From 001fed5efeedc34de9dfa1f8e4ab972c8be5b25a Mon Sep 17 00:00:00 2001
From: Youssef Victor <31348972+Youssef1313@users.noreply.github.com>
Date: Sun, 10 Jan 2021 23:05:27 +0200
Subject: [PATCH 001/444] Remove suppression

---
 .../Core/Source/ResultProvider/Helpers/HashFunctions.cs       | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/ExpressionEvaluator/Core/Source/ResultProvider/Helpers/HashFunctions.cs b/src/ExpressionEvaluator/Core/Source/ResultProvider/Helpers/HashFunctions.cs
index 9122dfb65c01b..214718ac9eb5c 100644
--- a/src/ExpressionEvaluator/Core/Source/ResultProvider/Helpers/HashFunctions.cs
+++ b/src/ExpressionEvaluator/Core/Source/ResultProvider/Helpers/HashFunctions.cs
@@ -2,18 +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.
 
-#nullable disable
-
 using Microsoft.CodeAnalysis;
 
 namespace Roslyn.Utilities
 {
-#pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
     /// <summary>
     /// Required by <see cref="CaseInsensitiveComparison"/>
     /// </summary>
     internal static class Hash
-#pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
     {
         internal const int FnvOffsetBias = unchecked((int)2166136261);
 

From 7771664aa1b94d266c8eb59d1316169fa3d69a2a Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Thu, 29 Apr 2021 21:23:39 -0700
Subject: [PATCH 002/444] Add OutVariableArgumentProvider for 'out' parameters

---
 .../ArgumentProviderOrderTests.cs             |  1 +
 .../ContextVariableArgumentProviderTests.cs   | 31 +++++++
 .../OutVariableArgumentProviderTests.cs       | 84 +++++++++++++++++++
 .../AbstractArgumentProviderTests`1.cs        |  2 +-
 .../ContextVariableArgumentProvider.cs        | 24 ++++++
 .../Providers/DefaultArgumentProvider.cs      |  2 +-
 .../Providers/OutVariableArgumentProvider.cs  | 63 ++++++++++++++
 7 files changed, 205 insertions(+), 2 deletions(-)
 create mode 100644 src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/OutVariableArgumentProviderTests.cs
 create mode 100644 src/Features/CSharp/Portable/Completion/Providers/OutVariableArgumentProvider.cs

diff --git a/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/ArgumentProviderOrderTests.cs b/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/ArgumentProviderOrderTests.cs
index d9a74abb17ea6..c1002dd079233 100644
--- a/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/ArgumentProviderOrderTests.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/ArgumentProviderOrderTests.cs
@@ -36,6 +36,7 @@ public void TestArgumentProviderOrder()
 
                 // Built-in providers
                 typeof(ContextVariableArgumentProvider),
+                typeof(OutVariableArgumentProvider),
                 typeof(DefaultArgumentProvider),
 
                 // Marker for end of built-in argument providers
diff --git a/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/ContextVariableArgumentProviderTests.cs b/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/ContextVariableArgumentProviderTests.cs
index d4903b595afa5..da4eb408377ee 100644
--- a/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/ContextVariableArgumentProviderTests.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/ContextVariableArgumentProviderTests.cs
@@ -41,6 +41,37 @@ void Target({type} arg)
             await VerifyDefaultValueAsync(markup, expectedDefaultValue: null, previousDefaultValue: "prior");
         }
 
+        [Theory]
+        [CombinatorialData]
+        public async Task TestOutVariable(
+            [CombinatorialValues("string", "bool", "int?")] string type,
+            [CombinatorialValues("out", "ref", "in")] string modifier)
+        {
+            var markup = $@"
+class C
+{{
+    void Method()
+    {{
+        {type} arg;
+        this.Target($$);
+    }}
+
+    void Target({modifier} {type} arg)
+    {{
+    }}
+}}
+";
+
+            var generatedModifier = modifier switch
+            {
+                "in" => "",
+                _ => $"{modifier} ",
+            };
+
+            await VerifyDefaultValueAsync(markup, $"{generatedModifier}arg");
+            await VerifyDefaultValueAsync(markup, expectedDefaultValue: null, previousDefaultValue: "prior");
+        }
+
         [Theory]
         [InlineData("string")]
         [InlineData("bool")]
diff --git a/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/OutVariableArgumentProviderTests.cs b/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/OutVariableArgumentProviderTests.cs
new file mode 100644
index 0000000000000..24108f82cabbd
--- /dev/null
+++ b/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/OutVariableArgumentProviderTests.cs
@@ -0,0 +1,84 @@
+// 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.Tasks;
+using Microsoft.CodeAnalysis.CSharp.Completion.Providers;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Completion.ArgumentProviders
+{
+    [Trait(Traits.Feature, Traits.Features.Completion)]
+    public class OutVariableArgumentProviderTests : AbstractCSharpArgumentProviderTests
+    {
+        internal override Type GetArgumentProviderType()
+            => typeof(OutVariableArgumentProvider);
+
+        [Theory]
+        [InlineData("")]
+        [InlineData("ref")]
+        [InlineData("in")]
+        public async Task TestUnsupportedModifiers(string modifier)
+        {
+            var markup = $@"
+class C
+{{
+    void Method()
+    {{
+        TryParse($$)
+    }}
+
+    bool TryParse({modifier} int value) => throw null;
+}}
+";
+
+            await VerifyDefaultValueAsync(markup, expectedDefaultValue: null);
+        }
+
+        [Fact]
+        public async Task TestDeclareVariable()
+        {
+            var markup = $@"
+class C
+{{
+    void Method()
+    {{
+        TryParse($$)
+    }}
+
+    bool TryParse(out int value) => throw null;
+}}
+";
+
+            await VerifyDefaultValueAsync(markup, "out var value");
+            await VerifyDefaultValueAsync(markup, expectedDefaultValue: null, previousDefaultValue: "prior");
+        }
+
+        [Theory]
+        [InlineData("string")]
+        [InlineData("bool")]
+        [InlineData("int?")]
+        public async Task TestDeclareVariableEscapedIdentifier(string type)
+        {
+            var markup = $@"
+class C
+{{
+    void Method()
+    {{
+        this.Target($$);
+    }}
+
+    void Target(out {type} @void)
+    {{
+        @void = default;
+    }}
+}}
+";
+
+            await VerifyDefaultValueAsync(markup, "out var @void");
+            await VerifyDefaultValueAsync(markup, expectedDefaultValue: null, previousDefaultValue: "prior");
+        }
+    }
+}
diff --git a/src/EditorFeatures/TestUtilities/Completion/AbstractArgumentProviderTests`1.cs b/src/EditorFeatures/TestUtilities/Completion/AbstractArgumentProviderTests`1.cs
index e57bde7378c16..31572163bb980 100644
--- a/src/EditorFeatures/TestUtilities/Completion/AbstractArgumentProviderTests`1.cs
+++ b/src/EditorFeatures/TestUtilities/Completion/AbstractArgumentProviderTests`1.cs
@@ -10,11 +10,11 @@
 using Microsoft.CodeAnalysis.Editor.UnitTests;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.VisualStudio.Composition;
 using Roslyn.Test.Utilities;
 using Roslyn.Utilities;
 using Xunit;
-using Microsoft.CodeAnalysis.Shared.Extensions;
 
 namespace Microsoft.CodeAnalysis.Test.Utilities.Completion
 {
diff --git a/src/Features/CSharp/Portable/Completion/Providers/ContextVariableArgumentProvider.cs b/src/Features/CSharp/Portable/Completion/Providers/ContextVariableArgumentProvider.cs
index 7666faf54b5ef..95c2ad546dc09 100644
--- a/src/Features/CSharp/Portable/Completion/Providers/ContextVariableArgumentProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/Providers/ContextVariableArgumentProvider.cs
@@ -4,6 +4,7 @@
 
 using System;
 using System.Composition;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Completion;
 using Microsoft.CodeAnalysis.Host.Mef;
 
@@ -19,5 +20,28 @@ internal sealed class ContextVariableArgumentProvider : AbstractContextVariableA
         public ContextVariableArgumentProvider()
         {
         }
+
+        public override async Task ProvideArgumentAsync(ArgumentContext context)
+        {
+            await base.ProvideArgumentAsync(context).ConfigureAwait(false);
+            if (context.DefaultValue is not null)
+            {
+                switch (context.Parameter.RefKind)
+                {
+                    case RefKind.Ref:
+                        context.DefaultValue = "ref " + context.DefaultValue;
+                        break;
+
+                    case RefKind.Out:
+                        context.DefaultValue = "out " + context.DefaultValue;
+                        break;
+
+                    case RefKind.In:
+                    case RefKind.None:
+                    default:
+                        break;
+                }
+            }
+        }
     }
 }
diff --git a/src/Features/CSharp/Portable/Completion/Providers/DefaultArgumentProvider.cs b/src/Features/CSharp/Portable/Completion/Providers/DefaultArgumentProvider.cs
index 242ffc9266704..87fcc97555f15 100644
--- a/src/Features/CSharp/Portable/Completion/Providers/DefaultArgumentProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/Providers/DefaultArgumentProvider.cs
@@ -12,7 +12,7 @@
 namespace Microsoft.CodeAnalysis.CSharp.Completion.Providers
 {
     [ExportArgumentProvider(nameof(DefaultArgumentProvider), LanguageNames.CSharp)]
-    [ExtensionOrder(After = nameof(ContextVariableArgumentProvider))]
+    [ExtensionOrder(After = nameof(OutVariableArgumentProvider))]
     [Shared]
     internal sealed class DefaultArgumentProvider : AbstractDefaultArgumentProvider
     {
diff --git a/src/Features/CSharp/Portable/Completion/Providers/OutVariableArgumentProvider.cs b/src/Features/CSharp/Portable/Completion/Providers/OutVariableArgumentProvider.cs
new file mode 100644
index 0000000000000..3ebc6db455ed4
--- /dev/null
+++ b/src/Features/CSharp/Portable/Completion/Providers/OutVariableArgumentProvider.cs
@@ -0,0 +1,63 @@
+// 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.Composition;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Completion;
+using Microsoft.CodeAnalysis.Host.Mef;
+
+namespace Microsoft.CodeAnalysis.CSharp.Completion.Providers
+{
+    [ExportArgumentProvider(nameof(OutVariableArgumentProvider), LanguageNames.CSharp)]
+    [ExtensionOrder(After = nameof(ContextVariableArgumentProvider))]
+    [Shared]
+    internal sealed class OutVariableArgumentProvider : ArgumentProvider
+    {
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public OutVariableArgumentProvider()
+        {
+        }
+
+        public override Task ProvideArgumentAsync(ArgumentContext context)
+        {
+            if (context.PreviousValue is not null)
+            {
+                // This argument provider does not attempt to replace arguments already in code.
+                return Task.CompletedTask;
+            }
+
+            if (context.Parameter.RefKind != RefKind.Out)
+            {
+                // This argument provider only considers 'out' parameters.
+                return Task.CompletedTask;
+            }
+
+            // Since tihs provider runs after ContextVariableArgumentProvider, we know there is no suitable target in
+            // the current context. Instead, offer to declare a new variable.
+            var name = context.Parameter.Name;
+            if (SyntaxFacts.GetKeywordKind(name) != SyntaxKind.None
+                || SyntaxFacts.GetContextualKeywordKind(name) != SyntaxKind.None)
+            {
+                name = "@" + name;
+            }
+
+            var syntax = SyntaxFactory.Argument(
+                nameColon: null,
+                refKindKeyword: SyntaxFactory.Token(SyntaxKind.OutKeyword),
+                SyntaxFactory.DeclarationExpression(
+                    type: SyntaxFactory.IdentifierName("var"),
+                    designation: SyntaxFactory.SingleVariableDesignation(SyntaxFactory.Identifier(
+                        SyntaxFactory.TriviaList(),
+                        contextualKind: SyntaxKind.None,
+                        text: name,
+                        valueText: context.Parameter.Name,
+                        SyntaxFactory.TriviaList()))));
+
+            context.DefaultValue = syntax.NormalizeWhitespace().ToFullString();
+            return Task.CompletedTask;
+        }
+    }
+}

From f97a9eca5f133414c20f6307225a6db783bc3e8f Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Fri, 30 Apr 2021 10:13:52 -0700
Subject: [PATCH 003/444] Support testing calls with multiple arguments

---
 .../AbstractCSharpArgumentProviderTests`1.cs  | 54 +++++++++++++++++++
 .../OutVariableArgumentProviderTests.cs       |  6 +--
 .../AbstractArgumentProviderTests`1.cs        | 10 ++--
 ...bstractVisualBasicArgumentProviderTests.vb | 51 ++++++++++++++++++
 4 files changed, 112 insertions(+), 9 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/AbstractCSharpArgumentProviderTests`1.cs b/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/AbstractCSharpArgumentProviderTests`1.cs
index b0409b04245fd..8c458f7e6c27f 100644
--- a/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/AbstractCSharpArgumentProviderTests`1.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/AbstractCSharpArgumentProviderTests`1.cs
@@ -2,8 +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 System.Collections.Immutable;
+using System.Linq;
+using System.Threading;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Test.Utilities.Completion;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Completion.ArgumentProviders
 {
@@ -11,5 +17,53 @@ public abstract class AbstractCSharpArgumentProviderTests<TWorkspaceFixture>
         : AbstractArgumentProviderTests<TWorkspaceFixture>
         where TWorkspaceFixture : TestWorkspaceFixture, new()
     {
+        protected override IParameterSymbol GetParameterSymbolInfo(SemanticModel semanticModel, SyntaxNode root, int position, CancellationToken cancellationToken)
+        {
+            var token = root.FindToken(position);
+            var argumentList = token.GetRequiredParent().GetAncestorsOrThis<BaseArgumentListSyntax>().First();
+            var symbols = semanticModel.GetSymbolInfo(argumentList.GetRequiredParent(), cancellationToken).GetAllSymbols();
+
+            // if more than one symbol is found, filter to only include symbols with a matching number of arguments
+            if (symbols.Length > 1)
+            {
+                symbols = symbols.WhereAsArray(
+                    symbol =>
+                    {
+                        var parameters = symbol.GetParameters();
+                        if (argumentList.Arguments.Count < GetMinimumArgumentCount(parameters))
+                            return false;
+
+                        if (argumentList.Arguments.Count > GetMaximumArgumentCount(parameters))
+                            return false;
+
+                        return true;
+                    });
+            }
+
+            var symbol = symbols.Single();
+            var parameters = symbol.GetParameters();
+
+            Contract.ThrowIfTrue(argumentList.Arguments.Any(argument => argument.NameColon is not null), "Named arguments are not currently supported by this test.");
+            Contract.ThrowIfTrue(parameters.Any(parameter => parameter.IsParams), "'params' parameters are not currently supported by this test.");
+
+            var index = argumentList.Arguments.Any()
+                ? argumentList.Arguments.IndexOf(argumentList.Arguments.Single(argument => argument.FullSpan.Start <= position && argument.FullSpan.End >= position))
+                : 0;
+
+            return parameters[index];
+        }
+
+        private static int GetMinimumArgumentCount(ImmutableArray<IParameterSymbol> parameters)
+        {
+            return parameters.Count(parameter => !parameter.IsOptional && !parameter.IsParams);
+        }
+
+        private static int GetMaximumArgumentCount(ImmutableArray<IParameterSymbol> parameters)
+        {
+            if (parameters.Any(parameter => parameter.IsParams))
+                return int.MaxValue;
+
+            return parameters.Length;
+        }
     }
 }
diff --git a/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/OutVariableArgumentProviderTests.cs b/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/OutVariableArgumentProviderTests.cs
index 24108f82cabbd..be7bb7c780fd6 100644
--- a/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/OutVariableArgumentProviderTests.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/OutVariableArgumentProviderTests.cs
@@ -45,14 +45,12 @@ class C
 {{
     void Method()
     {{
-        TryParse($$)
+        int.TryParse(""x"", $$)
     }}
-
-    bool TryParse(out int value) => throw null;
 }}
 ";
 
-            await VerifyDefaultValueAsync(markup, "out var value");
+            await VerifyDefaultValueAsync(markup, "out var result");
             await VerifyDefaultValueAsync(markup, expectedDefaultValue: null, previousDefaultValue: "prior");
         }
 
diff --git a/src/EditorFeatures/TestUtilities/Completion/AbstractArgumentProviderTests`1.cs b/src/EditorFeatures/TestUtilities/Completion/AbstractArgumentProviderTests`1.cs
index 31572163bb980..edc5b93eb90b1 100644
--- a/src/EditorFeatures/TestUtilities/Completion/AbstractArgumentProviderTests`1.cs
+++ b/src/EditorFeatures/TestUtilities/Completion/AbstractArgumentProviderTests`1.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -39,6 +40,8 @@ private protected ReferenceCountedDisposable<TWorkspaceFixture> GetOrCreateWorks
 
         internal abstract Type GetArgumentProviderType();
 
+        protected abstract IParameterSymbol GetParameterSymbolInfo(SemanticModel semanticModel, SyntaxNode root, int position, CancellationToken cancellationToken);
+
         protected virtual OptionSet WithChangedOptions(OptionSet options) => options;
 
         private protected async Task VerifyDefaultValueAsync(
@@ -60,13 +63,10 @@ private protected async Task VerifyDefaultValueAsync(
             Assert.IsType(GetArgumentProviderType(), provider);
 
             var root = await document.GetRequiredSyntaxRootAsync(CancellationToken.None);
-            var token = root.FindToken(position - 2);
             var semanticModel = await document.GetRequiredSemanticModelAsync(CancellationToken.None);
-            var symbolInfo = semanticModel.GetSymbolInfo(token.GetRequiredParent(), CancellationToken.None);
-            var target = symbolInfo.Symbol ?? symbolInfo.CandidateSymbols.Single();
-            Contract.ThrowIfNull(target);
+            var parameter = GetParameterSymbolInfo(semanticModel, root, position, CancellationToken.None);
+            Contract.ThrowIfNull(parameter);
 
-            var parameter = target.GetParameters().Single();
             var context = new ArgumentContext(provider, semanticModel, position, parameter, previousDefaultValue, CancellationToken.None);
             await provider.ProvideArgumentAsync(context);
 
diff --git a/src/EditorFeatures/VisualBasicTest/Completion/ArgumentProviders/AbstractVisualBasicArgumentProviderTests.vb b/src/EditorFeatures/VisualBasicTest/Completion/ArgumentProviders/AbstractVisualBasicArgumentProviderTests.vb
index 75d3678e35751..5f7aa19a5a71b 100644
--- a/src/EditorFeatures/VisualBasicTest/Completion/ArgumentProviders/AbstractVisualBasicArgumentProviderTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/Completion/ArgumentProviders/AbstractVisualBasicArgumentProviderTests.vb
@@ -2,11 +2,62 @@
 ' 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.Collections.Immutable
+Imports System.Threading
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
 Imports Microsoft.CodeAnalysis.Test.Utilities.Completion
+Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 
 Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Completion.ArgumentProviders
     Public MustInherit Class AbstractVisualBasicArgumentProviderTests
         Inherits AbstractArgumentProviderTests(Of VisualBasicTestWorkspaceFixture)
+
+        Protected Overrides Function GetParameterSymbolInfo(semanticModel As SemanticModel, root As SyntaxNode, position As Integer, cancellationToken As CancellationToken) As IParameterSymbol
+
+            Dim token = root.FindToken(position)
+            Dim argumentList = token.GetRequiredParent().GetAncestorsOrThis(Of ArgumentListSyntax)().First()
+            Dim symbols = semanticModel.GetSymbolInfo(argumentList.GetRequiredParent(), cancellationToken).GetAllSymbols()
+
+            ' if more than one symbol is found, filter to only include symbols with a matching number of arguments
+            If symbols.Length > 1 Then
+                symbols = symbols.WhereAsArray(
+                    Function(symbol1)
+                        Dim parameters1 = symbol1.GetParameters()
+                        If argumentList.Arguments.Count < GetMinimumArgumentCount(parameters1) Then
+                            Return False
+                        End If
+
+                        If argumentList.Arguments.Count > GetMaximumArgumentCount(parameters1) Then
+                            Return False
+                        End If
+
+                        Return True
+                    End Function)
+            End If
+
+            Dim symbol = symbols.Single()
+            Dim parameters = symbol.GetParameters()
+
+            Contract.ThrowIfTrue(argumentList.Arguments.Any(Function(argument) argument.IsNamed), "Named arguments are not currently supported by this test.")
+            Contract.ThrowIfTrue(parameters.Any(Function(parameter) parameter.IsParams), "'params' parameters are not currently supported by this test.")
+
+            Dim index = If(argumentList.Arguments.Any(),
+                argumentList.Arguments.IndexOf(argumentList.Arguments.Single(Function(argument) argument.FullSpan.Start <= position AndAlso argument.FullSpan.End >= position)),
+                0)
+
+            Return parameters(index)
+        End Function
+
+        Private Shared Function GetMinimumArgumentCount(parameters As ImmutableArray(Of IParameterSymbol)) As Integer
+            Return parameters.Count(Function(parameter) Not parameter.IsOptional AndAlso Not parameter.IsParams)
+        End Function
+
+        Private Shared Function GetMaximumArgumentCount(parameters As ImmutableArray(Of IParameterSymbol)) As Integer
+            If parameters.Any(Function(parameter) parameter.IsParams) Then
+                Return Integer.MaxValue
+            End If
+
+            Return parameters.Length
+        End Function
     End Class
 End Namespace

From 9be420e18fa5c58c2c719da397eb84c84f4632d0 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Fri, 30 Apr 2021 10:25:02 -0700
Subject: [PATCH 004/444] Share code for implementation of
 GetParameterSymbolInfo

---
 .../AbstractCSharpArgumentProviderTests`1.cs  | 48 +-----------------
 .../AbstractArgumentProviderTests`1.cs        | 49 ++++++++++++++++++-
 ...bstractVisualBasicArgumentProviderTests.vb | 48 +-----------------
 3 files changed, 51 insertions(+), 94 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/AbstractCSharpArgumentProviderTests`1.cs b/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/AbstractCSharpArgumentProviderTests`1.cs
index 8c458f7e6c27f..963c0f457e37e 100644
--- a/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/AbstractCSharpArgumentProviderTests`1.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/AbstractCSharpArgumentProviderTests`1.cs
@@ -4,7 +4,6 @@
 
 using System.Collections.Immutable;
 using System.Linq;
-using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Shared.Extensions;
@@ -17,53 +16,10 @@ public abstract class AbstractCSharpArgumentProviderTests<TWorkspaceFixture>
         : AbstractArgumentProviderTests<TWorkspaceFixture>
         where TWorkspaceFixture : TestWorkspaceFixture, new()
     {
-        protected override IParameterSymbol GetParameterSymbolInfo(SemanticModel semanticModel, SyntaxNode root, int position, CancellationToken cancellationToken)
+        protected override (SyntaxNode argumentList, ImmutableArray<SyntaxNode> arguments) GetArgumentList(SyntaxToken token)
         {
-            var token = root.FindToken(position);
             var argumentList = token.GetRequiredParent().GetAncestorsOrThis<BaseArgumentListSyntax>().First();
-            var symbols = semanticModel.GetSymbolInfo(argumentList.GetRequiredParent(), cancellationToken).GetAllSymbols();
-
-            // if more than one symbol is found, filter to only include symbols with a matching number of arguments
-            if (symbols.Length > 1)
-            {
-                symbols = symbols.WhereAsArray(
-                    symbol =>
-                    {
-                        var parameters = symbol.GetParameters();
-                        if (argumentList.Arguments.Count < GetMinimumArgumentCount(parameters))
-                            return false;
-
-                        if (argumentList.Arguments.Count > GetMaximumArgumentCount(parameters))
-                            return false;
-
-                        return true;
-                    });
-            }
-
-            var symbol = symbols.Single();
-            var parameters = symbol.GetParameters();
-
-            Contract.ThrowIfTrue(argumentList.Arguments.Any(argument => argument.NameColon is not null), "Named arguments are not currently supported by this test.");
-            Contract.ThrowIfTrue(parameters.Any(parameter => parameter.IsParams), "'params' parameters are not currently supported by this test.");
-
-            var index = argumentList.Arguments.Any()
-                ? argumentList.Arguments.IndexOf(argumentList.Arguments.Single(argument => argument.FullSpan.Start <= position && argument.FullSpan.End >= position))
-                : 0;
-
-            return parameters[index];
-        }
-
-        private static int GetMinimumArgumentCount(ImmutableArray<IParameterSymbol> parameters)
-        {
-            return parameters.Count(parameter => !parameter.IsOptional && !parameter.IsParams);
-        }
-
-        private static int GetMaximumArgumentCount(ImmutableArray<IParameterSymbol> parameters)
-        {
-            if (parameters.Any(parameter => parameter.IsParams))
-                return int.MaxValue;
-
-            return parameters.Length;
+            return (argumentList, argumentList.Arguments.ToImmutableArray<SyntaxNode>());
         }
     }
 }
diff --git a/src/EditorFeatures/TestUtilities/Completion/AbstractArgumentProviderTests`1.cs b/src/EditorFeatures/TestUtilities/Completion/AbstractArgumentProviderTests`1.cs
index edc5b93eb90b1..85f824cb48700 100644
--- a/src/EditorFeatures/TestUtilities/Completion/AbstractArgumentProviderTests`1.cs
+++ b/src/EditorFeatures/TestUtilities/Completion/AbstractArgumentProviderTests`1.cs
@@ -10,6 +10,7 @@
 using Microsoft.CodeAnalysis.Completion;
 using Microsoft.CodeAnalysis.Editor.UnitTests;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
+using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.VisualStudio.Composition;
@@ -40,7 +41,7 @@ private protected ReferenceCountedDisposable<TWorkspaceFixture> GetOrCreateWorks
 
         internal abstract Type GetArgumentProviderType();
 
-        protected abstract IParameterSymbol GetParameterSymbolInfo(SemanticModel semanticModel, SyntaxNode root, int position, CancellationToken cancellationToken);
+        protected abstract (SyntaxNode argumentList, ImmutableArray<SyntaxNode> arguments) GetArgumentList(SyntaxToken token);
 
         protected virtual OptionSet WithChangedOptions(OptionSet options) => options;
 
@@ -64,7 +65,7 @@ private protected async Task VerifyDefaultValueAsync(
 
             var root = await document.GetRequiredSyntaxRootAsync(CancellationToken.None);
             var semanticModel = await document.GetRequiredSemanticModelAsync(CancellationToken.None);
-            var parameter = GetParameterSymbolInfo(semanticModel, root, position, CancellationToken.None);
+            var parameter = GetParameterSymbolInfo(workspace, semanticModel, root, position, CancellationToken.None);
             Contract.ThrowIfNull(parameter);
 
             var context = new ArgumentContext(provider, semanticModel, position, parameter, previousDefaultValue, CancellationToken.None);
@@ -72,5 +73,49 @@ private protected async Task VerifyDefaultValueAsync(
 
             Assert.Equal(expectedDefaultValue, context.DefaultValue);
         }
+
+        private IParameterSymbol GetParameterSymbolInfo(Workspace workspace, SemanticModel semanticModel, SyntaxNode root, int position, CancellationToken cancellationToken)
+        {
+            var token = root.FindToken(position);
+            var (argumentList, arguments) = GetArgumentList(token);
+            var symbols = semanticModel.GetSymbolInfo(argumentList.GetRequiredParent(), cancellationToken).GetAllSymbols();
+
+            // if more than one symbol is found, filter to only include symbols with a matching number of arguments
+            if (symbols.Length > 1)
+            {
+                symbols = symbols.WhereAsArray(
+                    symbol =>
+                    {
+                        var parameters = symbol.GetParameters();
+                        if (arguments.Length < GetMinimumArgumentCount(parameters))
+                            return false;
+
+                        if (arguments.Length > GetMaximumArgumentCount(parameters))
+                            return false;
+
+                        return true;
+                    });
+            }
+
+            var symbol = symbols.Single();
+            var parameters = symbol.GetParameters();
+
+            var syntaxFacts = workspace.Services.GetLanguageServices(root.Language).GetRequiredService<ISyntaxFactsService>();
+            Contract.ThrowIfTrue(arguments.Any(argument => syntaxFacts.IsNamedArgument(argument)), "Named arguments are not currently supported by this test.");
+            Contract.ThrowIfTrue(parameters.Any(parameter => parameter.IsParams), "'params' parameters are not currently supported by this test.");
+
+            var index = arguments.Any()
+                ? arguments.IndexOf(arguments.Single(argument => argument.FullSpan.Start <= position && argument.FullSpan.End >= position))
+                : 0;
+
+            return parameters[index];
+
+            // Local functions
+            static int GetMinimumArgumentCount(ImmutableArray<IParameterSymbol> parameters)
+                => parameters.Count(parameter => !parameter.IsOptional && !parameter.IsParams);
+
+            static int GetMaximumArgumentCount(ImmutableArray<IParameterSymbol> parameters)
+                => parameters.Any(parameter => parameter.IsParams) ? int.MaxValue : parameters.Length;
+        }
     }
 }
diff --git a/src/EditorFeatures/VisualBasicTest/Completion/ArgumentProviders/AbstractVisualBasicArgumentProviderTests.vb b/src/EditorFeatures/VisualBasicTest/Completion/ArgumentProviders/AbstractVisualBasicArgumentProviderTests.vb
index 5f7aa19a5a71b..b5eb9fe055c5c 100644
--- a/src/EditorFeatures/VisualBasicTest/Completion/ArgumentProviders/AbstractVisualBasicArgumentProviderTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/Completion/ArgumentProviders/AbstractVisualBasicArgumentProviderTests.vb
@@ -3,7 +3,6 @@
 ' See the LICENSE file in the project root for more information.
 
 Imports System.Collections.Immutable
-Imports System.Threading
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
 Imports Microsoft.CodeAnalysis.Test.Utilities.Completion
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
@@ -12,52 +11,9 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Completion.Argumen
     Public MustInherit Class AbstractVisualBasicArgumentProviderTests
         Inherits AbstractArgumentProviderTests(Of VisualBasicTestWorkspaceFixture)
 
-        Protected Overrides Function GetParameterSymbolInfo(semanticModel As SemanticModel, root As SyntaxNode, position As Integer, cancellationToken As CancellationToken) As IParameterSymbol
-
-            Dim token = root.FindToken(position)
+        Protected Overrides Function GetArgumentList(token As SyntaxToken) As (argumentList As SyntaxNode, arguments As ImmutableArray(Of SyntaxNode))
             Dim argumentList = token.GetRequiredParent().GetAncestorsOrThis(Of ArgumentListSyntax)().First()
-            Dim symbols = semanticModel.GetSymbolInfo(argumentList.GetRequiredParent(), cancellationToken).GetAllSymbols()
-
-            ' if more than one symbol is found, filter to only include symbols with a matching number of arguments
-            If symbols.Length > 1 Then
-                symbols = symbols.WhereAsArray(
-                    Function(symbol1)
-                        Dim parameters1 = symbol1.GetParameters()
-                        If argumentList.Arguments.Count < GetMinimumArgumentCount(parameters1) Then
-                            Return False
-                        End If
-
-                        If argumentList.Arguments.Count > GetMaximumArgumentCount(parameters1) Then
-                            Return False
-                        End If
-
-                        Return True
-                    End Function)
-            End If
-
-            Dim symbol = symbols.Single()
-            Dim parameters = symbol.GetParameters()
-
-            Contract.ThrowIfTrue(argumentList.Arguments.Any(Function(argument) argument.IsNamed), "Named arguments are not currently supported by this test.")
-            Contract.ThrowIfTrue(parameters.Any(Function(parameter) parameter.IsParams), "'params' parameters are not currently supported by this test.")
-
-            Dim index = If(argumentList.Arguments.Any(),
-                argumentList.Arguments.IndexOf(argumentList.Arguments.Single(Function(argument) argument.FullSpan.Start <= position AndAlso argument.FullSpan.End >= position)),
-                0)
-
-            Return parameters(index)
-        End Function
-
-        Private Shared Function GetMinimumArgumentCount(parameters As ImmutableArray(Of IParameterSymbol)) As Integer
-            Return parameters.Count(Function(parameter) Not parameter.IsOptional AndAlso Not parameter.IsParams)
-        End Function
-
-        Private Shared Function GetMaximumArgumentCount(parameters As ImmutableArray(Of IParameterSymbol)) As Integer
-            If parameters.Any(Function(parameter) parameter.IsParams) Then
-                Return Integer.MaxValue
-            End If
-
-            Return parameters.Length
+            Return (argumentList, argumentList.Arguments.Cast(Of SyntaxNode)().ToImmutableArray())
         End Function
     End Class
 End Namespace

From 550db94490261b336b1df5bac7180853de4f87ab Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Fri, 30 Apr 2021 10:36:51 -0700
Subject: [PATCH 005/444] Prepare to support type style options in argument
 providers

---
 .../OutVariableArgumentProviderTests.cs       | 57 +++++++++++++++++++
 .../AbstractArgumentProviderTests`1.cs        | 16 +++++-
 .../Portable/Completion/ArgumentContext.cs    |  8 +++
 .../AbstractSnippetExpansionClient.cs         |  3 +-
 4 files changed, 80 insertions(+), 4 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/OutVariableArgumentProviderTests.cs b/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/OutVariableArgumentProviderTests.cs
index be7bb7c780fd6..73f8255bd6251 100644
--- a/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/OutVariableArgumentProviderTests.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/OutVariableArgumentProviderTests.cs
@@ -4,7 +4,10 @@
 
 using System;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Completion.Providers;
+using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Xunit;
 
@@ -13,6 +16,28 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Completion.ArgumentProv
     [Trait(Traits.Feature, Traits.Features.Completion)]
     public class OutVariableArgumentProviderTests : AbstractCSharpArgumentProviderTests
     {
+        private static readonly OptionsCollection s_useExplicitTypeOptions = new(LanguageNames.CSharp)
+        {
+            { CSharpCodeStyleOptions.VarForBuiltInTypes, false },
+            { CSharpCodeStyleOptions.VarWhenTypeIsApparent, false },
+            { CSharpCodeStyleOptions.VarElsewhere, false },
+        };
+
+        private static readonly OptionsCollection s_useExplicitMetadataTypeOptions = new(LanguageNames.CSharp)
+        {
+            { CSharpCodeStyleOptions.VarForBuiltInTypes, false },
+            { CSharpCodeStyleOptions.VarWhenTypeIsApparent, false },
+            { CSharpCodeStyleOptions.VarElsewhere, false },
+            { CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, false },
+        };
+
+        private static readonly OptionsCollection s_useImplicitTypeOptions = new(LanguageNames.CSharp)
+        {
+            { CSharpCodeStyleOptions.VarForBuiltInTypes, true },
+            { CSharpCodeStyleOptions.VarWhenTypeIsApparent, true },
+            { CSharpCodeStyleOptions.VarElsewhere, true },
+        };
+
         internal override Type GetArgumentProviderType()
             => typeof(OutVariableArgumentProvider);
 
@@ -54,6 +79,38 @@ void Method()
             await VerifyDefaultValueAsync(markup, expectedDefaultValue: null, previousDefaultValue: "prior");
         }
 
+        [Theory(Skip = "https://github.com/dotnet/roslyn/issues/53056")]
+        [CombinatorialData]
+        public async Task TestDeclareVariableBuiltInType(bool preferVar, bool preferBuiltInType)
+        {
+            var markup = $@"
+using System;
+class C
+{{
+    void Method()
+    {{
+        int.TryParse(""x"", $$)
+    }}
+}}
+";
+
+            var expected = (preferVar, preferBuiltInType) switch
+            {
+                (true, _) => "out var result",
+                (false, true) => "out int result",
+                (false, false) => "out Int32 result",
+            };
+
+            var options = (preferVar, preferBuiltInType) switch
+            {
+                (true, _) => s_useImplicitTypeOptions,
+                (false, true) => s_useExplicitTypeOptions,
+                (false, false) => s_useExplicitMetadataTypeOptions,
+            };
+
+            await VerifyDefaultValueAsync(markup, expected, options: options);
+        }
+
         [Theory]
         [InlineData("string")]
         [InlineData("bool")]
diff --git a/src/EditorFeatures/TestUtilities/Completion/AbstractArgumentProviderTests`1.cs b/src/EditorFeatures/TestUtilities/Completion/AbstractArgumentProviderTests`1.cs
index 85f824cb48700..ac23d353e45b4 100644
--- a/src/EditorFeatures/TestUtilities/Completion/AbstractArgumentProviderTests`1.cs
+++ b/src/EditorFeatures/TestUtilities/Completion/AbstractArgumentProviderTests`1.cs
@@ -9,6 +9,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Completion;
 using Microsoft.CodeAnalysis.Editor.UnitTests;
+using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.Options;
@@ -48,7 +49,8 @@ private protected ReferenceCountedDisposable<TWorkspaceFixture> GetOrCreateWorks
         private protected async Task VerifyDefaultValueAsync(
             string markup,
             string? expectedDefaultValue,
-            string? previousDefaultValue = null)
+            string? previousDefaultValue = null,
+            OptionsCollection? options = null)
         {
             using var workspaceFixture = GetOrCreateWorkspaceFixture();
 
@@ -56,7 +58,14 @@ private protected async Task VerifyDefaultValueAsync(
             var code = workspaceFixture.Target.Code;
             var position = workspaceFixture.Target.Position;
 
-            workspace.SetOptions(WithChangedOptions(workspace.Options));
+            var changedOptions = WithChangedOptions(workspace.Options);
+            if (options is not null)
+            {
+                foreach (var option in options)
+                    changedOptions = changedOptions.WithChangedOption(option.Key, option.Value);
+            }
+
+            workspace.SetOptions(changedOptions);
 
             var document = workspaceFixture.Target.UpdateDocument(code, SourceCodeKind.Regular);
 
@@ -64,11 +73,12 @@ private protected async Task VerifyDefaultValueAsync(
             Assert.IsType(GetArgumentProviderType(), provider);
 
             var root = await document.GetRequiredSyntaxRootAsync(CancellationToken.None);
+            var documentOptions = await document.GetOptionsAsync(CancellationToken.None);
             var semanticModel = await document.GetRequiredSemanticModelAsync(CancellationToken.None);
             var parameter = GetParameterSymbolInfo(workspace, semanticModel, root, position, CancellationToken.None);
             Contract.ThrowIfNull(parameter);
 
-            var context = new ArgumentContext(provider, semanticModel, position, parameter, previousDefaultValue, CancellationToken.None);
+            var context = new ArgumentContext(provider, documentOptions, semanticModel, position, parameter, previousDefaultValue, CancellationToken.None);
             await provider.ProvideArgumentAsync(context);
 
             Assert.Equal(expectedDefaultValue, context.DefaultValue);
diff --git a/src/Features/Core/Portable/Completion/ArgumentContext.cs b/src/Features/Core/Portable/Completion/ArgumentContext.cs
index 4edb328201163..7f88525a5139a 100644
--- a/src/Features/Core/Portable/Completion/ArgumentContext.cs
+++ b/src/Features/Core/Portable/Completion/ArgumentContext.cs
@@ -4,6 +4,7 @@
 
 using System;
 using System.Threading;
+using Microsoft.CodeAnalysis.Options;
 
 namespace Microsoft.CodeAnalysis.Completion
 {
@@ -14,6 +15,7 @@ internal sealed class ArgumentContext
     {
         public ArgumentContext(
             ArgumentProvider provider,
+            OptionSet options,
             SemanticModel semanticModel,
             int position,
             IParameterSymbol parameter,
@@ -21,6 +23,7 @@ public ArgumentContext(
             CancellationToken cancellationToken)
         {
             Provider = provider ?? throw new ArgumentNullException(nameof(provider));
+            Options = options ?? throw new ArgumentNullException(nameof(options));
             SemanticModel = semanticModel ?? throw new ArgumentNullException(nameof(semanticModel));
             Position = position;
             Parameter = parameter ?? throw new ArgumentNullException(nameof(parameter));
@@ -30,6 +33,11 @@ public ArgumentContext(
 
         internal ArgumentProvider Provider { get; }
 
+        /// <summary>
+        /// Gets the effective options where argument completion is requested.
+        /// </summary>
+        public OptionSet Options { get; }
+
         /// <summary>
         /// Gets the semantic model where argument completion is requested.
         /// </summary>
diff --git a/src/VisualStudio/Core/Def/Implementation/Snippets/AbstractSnippetExpansionClient.cs b/src/VisualStudio/Core/Def/Implementation/Snippets/AbstractSnippetExpansionClient.cs
index 98e880c9fa3e2..2bcd156b052c4 100644
--- a/src/VisualStudio/Core/Def/Implementation/Snippets/AbstractSnippetExpansionClient.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Snippets/AbstractSnippetExpansionClient.cs
@@ -868,6 +868,7 @@ public void MoveToSpecificMethod(IMethodSymbol method, CancellationToken cancell
             }
 
             // Now compute the new arguments for the new call
+            var options = document.GetOptionsAsync(cancellationToken).WaitAndGetResult(cancellationToken);
             var semanticModel = document.GetRequiredSemanticModelAsync(cancellationToken).AsTask().WaitAndGetResult(cancellationToken);
             var position = SubjectBuffer.CurrentSnapshot.GetPosition(adjustedTextSpan.iStartLine, adjustedTextSpan.iStartIndex);
 
@@ -877,7 +878,7 @@ public void MoveToSpecificMethod(IMethodSymbol method, CancellationToken cancell
 
                 foreach (var provider in GetArgumentProviders(document.Project.Solution.Workspace))
                 {
-                    var context = new ArgumentContext(provider, semanticModel, position, parameter, value, cancellationToken);
+                    var context = new ArgumentContext(provider, options, semanticModel, position, parameter, value, cancellationToken);
                     ThreadingContext.JoinableTaskFactory.Run(() => provider.ProvideArgumentAsync(context));
 
                     if (context.DefaultValue is not null)

From 8875438681cad26bca66cd3ec715c2bdcdbc5211 Mon Sep 17 00:00:00 2001
From: Youssef1313 <youssefvictor00@gmail.com>
Date: Tue, 11 May 2021 16:21:14 +0200
Subject: [PATCH 006/444] Fix code generation to add default constraint when
 needed

---
 .../GenerateOverridesTests.cs                 | 30 ++++++++++
 .../ImplementAbstractClassTests.cs            | 29 ++++++++++
 .../ImplementInterfaceTests.cs                | 56 +++++++++++++++++++
 .../CodeGeneration/MethodGenerator.cs         | 25 ++++++++-
 4 files changed, 139 insertions(+), 1 deletion(-)

diff --git a/src/EditorFeatures/CSharpTest/GenerateOverrides/GenerateOverridesTests.cs b/src/EditorFeatures/CSharpTest/GenerateOverrides/GenerateOverridesTests.cs
index 3db5264978e21..e98f9c7673c09 100644
--- a/src/EditorFeatures/CSharpTest/GenerateOverrides/GenerateOverridesTests.cs
+++ b/src/EditorFeatures/CSharpTest/GenerateOverrides/GenerateOverridesTests.cs
@@ -220,5 +220,35 @@ static class [||]C
     
 }");
         }
+
+        [WorkItem(53012, "https://github.com/dotnet/roslyn/issues/53012")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
+        public async Task TestNullableTypeParameter()
+        {
+            await TestWithPickMembersDialogAsync(
+@"class C
+{
+    public virtual void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d) {}
+}
+
+class D : C
+{
+    [||]
+}",
+@"class C
+{
+    public virtual void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d) {}
+}
+
+class D : C
+{
+    public override void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d)
+        where T1 : default
+        where T3 : default
+    {
+        base.M(a, b, c, d);
+    }
+}", new[] { "M" });
+        }
     }
 }
diff --git a/src/EditorFeatures/CSharpTest/ImplementAbstractClass/ImplementAbstractClassTests.cs b/src/EditorFeatures/CSharpTest/ImplementAbstractClass/ImplementAbstractClassTests.cs
index 15061953a2233..603d5ac8f790b 100644
--- a/src/EditorFeatures/CSharpTest/ImplementAbstractClass/ImplementAbstractClassTests.cs
+++ b/src/EditorFeatures/CSharpTest/ImplementAbstractClass/ImplementAbstractClassTests.cs
@@ -1911,5 +1911,34 @@ public override void AbstractMethod()
     }
 }", parseOptions: TestOptions.RegularPreview);
         }
+
+        [WorkItem(53012, "https://github.com/dotnet/roslyn/issues/53012")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementAbstractClass)]
+        public async Task TestNullableGenericType()
+        {
+            await TestAllOptionsOffAsync(
+@"abstract class C
+{
+    public abstract void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d);
+}
+
+class [|D|] : C
+{
+}",
+@"abstract class C
+{
+    public abstract void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d);
+}
+
+class D : C
+{
+    public override void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d)
+        where T1 : default
+        where T3 : default
+    {
+        throw new System.NotImplementedException();
+    }
+}");
+        }
     }
 }
diff --git a/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs b/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs
index 8e20dbcb817b8..33816f3f3f3e4 100644
--- a/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs
+++ b/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs
@@ -8941,5 +8941,61 @@ public void Bar(string? x)
 }
 ");
         }
+
+        [WorkItem(53012, "https://github.com/dotnet/roslyn/issues/53012")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
+        public async Task TestNullableTypeParameter()
+        {
+            await TestInRegularAndScriptAsync(
+@"interface I
+{
+    void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d);
+}
+
+class D : [|I|]
+{
+}",
+@"interface I
+{
+    void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d);
+}
+
+class D : I
+{
+    public void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d)
+    {
+        throw new System.NotImplementedException();
+    }
+}");
+        }
+
+        [WorkItem(53012, "https://github.com/dotnet/roslyn/issues/53012")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
+        public async Task TestNullableTypeParameter_ExplicitInterfaceImplementation()
+        {
+            await TestInRegularAndScriptAsync(
+@"interface I
+{
+    void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d);
+}
+
+class D : [|I|]
+{
+}",
+@"interface I
+{
+    void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d);
+}
+
+class D : I
+{
+    void I.M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d)
+        where T1 : default
+        where T3 : default
+    {
+        throw new System.NotImplementedException();
+    }
+}", index: 1);
+        }
     }
 }
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
index bf8f904398b2b..fd0f63655b079 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
@@ -5,6 +5,8 @@
 #nullable disable
 
 using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Diagnostics;
 using System.Linq;
 using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
@@ -206,7 +208,28 @@ private static SyntaxList<TypeParameterConstraintClauseSyntax> GenerateConstrain
         {
             return !method.ExplicitInterfaceImplementations.Any() && !method.IsOverride
                 ? method.TypeParameters.GenerateConstraintClauses()
-                : default;
+                : GenerateDefaultConstraints(method);
+        }
+
+        private static SyntaxList<TypeParameterConstraintClauseSyntax> GenerateDefaultConstraints(IMethodSymbol method)
+        {
+            Debug.Assert(method.ExplicitInterfaceImplementations.Any() || method.IsOverride);
+            var seenTypeParameters = new HashSet<string>();
+            var listOfClauses = new List<TypeParameterConstraintClauseSyntax>(method.TypeParameters.Length);
+            foreach (var parameter in method.Parameters)
+            {
+                if (parameter.Type is not { TypeKind: TypeKind.TypeParameter, NullableAnnotation: NullableAnnotation.Annotated } ||
+                    !seenTypeParameters.Add(parameter.Type.Name))
+                {
+                    continue;
+                }
+
+                listOfClauses.Add(SyntaxFactory.TypeParameterConstraintClause(
+                    name: SyntaxFactory.IdentifierName(parameter.Type.Name),
+                    constraints: SyntaxFactory.SingletonSeparatedList((TypeParameterConstraintSyntax)SyntaxFactory.DefaultConstraint())));
+            }
+
+            return SyntaxFactory.List(listOfClauses);
         }
 
         private static TypeParameterListSyntax GenerateTypeParameterList(

From 65170e742fefb041dc34e985b60c152afa2358e6 Mon Sep 17 00:00:00 2001
From: Youssef1313 <youssefvictor00@gmail.com>
Date: Tue, 11 May 2021 16:24:34 +0200
Subject: [PATCH 007/444] Remove unused using

---
 src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
index fd0f63655b079..dc19a0078eca5 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
@@ -5,7 +5,6 @@
 #nullable disable
 
 using System.Collections.Generic;
-using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Linq;
 using Microsoft.CodeAnalysis.CodeGeneration;

From b145143fe5bde7403f30c7f7de2cee16f11758fb Mon Sep 17 00:00:00 2001
From: Youssef1313 <youssefvictor00@gmail.com>
Date: Tue, 11 May 2021 18:52:50 +0200
Subject: [PATCH 008/444] Fix implementation

---
 .../CodeGeneration/MethodGenerator.cs         | 20 ++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
index dc19a0078eca5..9d2d44b917ca5 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
@@ -217,15 +217,29 @@ private static SyntaxList<TypeParameterConstraintClauseSyntax> GenerateDefaultCo
             var listOfClauses = new List<TypeParameterConstraintClauseSyntax>(method.TypeParameters.Length);
             foreach (var parameter in method.Parameters)
             {
-                if (parameter.Type is not { TypeKind: TypeKind.TypeParameter, NullableAnnotation: NullableAnnotation.Annotated } ||
+                if (parameter.Type is not ITypeParameterSymbol { NullableAnnotation: NullableAnnotation.Annotated } typeParameter ||
                     !seenTypeParameters.Add(parameter.Type.Name))
                 {
                     continue;
                 }
 
+                TypeParameterConstraintSyntax constraint = null;
+                if (typeParameter.HasReferenceTypeConstraint)
+                {
+                    constraint = SyntaxFactory.ClassOrStructConstraint(SyntaxKind.ClassConstraint);
+                }
+                else if (typeParameter.HasValueTypeConstraint)
+                {
+                    constraint = SyntaxFactory.ClassOrStructConstraint(SyntaxKind.StructConstraint);
+                }
+                else
+                {
+                    constraint = SyntaxFactory.DefaultConstraint();
+                }
+
                 listOfClauses.Add(SyntaxFactory.TypeParameterConstraintClause(
-                    name: SyntaxFactory.IdentifierName(parameter.Type.Name),
-                    constraints: SyntaxFactory.SingletonSeparatedList((TypeParameterConstraintSyntax)SyntaxFactory.DefaultConstraint())));
+                    name: parameter.Type.Name.ToIdentifierName(),
+                    constraints: SyntaxFactory.SingletonSeparatedList(constraint)));
             }
 
             return SyntaxFactory.List(listOfClauses);

From 2df4a5463de47845bdedc95163ed41e2f298bd97 Mon Sep 17 00:00:00 2001
From: Youssef1313 <youssefvictor00@gmail.com>
Date: Tue, 11 May 2021 19:17:26 +0200
Subject: [PATCH 009/444] Add test

---
 .../ImplementInterfaceTests.cs                | 33 +++++++++++++++++++
 .../CodeGeneration/MethodGenerator.cs         |  2 +-
 2 files changed, 34 insertions(+), 1 deletion(-)

diff --git a/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs b/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs
index 33816f3f3f3e4..d5f453dcb6717 100644
--- a/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs
+++ b/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs
@@ -8995,6 +8995,39 @@ void I.M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d)
     {
         throw new System.NotImplementedException();
     }
+}", index: 1);
+        }
+
+        [WorkItem(53012, "https://github.com/dotnet/roslyn/issues/53012")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
+        public async Task TestNullableTypeParameter_ExplicitInterfaceImplementationWithClassConstraint()
+        {
+            await TestInRegularAndScriptAsync(
+@"#nullable enable
+
+interface I
+{
+    void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d) where T1 : class;
+}
+
+class D : [|I|]
+{
+}",
+@"#nullable enable
+
+interface I
+{
+    void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d) where T1 : class;
+}
+
+class D : I
+{
+    void I.M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d)
+        where T1 : class
+        where T3 : default
+    {
+        throw new System.NotImplementedException();
+    }
 }", index: 1);
         }
     }
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
index 9d2d44b917ca5..5a2a96d2bb1a8 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
@@ -223,7 +223,7 @@ private static SyntaxList<TypeParameterConstraintClauseSyntax> GenerateDefaultCo
                     continue;
                 }
 
-                TypeParameterConstraintSyntax constraint = null;
+                TypeParameterConstraintSyntax constraint;
                 if (typeParameter.HasReferenceTypeConstraint)
                 {
                     constraint = SyntaxFactory.ClassOrStructConstraint(SyntaxKind.ClassConstraint);

From 042d1086bb89b75fc08f3a40127c0ca47bf89301 Mon Sep 17 00:00:00 2001
From: Youssef Victor <youssefvictor00@gmail.com>
Date: Tue, 22 Jun 2021 21:15:37 +0200
Subject: [PATCH 010/444] Update ImplementAbstractClassTests.cs

---
 .../ImplementAbstractClassTests.cs            | 21 +++++++++----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/ImplementAbstractClass/ImplementAbstractClassTests.cs b/src/EditorFeatures/CSharpTest/ImplementAbstractClass/ImplementAbstractClassTests.cs
index e46dc15b9bca1..5f894a5d0e51f 100644
--- a/src/EditorFeatures/CSharpTest/ImplementAbstractClass/ImplementAbstractClassTests.cs
+++ b/src/EditorFeatures/CSharpTest/ImplementAbstractClass/ImplementAbstractClassTests.cs
@@ -2042,21 +2042,20 @@ class D<T> : B<{passToBase}>{constraint}
         }
 
         [WorkItem(53012, "https://github.com/dotnet/roslyn/issues/53012")]
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
-        public async Task TestNullableTypeParameter()
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementAbstractClass)]
+        public async Task TestNullableGenericType()
         {
-            await TestWithPickMembersDialogAsync(
-@"class C
+            await TestAllOptionsOffAsync(
+@"abstract class C
 {
-    public virtual void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d) {}
+    public abstract void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d);
 }
-class D : C
+class [|D|] : C
 {
-    [||]
 }",
-@"class C
+@"abstract class C
 {
-    public virtual void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d) {}
+    public abstract void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d);
 }
 class D : C
 {
@@ -2064,9 +2063,9 @@ public override void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d)
         where T1 : default
         where T3 : default
     {
-        base.M(a, b, c, d);
+        throw new System.NotImplementedException();
     }
-}", new[] { "M" });
+}");
         }
     }
 }

From e080d077129b3f89e48d0d5c708fdedd31fbcfdf Mon Sep 17 00:00:00 2001
From: Youssef1313 <youssefvictor00@gmail.com>
Date: Tue, 22 Jun 2021 21:34:58 +0200
Subject: [PATCH 011/444] Feedback

---
 .../CodeGeneration/MethodGenerator.cs         | 30 ++++++++++---------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
index 5a2a96d2bb1a8..65084de492b8e 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
@@ -20,6 +20,10 @@ namespace Microsoft.CodeAnalysis.CSharp.CodeGeneration
 {
     internal static class MethodGenerator
     {
+        private static readonly TypeParameterConstraintSyntax s_classConstraint = SyntaxFactory.ClassOrStructConstraint(SyntaxKind.ClassConstraint);
+        private static readonly TypeParameterConstraintSyntax s_structConstraint = SyntaxFactory.ClassOrStructConstraint(SyntaxKind.StructConstraint);
+        private static readonly TypeParameterConstraintSyntax s_defaultConstraint = SyntaxFactory.DefaultConstraint();
+
         internal static NamespaceDeclarationSyntax AddMethodTo(
             NamespaceDeclarationSyntax destination,
             IMethodSymbol method,
@@ -213,29 +217,27 @@ private static SyntaxList<TypeParameterConstraintClauseSyntax> GenerateConstrain
         private static SyntaxList<TypeParameterConstraintClauseSyntax> GenerateDefaultConstraints(IMethodSymbol method)
         {
             Debug.Assert(method.ExplicitInterfaceImplementations.Any() || method.IsOverride);
-            var seenTypeParameters = new HashSet<string>();
-            var listOfClauses = new List<TypeParameterConstraintClauseSyntax>(method.TypeParameters.Length);
+
+            using var _1 = PooledHashSet<string>.GetInstance(out var seenTypeParameters);
+            using var _2 = ArrayBuilder<TypeParameterConstraintClauseSyntax>.GetInstance(out var listOfClauses);
             foreach (var parameter in method.Parameters)
             {
-                if (parameter.Type is not ITypeParameterSymbol { NullableAnnotation: NullableAnnotation.Annotated } typeParameter ||
-                    !seenTypeParameters.Add(parameter.Type.Name))
+                if (parameter.Type is not ITypeParameterSymbol { NullableAnnotation: NullableAnnotation.Annotated } typeParameter)
                 {
                     continue;
                 }
 
-                TypeParameterConstraintSyntax constraint;
-                if (typeParameter.HasReferenceTypeConstraint)
-                {
-                    constraint = SyntaxFactory.ClassOrStructConstraint(SyntaxKind.ClassConstraint);
-                }
-                else if (typeParameter.HasValueTypeConstraint)
+                if (!seenTypeParameters.Add(parameter.Type.Name))
                 {
-                    constraint = SyntaxFactory.ClassOrStructConstraint(SyntaxKind.StructConstraint);
+                    continue;
                 }
-                else
+
+                var constraint = typeParameter switch
                 {
-                    constraint = SyntaxFactory.DefaultConstraint();
-                }
+                    { HasReferenceTypeConstraint: true } => s_classConstraint,
+                    { HasValueTypeConstraint: true } => s_structConstraint,
+                    _ => s_defaultConstraint
+                };
 
                 listOfClauses.Add(SyntaxFactory.TypeParameterConstraintClause(
                     name: parameter.Type.Name.ToIdentifierName(),

From 0e45ca626e8350677d0c7263f5c421e83b70d3bf Mon Sep 17 00:00:00 2001
From: Ankita Khera <ankitakhera@microsoft.com>
Date: Thu, 19 Aug 2021 15:41:54 -0700
Subject: [PATCH 012/444] Added double click on hint to insert text

---
 .../Core.Wpf/InlineHints/InlineHintsTag.cs    | 19 ++++++++++++++++++
 .../InlineHintsDataTaggerProvider.cs          |  1 +
 ...AbstractInlineParameterNameHintsService.cs | 20 +++++++++++++++----
 .../Core/Portable/InlineHints/InlineHint.cs   |  8 +++++++-
 .../Portable/InlineHints/InlineHintHelpers.cs |  8 ++++++++
 .../InlineHints/InlineHintsOptions.cs         |  7 +++++++
 .../Options/AdvancedOptionPageControl.xaml    |  4 ++++
 .../Options/AdvancedOptionPageControl.xaml.cs |  2 ++
 .../Impl/Options/AdvancedOptionPageStrings.cs |  3 +++
 .../Core/Def/ServicesVSResources.resx         |  3 +++
 .../Core/Def/xlf/ServicesVSResources.cs.xlf   |  5 +++++
 .../Core/Def/xlf/ServicesVSResources.de.xlf   |  5 +++++
 .../Core/Def/xlf/ServicesVSResources.es.xlf   |  5 +++++
 .../Core/Def/xlf/ServicesVSResources.fr.xlf   |  5 +++++
 .../Core/Def/xlf/ServicesVSResources.it.xlf   |  5 +++++
 .../Core/Def/xlf/ServicesVSResources.ja.xlf   |  5 +++++
 .../Core/Def/xlf/ServicesVSResources.ko.xlf   |  5 +++++
 .../Core/Def/xlf/ServicesVSResources.pl.xlf   |  5 +++++
 .../Def/xlf/ServicesVSResources.pt-BR.xlf     |  5 +++++
 .../Core/Def/xlf/ServicesVSResources.ru.xlf   |  5 +++++
 .../Core/Def/xlf/ServicesVSResources.tr.xlf   |  5 +++++
 .../Def/xlf/ServicesVSResources.zh-Hans.xlf   |  5 +++++
 .../Def/xlf/ServicesVSResources.zh-Hant.xlf   |  5 +++++
 .../Options/AdvancedOptionPageControl.xaml    |  4 ++++
 .../Options/AdvancedOptionPageControl.xaml.vb |  2 ++
 .../Impl/Options/AdvancedOptionPageStrings.vb |  3 +++
 26 files changed, 144 insertions(+), 5 deletions(-)

diff --git a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
index 58f960d52f240..e5aa2bc1e9a86 100644
--- a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -13,10 +14,13 @@
 using System.Windows.Documents;
 using System.Windows.Input;
 using System.Windows.Media;
+using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Editor.Host;
 using Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.QuickInfo;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.InlineHints;
+using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
@@ -65,6 +69,8 @@ private InlineHintsTag(
             // information in the Border_ToolTipOpening event handler
             adornment.ToolTip = "Quick info";
             adornment.ToolTipOpening += Border_ToolTipOpening;
+
+            adornment.MouseLeftButtonDown += Adornment_MouseLeftButtonDown;
         }
 
         /// <summary>
@@ -254,5 +260,18 @@ private async Task StartToolTipServiceAsync(IToolTipPresenter toolTipPresenter)
 
             toolTipPresenter.StartOrUpdate(_textView.TextSnapshot.CreateTrackingSpan(_span.Start, _span.Length, SpanTrackingMode.EdgeInclusive), uiList);
         }
+
+        private void Adornment_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
+        {
+            if (e.ClickCount == 2)
+            {
+                e.Handled = true;
+                var replacementText = _hint.GetReplacementText();
+                if (replacementText != null)
+                {
+                    _ = _textView.TextBuffer.Replace(_span, replacementText);
+                }
+            }
+        }
     }
 }
diff --git a/src/EditorFeatures/Core/InlineHints/InlineHintsDataTaggerProvider.cs b/src/EditorFeatures/Core/InlineHints/InlineHintsDataTaggerProvider.cs
index f4943e33c4618..e277194d663a1 100644
--- a/src/EditorFeatures/Core/InlineHints/InlineHintsDataTaggerProvider.cs
+++ b/src/EditorFeatures/Core/InlineHints/InlineHintsDataTaggerProvider.cs
@@ -68,6 +68,7 @@ protected override ITaggerEventSource CreateEventSource(ITextView textViewOpt, I
                 TaggerEventSources.OnOptionChanged(subjectBuffer, InlineHintsOptions.ForIndexerParameters),
                 TaggerEventSources.OnOptionChanged(subjectBuffer, InlineHintsOptions.ForObjectCreationParameters),
                 TaggerEventSources.OnOptionChanged(subjectBuffer, InlineHintsOptions.ForOtherParameters),
+                TaggerEventSources.OnOptionChanged(subjectBuffer, InlineHintsOptions.DoubleClickToInsertHint),
                 TaggerEventSources.OnOptionChanged(subjectBuffer, InlineHintsOptions.SuppressForParametersThatMatchMethodIntent),
                 TaggerEventSources.OnOptionChanged(subjectBuffer, InlineHintsOptions.SuppressForParametersThatDifferOnlyBySuffix),
                 TaggerEventSources.OnOptionChanged(subjectBuffer, InlineHintsOptions.EnabledForTypes),
diff --git a/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs b/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
index 03eabdbfafab9..c80d64e06c97a 100644
--- a/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
+++ b/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
@@ -49,6 +49,7 @@ public async Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(Document docum
             var indexerParameters = displayAllOverride || options.GetOption(InlineHintsOptions.ForIndexerParameters);
             var suppressForParametersThatDifferOnlyBySuffix = !displayAllOverride && options.GetOption(InlineHintsOptions.SuppressForParametersThatDifferOnlyBySuffix);
             var suppressForParametersThatMatchMethodIntent = !displayAllOverride && options.GetOption(InlineHintsOptions.SuppressForParametersThatMatchMethodIntent);
+            var doubleClickToInsertHint = options.GetOption(InlineHintsOptions.DoubleClickToInsertHint);
 
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
@@ -90,10 +91,21 @@ void AddHintsIfAppropriate(SyntaxNode node)
 
                     if (HintMatches(kind, literalParameters, objectCreationParameters, otherParameters))
                     {
-                        result.Add(new InlineHint(
-                            new TextSpan(position, 0),
-                            ImmutableArray.Create(new TaggedText(TextTags.Text, parameter.Name + ": ")),
-                            InlineHintHelpers.GetDescriptionFunction(position, parameter.GetSymbolKey(cancellationToken: cancellationToken))));
+                        if (doubleClickToInsertHint is false)
+                        {
+                            result.Add(new InlineHint(
+                                new TextSpan(position, 0),
+                                ImmutableArray.Create(new TaggedText(TextTags.Text, parameter.Name + ": ")),
+                                InlineHintHelpers.GetDescriptionFunction(position, parameter.GetSymbolKey(cancellationToken: cancellationToken))));
+                        }
+                        else
+                        {
+                            result.Add(new InlineHint(
+                                new TextSpan(position, 0),
+                                ImmutableArray.Create(new TaggedText(TextTags.Text, parameter.Name + ": ")),
+                                InlineHintHelpers.GetDescriptionFunction(position, parameter.GetSymbolKey(cancellationToken: cancellationToken)),
+                                InlineHintHelpers.GetReplacementTextFunction(parameter.Name)));
+                        }
                     }
                 }
             }
diff --git a/src/Features/Core/Portable/InlineHints/InlineHint.cs b/src/Features/Core/Portable/InlineHints/InlineHint.cs
index ae68b3553ec1c..a49f78833f713 100644
--- a/src/Features/Core/Portable/InlineHints/InlineHint.cs
+++ b/src/Features/Core/Portable/InlineHints/InlineHint.cs
@@ -16,11 +16,13 @@ internal readonly struct InlineHint
         public readonly TextSpan Span;
         public readonly ImmutableArray<TaggedText> DisplayParts;
         private readonly Func<Document, CancellationToken, Task<ImmutableArray<TaggedText>>>? _getDescriptionAsync;
+        private readonly Func<string>? _getReplacementText;
 
         public InlineHint(
             TextSpan span,
             ImmutableArray<TaggedText> displayParts,
-            Func<Document, CancellationToken, Task<ImmutableArray<TaggedText>>>? getDescriptionAsync = null)
+            Func<Document, CancellationToken, Task<ImmutableArray<TaggedText>>>? getDescriptionAsync = null,
+            Func<string>? getReplacementText = null)
         {
             if (displayParts.Length == 0)
                 throw new ArgumentException($"{nameof(displayParts)} must be non-empty");
@@ -28,6 +30,7 @@ public InlineHint(
             Span = span;
             DisplayParts = displayParts;
             _getDescriptionAsync = getDescriptionAsync;
+            _getReplacementText = getReplacementText;
         }
 
         /// <summary>
@@ -36,5 +39,8 @@ public InlineHint(
         /// </summary>
         public Task<ImmutableArray<TaggedText>> GetDescriptionAsync(Document document, CancellationToken cancellationToken)
             => _getDescriptionAsync?.Invoke(document, cancellationToken) ?? SpecializedTasks.EmptyImmutableArray<TaggedText>();
+
+        public string? GetReplacementText()
+            => _getReplacementText?.Invoke() ?? null;
     }
 }
diff --git a/src/Features/Core/Portable/InlineHints/InlineHintHelpers.cs b/src/Features/Core/Portable/InlineHints/InlineHintHelpers.cs
index d384e413cfdb8..320901a5302ce 100644
--- a/src/Features/Core/Portable/InlineHints/InlineHintHelpers.cs
+++ b/src/Features/Core/Portable/InlineHints/InlineHintHelpers.cs
@@ -60,5 +60,13 @@ private static async Task<ImmutableArray<TaggedText>> GetDescriptionAsync(Docume
 
             return default;
         }
+
+        public static Func<string>? GetReplacementTextFunction(string parameterName)
+            => () => GetReplacementText(parameterName);
+
+        private static string GetReplacementText(string parameterName)
+        {
+            return $"{parameterName}: ";
+        }
     }
 }
diff --git a/src/Features/Core/Portable/InlineHints/InlineHintsOptions.cs b/src/Features/Core/Portable/InlineHints/InlineHintsOptions.cs
index a3867d4f3b98d..7afc6db13e9dd 100644
--- a/src/Features/Core/Portable/InlineHints/InlineHintsOptions.cs
+++ b/src/Features/Core/Portable/InlineHints/InlineHintsOptions.cs
@@ -75,6 +75,12 @@ internal static class InlineHintsOptions
                 defaultValue: true,
                 storageLocations: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.InlineParameterNameHints.SuppressForParametersThatMatchMethodIntent"));
 
+        public static readonly PerLanguageOption2<bool> DoubleClickToInsertHint =
+            new(nameof(InlineHintsOptions),
+                nameof(DoubleClickToInsertHint),
+                defaultValue: true,
+                storageLocations: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.InlineParameterNameHints.DoubleClickToInsertHint"));
+
         public static readonly PerLanguageOption2<bool> EnabledForTypes =
             new(nameof(InlineHintsOptions),
                 nameof(EnabledForTypes),
@@ -117,6 +123,7 @@ public InlineHintsOptionsProvider()
             InlineHintsOptions.ForIndexerParameters,
             InlineHintsOptions.ForObjectCreationParameters,
             InlineHintsOptions.ForOtherParameters,
+            InlineHintsOptions.DoubleClickToInsertHint,
             InlineHintsOptions.EnabledForTypes,
             InlineHintsOptions.ForImplicitVariableTypes,
             InlineHintsOptions.ForLambdaParameterTypes,
diff --git a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
index 521428aa817e1..1e9d5dadbd16c 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
+++ b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
@@ -261,6 +261,10 @@
                         <CheckBox x:Uid="SuppressHintsWhenParameterNamesDifferOnlyBySuffix"
                                   x:Name="SuppressHintsWhenParameterNamesDifferOnlyBySuffix"
                                   Content="{x:Static local:AdvancedOptionPageStrings.Option_Suppress_hints_when_parameter_names_differ_only_by_suffix}" />
+
+                        <CheckBox x:Uid="DoubleClickToInsertHint"
+                                  x:Name="DoubleClickToInsertHint"
+                                  Content="{x:Static local:AdvancedOptionPageStrings.Option_Double_click_to_insert_hint}" />
                     </StackPanel>
                     
                     <CheckBox x:Name="DisplayInlineTypeHints"
diff --git a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
index 5d5241e25a15a..3553b251fa80b 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
@@ -140,6 +140,7 @@ public AdvancedOptionPageControl(OptionStore optionStore, IComponentModel compon
             BindToOption(ShowHintsForIndexers, InlineHintsOptions.ForIndexerParameters, LanguageNames.CSharp);
             BindToOption(SuppressHintsWhenParameterNameMatchesTheMethodsIntent, InlineHintsOptions.SuppressForParametersThatMatchMethodIntent, LanguageNames.CSharp);
             BindToOption(SuppressHintsWhenParameterNamesDifferOnlyBySuffix, InlineHintsOptions.SuppressForParametersThatDifferOnlyBySuffix, LanguageNames.CSharp);
+            BindToOption(DoubleClickToInsertHint, InlineHintsOptions.DoubleClickToInsertHint, LanguageNames.CSharp);
 
             BindToOption(DisplayInlineTypeHints, InlineHintsOptions.EnabledForTypes, LanguageNames.CSharp);
             BindToOption(ShowHintsForVariablesWithInferredTypes, InlineHintsOptions.ForImplicitVariableTypes, LanguageNames.CSharp);
@@ -242,6 +243,7 @@ private void UpdateInlineHintsOptions()
             ShowHintsForIndexers.IsEnabled = enabledForParameters;
             SuppressHintsWhenParameterNameMatchesTheMethodsIntent.IsEnabled = enabledForParameters;
             SuppressHintsWhenParameterNamesDifferOnlyBySuffix.IsEnabled = enabledForParameters;
+            DoubleClickToInsertHint.IsEnabled = enabledForParameters;
 
             var enabledForTypes = this.OptionStore.GetOption(InlineHintsOptions.EnabledForTypes, LanguageNames.CSharp);
             ShowHintsForVariablesWithInferredTypes.IsEnabled = enabledForTypes;
diff --git a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs
index a1678aaf8a7ce..e73097ec687cd 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs
@@ -67,6 +67,9 @@ public static string Option_Suppress_hints_when_parameter_name_matches_the_metho
         public static string Option_Suppress_hints_when_parameter_names_differ_only_by_suffix
             => ServicesVSResources.Suppress_hints_when_parameter_names_differ_only_by_suffix;
 
+        public static string Option_Double_click_to_insert_hint
+            => ServicesVSResources.Double_click_to_insert_hint;
+
         public static string Option_Display_inline_type_hints
             => ServicesVSResources.Display_inline_type_hints;
 
diff --git a/src/VisualStudio/Core/Def/ServicesVSResources.resx b/src/VisualStudio/Core/Def/ServicesVSResources.resx
index 02fd79c672fa0..0f97b34d581e8 100644
--- a/src/VisualStudio/Core/Def/ServicesVSResources.resx
+++ b/src/VisualStudio/Core/Def/ServicesVSResources.resx
@@ -1809,4 +1809,7 @@ Additional information: {1}</value>
     <value>Default (Open Documents)</value>
     <comment>This text is a menu command</comment>
   </data>
+  <data name="Double_click_to_insert_hint" xml:space="preserve">
+    <value>Double click to insert hint</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
index 71c717f0340a0..32cfaea234dfd 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
@@ -292,6 +292,11 @@
         <target state="translated">Zobrazovat vložené nápovědy k typům</target>
         <note />
       </trans-unit>
+      <trans-unit id="Double_click_to_insert_hint">
+        <source>Double click to insert hint</source>
+        <target state="new">Double click to insert hint</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">_Upravit</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
index a9a7b35f2c6cc..79ab316f3e8b8 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
@@ -292,6 +292,11 @@
         <target state="translated">Inlinetyphinweise anzeigen</target>
         <note />
       </trans-unit>
+      <trans-unit id="Double_click_to_insert_hint">
+        <source>Double click to insert hint</source>
+        <target state="new">Double click to insert hint</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">_Bearbeiten</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
index 51981ba12252e..d5a3ce0071031 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
@@ -292,6 +292,11 @@
         <target state="translated">Mostrar sugerencias de tipo insertado</target>
         <note />
       </trans-unit>
+      <trans-unit id="Double_click_to_insert_hint">
+        <source>Double click to insert hint</source>
+        <target state="new">Double click to insert hint</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">_Editar</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
index cf5775b5ab268..c82c92925fa47 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
@@ -292,6 +292,11 @@
         <target state="translated">Afficher les indicateurs de type inline</target>
         <note />
       </trans-unit>
+      <trans-unit id="Double_click_to_insert_hint">
+        <source>Double click to insert hint</source>
+        <target state="new">Double click to insert hint</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">_Modifier</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
index 5c2a3354ae6b9..d1dfe86a7c143 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
@@ -292,6 +292,11 @@
         <target state="translated">Visualizza suggerimenti di tipo inline</target>
         <note />
       </trans-unit>
+      <trans-unit id="Double_click_to_insert_hint">
+        <source>Double click to insert hint</source>
+        <target state="new">Double click to insert hint</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">_Modifica</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
index 1a4609df4cafe..9285eb5390c8e 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
@@ -292,6 +292,11 @@
         <target state="translated">インライン型のヒントを表示する</target>
         <note />
       </trans-unit>
+      <trans-unit id="Double_click_to_insert_hint">
+        <source>Double click to insert hint</source>
+        <target state="new">Double click to insert hint</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">編集(_E)</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
index eddba32650ad6..ba606f81672bb 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
@@ -292,6 +292,11 @@
         <target state="translated">인라인 유형 힌트 표시</target>
         <note />
       </trans-unit>
+      <trans-unit id="Double_click_to_insert_hint">
+        <source>Double click to insert hint</source>
+        <target state="new">Double click to insert hint</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">편집(_E)</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
index 105efbc6aede2..41edc2699d762 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
@@ -292,6 +292,11 @@
         <target state="translated">Wyświetl wskazówki w tekście dla typów</target>
         <note />
       </trans-unit>
+      <trans-unit id="Double_click_to_insert_hint">
+        <source>Double click to insert hint</source>
+        <target state="new">Double click to insert hint</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">_Edytuj</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
index b90d99713d43f..5bb8883bf0e3d 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
@@ -292,6 +292,11 @@
         <target state="translated">Exibir as dicas embutidas de tipo</target>
         <note />
       </trans-unit>
+      <trans-unit id="Double_click_to_insert_hint">
+        <source>Double click to insert hint</source>
+        <target state="new">Double click to insert hint</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">_Editar</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
index 04bbd8f85ea1d..fbdefe5123c7a 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
@@ -292,6 +292,11 @@
         <target state="translated">Отображать подсказки для встроенных типов</target>
         <note />
       </trans-unit>
+      <trans-unit id="Double_click_to_insert_hint">
+        <source>Double click to insert hint</source>
+        <target state="new">Double click to insert hint</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">_Изменить</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
index 3e032a2617eb7..53c728bb818a2 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
@@ -292,6 +292,11 @@
         <target state="translated">Satır içi tür ipuçlarını göster</target>
         <note />
       </trans-unit>
+      <trans-unit id="Double_click_to_insert_hint">
+        <source>Double click to insert hint</source>
+        <target state="new">Double click to insert hint</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">_Düzenle</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
index cbb91b97bbbf4..f1ab99464d76d 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
@@ -292,6 +292,11 @@
         <target state="translated">显示内联类型提示</target>
         <note />
       </trans-unit>
+      <trans-unit id="Double_click_to_insert_hint">
+        <source>Double click to insert hint</source>
+        <target state="new">Double click to insert hint</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">编辑(_E)</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
index cc5379268988f..e7237c18435c3 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
@@ -292,6 +292,11 @@
         <target state="translated">顯示內嵌類型提示</target>
         <note />
       </trans-unit>
+      <trans-unit id="Double_click_to_insert_hint">
+        <source>Double click to insert hint</source>
+        <target state="new">Double click to insert hint</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">編輯(_E)</target>
diff --git a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml
index 372796b597864..55c335fccf76e 100644
--- a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml
+++ b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml
@@ -252,6 +252,10 @@
                         <CheckBox x:Uid="SuppressHintsWhenParameterNamesDifferOnlyBySuffix"
                                   x:Name="SuppressHintsWhenParameterNamesDifferOnlyBySuffix"
                                   Content="{x:Static local:AdvancedOptionPageStrings.Option_Suppress_hints_when_parameter_names_differ_only_by_suffix}" />
+
+                        <CheckBox x:Uid="DoubleClickToInsertHint"
+                                  x:Name="DoubleClickToInsertHint"
+                                  Content="{x:Static local:AdvancedOptionPageStrings.Option_Double_click_to_insert_hint}" />
                     </StackPanel>
                 </StackPanel>
             </GroupBox>
diff --git a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb
index 1a27d07b98dab..1088df2f49240 100644
--- a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb
+++ b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb
@@ -145,6 +145,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Options
             BindToOption(ShowHintsForIndexers, InlineHintsOptions.ForIndexerParameters, LanguageNames.VisualBasic)
             BindToOption(SuppressHintsWhenParameterNameMatchesTheMethodsIntent, InlineHintsOptions.SuppressForParametersThatMatchMethodIntent, LanguageNames.VisualBasic)
             BindToOption(SuppressHintsWhenParameterNamesDifferOnlyBySuffix, InlineHintsOptions.SuppressForParametersThatDifferOnlyBySuffix, LanguageNames.VisualBasic)
+            BindToOption(DoubleClickToInsertHint, InlineHintsOptions.DoubleClickToInsertHint, LanguageNames.VisualBasic)
 
             BindToOption(ShowInheritanceMargin, FeatureOnOffOptions.ShowInheritanceMargin, LanguageNames.VisualBasic,
                          Function()
@@ -176,6 +177,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Options
             ShowHintsForIndexers.IsEnabled = enabledForParameters
             SuppressHintsWhenParameterNameMatchesTheMethodsIntent.IsEnabled = enabledForParameters
             SuppressHintsWhenParameterNamesDifferOnlyBySuffix.IsEnabled = enabledForParameters
+            DoubleClickToInsertHint.IsEnabled = enabledForParameters
         End Sub
 
         Private Sub DisplayInlineParameterNameHints_Checked()
diff --git a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb
index 4c5e6d28a78d8..b2658ea0e90f7 100644
--- a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb
+++ b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb
@@ -66,6 +66,9 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Options
         Public ReadOnly Property Option_Suppress_hints_when_parameter_names_differ_only_by_suffix As String =
             ServicesVSResources.Suppress_hints_when_parameter_names_differ_only_by_suffix
 
+        Public ReadOnly Property Option_Double_click_to_insert_hint As String =
+            ServicesVSResources.Double_click_to_insert_hint
+
         Public ReadOnly Property Option_DontPutOutOrRefOnStruct As String =
             BasicVSResources.Don_t_put_ByRef_on_custom_structure
 

From 29d2b9eeed70ca5525848d9255b2fb9910266278 Mon Sep 17 00:00:00 2001
From: Ankita Khera <ankitakhera@microsoft.com>
Date: Thu, 19 Aug 2021 15:58:04 -0700
Subject: [PATCH 013/444] removed unnecessary usings

---
 src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
index e5aa2bc1e9a86..8339fc509ea08 100644
--- a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
@@ -5,7 +5,6 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -14,13 +13,10 @@
 using System.Windows.Documents;
 using System.Windows.Input;
 using System.Windows.Media;
-using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Editor.Host;
 using Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.QuickInfo;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
-using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.InlineHints;
-using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;

From efb908509c42db464432ed36936cd5faaa32a2f8 Mon Sep 17 00:00:00 2001
From: Ankita Khera <ankitakhera@microsoft.com>
Date: Thu, 19 Aug 2021 16:00:09 -0700
Subject: [PATCH 014/444] don't explicitly check for false

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

diff --git a/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs b/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
index c80d64e06c97a..0e7032eb137ee 100644
--- a/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
+++ b/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
@@ -91,7 +91,7 @@ void AddHintsIfAppropriate(SyntaxNode node)
 
                     if (HintMatches(kind, literalParameters, objectCreationParameters, otherParameters))
                     {
-                        if (doubleClickToInsertHint is false)
+                        if (!doubleClickToInsertHint)
                         {
                             result.Add(new InlineHint(
                                 new TextSpan(position, 0),

From 705543d9eb129654ad8a3bc773fbb814caed3bd3 Mon Sep 17 00:00:00 2001
From: Ankita Khera <ankitakhera@microsoft.com>
Date: Thu, 19 Aug 2021 16:11:33 -0700
Subject: [PATCH 015/444] don't call add twice

---
 ...AbstractInlineParameterNameHintsService.cs | 24 +++++++------------
 1 file changed, 9 insertions(+), 15 deletions(-)

diff --git a/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs b/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
index 0e7032eb137ee..06c9d04a13a4c 100644
--- a/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
+++ b/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
@@ -91,21 +91,15 @@ void AddHintsIfAppropriate(SyntaxNode node)
 
                     if (HintMatches(kind, literalParameters, objectCreationParameters, otherParameters))
                     {
-                        if (!doubleClickToInsertHint)
-                        {
-                            result.Add(new InlineHint(
-                                new TextSpan(position, 0),
-                                ImmutableArray.Create(new TaggedText(TextTags.Text, parameter.Name + ": ")),
-                                InlineHintHelpers.GetDescriptionFunction(position, parameter.GetSymbolKey(cancellationToken: cancellationToken))));
-                        }
-                        else
-                        {
-                            result.Add(new InlineHint(
-                                new TextSpan(position, 0),
-                                ImmutableArray.Create(new TaggedText(TextTags.Text, parameter.Name + ": ")),
-                                InlineHintHelpers.GetDescriptionFunction(position, parameter.GetSymbolKey(cancellationToken: cancellationToken)),
-                                InlineHintHelpers.GetReplacementTextFunction(parameter.Name)));
-                        }
+                        var replacementTextFunction = doubleClickToInsertHint
+                            ? InlineHintHelpers.GetReplacementTextFunction(parameter.Name)
+                            : null;
+
+                        result.Add(new InlineHint(
+                            new TextSpan(position, 0),
+                            ImmutableArray.Create(new TaggedText(TextTags.Text, parameter.Name + ": ")),
+                            InlineHintHelpers.GetDescriptionFunction(position, parameter.GetSymbolKey(cancellationToken: cancellationToken)),
+                            replacementTextFunction));
                     }
                 }
             }

From b7441a3751aba0a79082fa7b0ebee57a4731ad98 Mon Sep 17 00:00:00 2001
From: Ankita Khera <ankitakhera@microsoft.com>
Date: Thu, 19 Aug 2021 17:17:31 -0700
Subject: [PATCH 016/444] removed functions and options

---
 .../Core.Wpf/InlineHints/InlineHintsTag.cs    |  2 +-
 .../InlineHintsDataTaggerProvider.cs          |  1 -
 ...AbstractInlineParameterNameHintsService.cs | 11 +++-----
 .../Core/Portable/InlineHints/InlineHint.cs   | 25 +++++++++++++------
 .../Options/AdvancedOptionPageControl.xaml    |  3 ---
 .../Options/AdvancedOptionPageControl.xaml.cs |  2 --
 .../Impl/Options/AdvancedOptionPageStrings.cs |  3 ---
 .../Core/Def/ServicesVSResources.resx         |  3 ---
 .../Core/Def/xlf/ServicesVSResources.cs.xlf   |  5 ----
 .../Core/Def/xlf/ServicesVSResources.de.xlf   |  5 ----
 .../Core/Def/xlf/ServicesVSResources.es.xlf   |  5 ----
 .../Core/Def/xlf/ServicesVSResources.fr.xlf   |  5 ----
 .../Core/Def/xlf/ServicesVSResources.it.xlf   |  5 ----
 .../Core/Def/xlf/ServicesVSResources.ja.xlf   |  5 ----
 .../Core/Def/xlf/ServicesVSResources.ko.xlf   |  5 ----
 .../Core/Def/xlf/ServicesVSResources.pl.xlf   |  5 ----
 .../Def/xlf/ServicesVSResources.pt-BR.xlf     |  5 ----
 .../Core/Def/xlf/ServicesVSResources.ru.xlf   |  5 ----
 .../Core/Def/xlf/ServicesVSResources.tr.xlf   |  5 ----
 .../Def/xlf/ServicesVSResources.zh-Hans.xlf   |  5 ----
 .../Def/xlf/ServicesVSResources.zh-Hant.xlf   |  5 ----
 .../Options/AdvancedOptionPageControl.xaml    |  4 ---
 .../Options/AdvancedOptionPageControl.xaml.vb |  2 --
 .../Impl/Options/AdvancedOptionPageStrings.vb |  3 ---
 24 files changed, 23 insertions(+), 101 deletions(-)

diff --git a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
index 8339fc509ea08..67fb9839236a2 100644
--- a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
@@ -262,7 +262,7 @@ private void Adornment_MouseLeftButtonDown(object sender, MouseButtonEventArgs e
             if (e.ClickCount == 2)
             {
                 e.Handled = true;
-                var replacementText = _hint.GetReplacementText();
+                var replacementText = _hint.ReplacementText;
                 if (replacementText != null)
                 {
                     _ = _textView.TextBuffer.Replace(_span, replacementText);
diff --git a/src/EditorFeatures/Core/InlineHints/InlineHintsDataTaggerProvider.cs b/src/EditorFeatures/Core/InlineHints/InlineHintsDataTaggerProvider.cs
index e277194d663a1..f4943e33c4618 100644
--- a/src/EditorFeatures/Core/InlineHints/InlineHintsDataTaggerProvider.cs
+++ b/src/EditorFeatures/Core/InlineHints/InlineHintsDataTaggerProvider.cs
@@ -68,7 +68,6 @@ protected override ITaggerEventSource CreateEventSource(ITextView textViewOpt, I
                 TaggerEventSources.OnOptionChanged(subjectBuffer, InlineHintsOptions.ForIndexerParameters),
                 TaggerEventSources.OnOptionChanged(subjectBuffer, InlineHintsOptions.ForObjectCreationParameters),
                 TaggerEventSources.OnOptionChanged(subjectBuffer, InlineHintsOptions.ForOtherParameters),
-                TaggerEventSources.OnOptionChanged(subjectBuffer, InlineHintsOptions.DoubleClickToInsertHint),
                 TaggerEventSources.OnOptionChanged(subjectBuffer, InlineHintsOptions.SuppressForParametersThatMatchMethodIntent),
                 TaggerEventSources.OnOptionChanged(subjectBuffer, InlineHintsOptions.SuppressForParametersThatDifferOnlyBySuffix),
                 TaggerEventSources.OnOptionChanged(subjectBuffer, InlineHintsOptions.EnabledForTypes),
diff --git a/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs b/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
index 06c9d04a13a4c..00451bf3b9701 100644
--- a/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
+++ b/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
@@ -91,15 +91,12 @@ void AddHintsIfAppropriate(SyntaxNode node)
 
                     if (HintMatches(kind, literalParameters, objectCreationParameters, otherParameters))
                     {
-                        var replacementTextFunction = doubleClickToInsertHint
-                            ? InlineHintHelpers.GetReplacementTextFunction(parameter.Name)
-                            : null;
-
+                        var inlineHintText = parameter.Name + ": ";
                         result.Add(new InlineHint(
                             new TextSpan(position, 0),
-                            ImmutableArray.Create(new TaggedText(TextTags.Text, parameter.Name + ": ")),
-                            InlineHintHelpers.GetDescriptionFunction(position, parameter.GetSymbolKey(cancellationToken: cancellationToken)),
-                            replacementTextFunction));
+                            ImmutableArray.Create(new TaggedText(TextTags.Text, inlineHintText)),
+                            inlineHintText,
+                            InlineHintHelpers.GetDescriptionFunction(position, parameter.GetSymbolKey(cancellationToken: cancellationToken))));
                     }
                 }
             }
diff --git a/src/Features/Core/Portable/InlineHints/InlineHint.cs b/src/Features/Core/Portable/InlineHints/InlineHint.cs
index a49f78833f713..19d1ecb9a9222 100644
--- a/src/Features/Core/Portable/InlineHints/InlineHint.cs
+++ b/src/Features/Core/Portable/InlineHints/InlineHint.cs
@@ -15,14 +15,13 @@ internal readonly struct InlineHint
     {
         public readonly TextSpan Span;
         public readonly ImmutableArray<TaggedText> DisplayParts;
+        public readonly string? ReplacementText;
         private readonly Func<Document, CancellationToken, Task<ImmutableArray<TaggedText>>>? _getDescriptionAsync;
-        private readonly Func<string>? _getReplacementText;
 
         public InlineHint(
             TextSpan span,
             ImmutableArray<TaggedText> displayParts,
-            Func<Document, CancellationToken, Task<ImmutableArray<TaggedText>>>? getDescriptionAsync = null,
-            Func<string>? getReplacementText = null)
+            Func<Document, CancellationToken, Task<ImmutableArray<TaggedText>>>? getDescriptionAsync = null)
         {
             if (displayParts.Length == 0)
                 throw new ArgumentException($"{nameof(displayParts)} must be non-empty");
@@ -30,7 +29,22 @@ public InlineHint(
             Span = span;
             DisplayParts = displayParts;
             _getDescriptionAsync = getDescriptionAsync;
-            _getReplacementText = getReplacementText;
+            ReplacementText = null;
+        }
+
+        public InlineHint(
+            TextSpan span,
+            ImmutableArray<TaggedText> displayParts,
+            string replacementText,
+            Func<Document, CancellationToken, Task<ImmutableArray<TaggedText>>>? getDescriptionAsync = null)
+        {
+            if (displayParts.Length == 0)
+                throw new ArgumentException($"{nameof(displayParts)} must be non-empty");
+
+            Span = span;
+            DisplayParts = displayParts;
+            _getDescriptionAsync = getDescriptionAsync;
+            ReplacementText = replacementText;
         }
 
         /// <summary>
@@ -39,8 +53,5 @@ public InlineHint(
         /// </summary>
         public Task<ImmutableArray<TaggedText>> GetDescriptionAsync(Document document, CancellationToken cancellationToken)
             => _getDescriptionAsync?.Invoke(document, cancellationToken) ?? SpecializedTasks.EmptyImmutableArray<TaggedText>();
-
-        public string? GetReplacementText()
-            => _getReplacementText?.Invoke() ?? null;
     }
 }
diff --git a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
index 1e9d5dadbd16c..d75d0eb59a759 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
+++ b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
@@ -262,9 +262,6 @@
                                   x:Name="SuppressHintsWhenParameterNamesDifferOnlyBySuffix"
                                   Content="{x:Static local:AdvancedOptionPageStrings.Option_Suppress_hints_when_parameter_names_differ_only_by_suffix}" />
 
-                        <CheckBox x:Uid="DoubleClickToInsertHint"
-                                  x:Name="DoubleClickToInsertHint"
-                                  Content="{x:Static local:AdvancedOptionPageStrings.Option_Double_click_to_insert_hint}" />
                     </StackPanel>
                     
                     <CheckBox x:Name="DisplayInlineTypeHints"
diff --git a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
index 3553b251fa80b..5d5241e25a15a 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
@@ -140,7 +140,6 @@ public AdvancedOptionPageControl(OptionStore optionStore, IComponentModel compon
             BindToOption(ShowHintsForIndexers, InlineHintsOptions.ForIndexerParameters, LanguageNames.CSharp);
             BindToOption(SuppressHintsWhenParameterNameMatchesTheMethodsIntent, InlineHintsOptions.SuppressForParametersThatMatchMethodIntent, LanguageNames.CSharp);
             BindToOption(SuppressHintsWhenParameterNamesDifferOnlyBySuffix, InlineHintsOptions.SuppressForParametersThatDifferOnlyBySuffix, LanguageNames.CSharp);
-            BindToOption(DoubleClickToInsertHint, InlineHintsOptions.DoubleClickToInsertHint, LanguageNames.CSharp);
 
             BindToOption(DisplayInlineTypeHints, InlineHintsOptions.EnabledForTypes, LanguageNames.CSharp);
             BindToOption(ShowHintsForVariablesWithInferredTypes, InlineHintsOptions.ForImplicitVariableTypes, LanguageNames.CSharp);
@@ -243,7 +242,6 @@ private void UpdateInlineHintsOptions()
             ShowHintsForIndexers.IsEnabled = enabledForParameters;
             SuppressHintsWhenParameterNameMatchesTheMethodsIntent.IsEnabled = enabledForParameters;
             SuppressHintsWhenParameterNamesDifferOnlyBySuffix.IsEnabled = enabledForParameters;
-            DoubleClickToInsertHint.IsEnabled = enabledForParameters;
 
             var enabledForTypes = this.OptionStore.GetOption(InlineHintsOptions.EnabledForTypes, LanguageNames.CSharp);
             ShowHintsForVariablesWithInferredTypes.IsEnabled = enabledForTypes;
diff --git a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs
index e73097ec687cd..a1678aaf8a7ce 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs
@@ -67,9 +67,6 @@ public static string Option_Suppress_hints_when_parameter_name_matches_the_metho
         public static string Option_Suppress_hints_when_parameter_names_differ_only_by_suffix
             => ServicesVSResources.Suppress_hints_when_parameter_names_differ_only_by_suffix;
 
-        public static string Option_Double_click_to_insert_hint
-            => ServicesVSResources.Double_click_to_insert_hint;
-
         public static string Option_Display_inline_type_hints
             => ServicesVSResources.Display_inline_type_hints;
 
diff --git a/src/VisualStudio/Core/Def/ServicesVSResources.resx b/src/VisualStudio/Core/Def/ServicesVSResources.resx
index 0f97b34d581e8..02fd79c672fa0 100644
--- a/src/VisualStudio/Core/Def/ServicesVSResources.resx
+++ b/src/VisualStudio/Core/Def/ServicesVSResources.resx
@@ -1809,7 +1809,4 @@ Additional information: {1}</value>
     <value>Default (Open Documents)</value>
     <comment>This text is a menu command</comment>
   </data>
-  <data name="Double_click_to_insert_hint" xml:space="preserve">
-    <value>Double click to insert hint</value>
-  </data>
 </root>
\ No newline at end of file
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
index 32cfaea234dfd..71c717f0340a0 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
@@ -292,11 +292,6 @@
         <target state="translated">Zobrazovat vložené nápovědy k typům</target>
         <note />
       </trans-unit>
-      <trans-unit id="Double_click_to_insert_hint">
-        <source>Double click to insert hint</source>
-        <target state="new">Double click to insert hint</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">_Upravit</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
index 79ab316f3e8b8..a9a7b35f2c6cc 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
@@ -292,11 +292,6 @@
         <target state="translated">Inlinetyphinweise anzeigen</target>
         <note />
       </trans-unit>
-      <trans-unit id="Double_click_to_insert_hint">
-        <source>Double click to insert hint</source>
-        <target state="new">Double click to insert hint</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">_Bearbeiten</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
index d5a3ce0071031..51981ba12252e 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
@@ -292,11 +292,6 @@
         <target state="translated">Mostrar sugerencias de tipo insertado</target>
         <note />
       </trans-unit>
-      <trans-unit id="Double_click_to_insert_hint">
-        <source>Double click to insert hint</source>
-        <target state="new">Double click to insert hint</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">_Editar</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
index c82c92925fa47..cf5775b5ab268 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
@@ -292,11 +292,6 @@
         <target state="translated">Afficher les indicateurs de type inline</target>
         <note />
       </trans-unit>
-      <trans-unit id="Double_click_to_insert_hint">
-        <source>Double click to insert hint</source>
-        <target state="new">Double click to insert hint</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">_Modifier</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
index d1dfe86a7c143..5c2a3354ae6b9 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
@@ -292,11 +292,6 @@
         <target state="translated">Visualizza suggerimenti di tipo inline</target>
         <note />
       </trans-unit>
-      <trans-unit id="Double_click_to_insert_hint">
-        <source>Double click to insert hint</source>
-        <target state="new">Double click to insert hint</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">_Modifica</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
index 9285eb5390c8e..1a4609df4cafe 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
@@ -292,11 +292,6 @@
         <target state="translated">インライン型のヒントを表示する</target>
         <note />
       </trans-unit>
-      <trans-unit id="Double_click_to_insert_hint">
-        <source>Double click to insert hint</source>
-        <target state="new">Double click to insert hint</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">編集(_E)</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
index ba606f81672bb..eddba32650ad6 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
@@ -292,11 +292,6 @@
         <target state="translated">인라인 유형 힌트 표시</target>
         <note />
       </trans-unit>
-      <trans-unit id="Double_click_to_insert_hint">
-        <source>Double click to insert hint</source>
-        <target state="new">Double click to insert hint</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">편집(_E)</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
index 41edc2699d762..105efbc6aede2 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
@@ -292,11 +292,6 @@
         <target state="translated">Wyświetl wskazówki w tekście dla typów</target>
         <note />
       </trans-unit>
-      <trans-unit id="Double_click_to_insert_hint">
-        <source>Double click to insert hint</source>
-        <target state="new">Double click to insert hint</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">_Edytuj</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
index 5bb8883bf0e3d..b90d99713d43f 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
@@ -292,11 +292,6 @@
         <target state="translated">Exibir as dicas embutidas de tipo</target>
         <note />
       </trans-unit>
-      <trans-unit id="Double_click_to_insert_hint">
-        <source>Double click to insert hint</source>
-        <target state="new">Double click to insert hint</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">_Editar</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
index fbdefe5123c7a..04bbd8f85ea1d 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
@@ -292,11 +292,6 @@
         <target state="translated">Отображать подсказки для встроенных типов</target>
         <note />
       </trans-unit>
-      <trans-unit id="Double_click_to_insert_hint">
-        <source>Double click to insert hint</source>
-        <target state="new">Double click to insert hint</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">_Изменить</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
index 53c728bb818a2..3e032a2617eb7 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
@@ -292,11 +292,6 @@
         <target state="translated">Satır içi tür ipuçlarını göster</target>
         <note />
       </trans-unit>
-      <trans-unit id="Double_click_to_insert_hint">
-        <source>Double click to insert hint</source>
-        <target state="new">Double click to insert hint</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">_Düzenle</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
index f1ab99464d76d..cbb91b97bbbf4 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
@@ -292,11 +292,6 @@
         <target state="translated">显示内联类型提示</target>
         <note />
       </trans-unit>
-      <trans-unit id="Double_click_to_insert_hint">
-        <source>Double click to insert hint</source>
-        <target state="new">Double click to insert hint</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">编辑(_E)</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
index e7237c18435c3..cc5379268988f 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
@@ -292,11 +292,6 @@
         <target state="translated">顯示內嵌類型提示</target>
         <note />
       </trans-unit>
-      <trans-unit id="Double_click_to_insert_hint">
-        <source>Double click to insert hint</source>
-        <target state="new">Double click to insert hint</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Edit">
         <source>_Edit</source>
         <target state="translated">編輯(_E)</target>
diff --git a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml
index 55c335fccf76e..372796b597864 100644
--- a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml
+++ b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml
@@ -252,10 +252,6 @@
                         <CheckBox x:Uid="SuppressHintsWhenParameterNamesDifferOnlyBySuffix"
                                   x:Name="SuppressHintsWhenParameterNamesDifferOnlyBySuffix"
                                   Content="{x:Static local:AdvancedOptionPageStrings.Option_Suppress_hints_when_parameter_names_differ_only_by_suffix}" />
-
-                        <CheckBox x:Uid="DoubleClickToInsertHint"
-                                  x:Name="DoubleClickToInsertHint"
-                                  Content="{x:Static local:AdvancedOptionPageStrings.Option_Double_click_to_insert_hint}" />
                     </StackPanel>
                 </StackPanel>
             </GroupBox>
diff --git a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb
index 1088df2f49240..1a27d07b98dab 100644
--- a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb
+++ b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb
@@ -145,7 +145,6 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Options
             BindToOption(ShowHintsForIndexers, InlineHintsOptions.ForIndexerParameters, LanguageNames.VisualBasic)
             BindToOption(SuppressHintsWhenParameterNameMatchesTheMethodsIntent, InlineHintsOptions.SuppressForParametersThatMatchMethodIntent, LanguageNames.VisualBasic)
             BindToOption(SuppressHintsWhenParameterNamesDifferOnlyBySuffix, InlineHintsOptions.SuppressForParametersThatDifferOnlyBySuffix, LanguageNames.VisualBasic)
-            BindToOption(DoubleClickToInsertHint, InlineHintsOptions.DoubleClickToInsertHint, LanguageNames.VisualBasic)
 
             BindToOption(ShowInheritanceMargin, FeatureOnOffOptions.ShowInheritanceMargin, LanguageNames.VisualBasic,
                          Function()
@@ -177,7 +176,6 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Options
             ShowHintsForIndexers.IsEnabled = enabledForParameters
             SuppressHintsWhenParameterNameMatchesTheMethodsIntent.IsEnabled = enabledForParameters
             SuppressHintsWhenParameterNamesDifferOnlyBySuffix.IsEnabled = enabledForParameters
-            DoubleClickToInsertHint.IsEnabled = enabledForParameters
         End Sub
 
         Private Sub DisplayInlineParameterNameHints_Checked()
diff --git a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb
index b2658ea0e90f7..4c5e6d28a78d8 100644
--- a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb
+++ b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb
@@ -66,9 +66,6 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Options
         Public ReadOnly Property Option_Suppress_hints_when_parameter_names_differ_only_by_suffix As String =
             ServicesVSResources.Suppress_hints_when_parameter_names_differ_only_by_suffix
 
-        Public ReadOnly Property Option_Double_click_to_insert_hint As String =
-            ServicesVSResources.Double_click_to_insert_hint
-
         Public ReadOnly Property Option_DontPutOutOrRefOnStruct As String =
             BasicVSResources.Don_t_put_ByRef_on_custom_structure
 

From 09f245c79857f876fc29d3370e0c5e296bc1876a Mon Sep 17 00:00:00 2001
From: Ankita Khera <ankitakhera@microsoft.com>
Date: Thu, 19 Aug 2021 17:21:15 -0700
Subject: [PATCH 017/444] leftover removal

---
 .../Core/Portable/InlineHints/InlineHintsOptions.cs        | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/src/Features/Core/Portable/InlineHints/InlineHintsOptions.cs b/src/Features/Core/Portable/InlineHints/InlineHintsOptions.cs
index 7afc6db13e9dd..a3867d4f3b98d 100644
--- a/src/Features/Core/Portable/InlineHints/InlineHintsOptions.cs
+++ b/src/Features/Core/Portable/InlineHints/InlineHintsOptions.cs
@@ -75,12 +75,6 @@ internal static class InlineHintsOptions
                 defaultValue: true,
                 storageLocations: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.InlineParameterNameHints.SuppressForParametersThatMatchMethodIntent"));
 
-        public static readonly PerLanguageOption2<bool> DoubleClickToInsertHint =
-            new(nameof(InlineHintsOptions),
-                nameof(DoubleClickToInsertHint),
-                defaultValue: true,
-                storageLocations: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.InlineParameterNameHints.DoubleClickToInsertHint"));
-
         public static readonly PerLanguageOption2<bool> EnabledForTypes =
             new(nameof(InlineHintsOptions),
                 nameof(EnabledForTypes),
@@ -123,7 +117,6 @@ public InlineHintsOptionsProvider()
             InlineHintsOptions.ForIndexerParameters,
             InlineHintsOptions.ForObjectCreationParameters,
             InlineHintsOptions.ForOtherParameters,
-            InlineHintsOptions.DoubleClickToInsertHint,
             InlineHintsOptions.EnabledForTypes,
             InlineHintsOptions.ForImplicitVariableTypes,
             InlineHintsOptions.ForLambdaParameterTypes,

From ef901670c0d3ca230ce44469c76e954f3846e8cf Mon Sep 17 00:00:00 2001
From: Ankita Khera <ankitakhera@microsoft.com>
Date: Thu, 19 Aug 2021 17:24:19 -0700
Subject: [PATCH 018/444] more pr feedback

---
 .../AbstractInlineParameterNameHintsService.cs            | 1 -
 .../Core/Portable/InlineHints/InlineHintHelpers.cs        | 8 --------
 .../CSharp/Impl/Options/AdvancedOptionPageControl.xaml    | 3 +--
 3 files changed, 1 insertion(+), 11 deletions(-)

diff --git a/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs b/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
index 00451bf3b9701..8ca068d893f96 100644
--- a/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
+++ b/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
@@ -49,7 +49,6 @@ public async Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(Document docum
             var indexerParameters = displayAllOverride || options.GetOption(InlineHintsOptions.ForIndexerParameters);
             var suppressForParametersThatDifferOnlyBySuffix = !displayAllOverride && options.GetOption(InlineHintsOptions.SuppressForParametersThatDifferOnlyBySuffix);
             var suppressForParametersThatMatchMethodIntent = !displayAllOverride && options.GetOption(InlineHintsOptions.SuppressForParametersThatMatchMethodIntent);
-            var doubleClickToInsertHint = options.GetOption(InlineHintsOptions.DoubleClickToInsertHint);
 
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
diff --git a/src/Features/Core/Portable/InlineHints/InlineHintHelpers.cs b/src/Features/Core/Portable/InlineHints/InlineHintHelpers.cs
index 320901a5302ce..d384e413cfdb8 100644
--- a/src/Features/Core/Portable/InlineHints/InlineHintHelpers.cs
+++ b/src/Features/Core/Portable/InlineHints/InlineHintHelpers.cs
@@ -60,13 +60,5 @@ private static async Task<ImmutableArray<TaggedText>> GetDescriptionAsync(Docume
 
             return default;
         }
-
-        public static Func<string>? GetReplacementTextFunction(string parameterName)
-            => () => GetReplacementText(parameterName);
-
-        private static string GetReplacementText(string parameterName)
-        {
-            return $"{parameterName}: ";
-        }
     }
 }
diff --git a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
index d75d0eb59a759..3b7efde8328ac 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
+++ b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
@@ -257,11 +257,10 @@
                         <CheckBox x:Uid="SuppressHintsWhenParameterNameMatchesTheMethodsIntent"
                                   x:Name="SuppressHintsWhenParameterNameMatchesTheMethodsIntent"
                                   Content="{x:Static local:AdvancedOptionPageStrings.Option_Suppress_hints_when_parameter_name_matches_the_method_s_intent}" />
-                        
+
                         <CheckBox x:Uid="SuppressHintsWhenParameterNamesDifferOnlyBySuffix"
                                   x:Name="SuppressHintsWhenParameterNamesDifferOnlyBySuffix"
                                   Content="{x:Static local:AdvancedOptionPageStrings.Option_Suppress_hints_when_parameter_names_differ_only_by_suffix}" />
-
                     </StackPanel>
                     
                     <CheckBox x:Name="DisplayInlineTypeHints"

From 714811407d792a9ba8256cbba226842d7a2b119f Mon Sep 17 00:00:00 2001
From: Ankita Khera <ankitakhera@microsoft.com>
Date: Thu, 19 Aug 2021 20:21:44 -0700
Subject: [PATCH 019/444] pr feedback

---
 src/Features/Core/Portable/InlineHints/InlineHint.cs | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/src/Features/Core/Portable/InlineHints/InlineHint.cs b/src/Features/Core/Portable/InlineHints/InlineHint.cs
index 19d1ecb9a9222..0a59e514388e8 100644
--- a/src/Features/Core/Portable/InlineHints/InlineHint.cs
+++ b/src/Features/Core/Portable/InlineHints/InlineHint.cs
@@ -22,20 +22,14 @@ public InlineHint(
             TextSpan span,
             ImmutableArray<TaggedText> displayParts,
             Func<Document, CancellationToken, Task<ImmutableArray<TaggedText>>>? getDescriptionAsync = null)
+            : this(span, displayParts, replacementText: null, getDescriptionAsync)
         {
-            if (displayParts.Length == 0)
-                throw new ArgumentException($"{nameof(displayParts)} must be non-empty");
-
-            Span = span;
-            DisplayParts = displayParts;
-            _getDescriptionAsync = getDescriptionAsync;
-            ReplacementText = null;
         }
 
         public InlineHint(
             TextSpan span,
             ImmutableArray<TaggedText> displayParts,
-            string replacementText,
+            string? replacementText,
             Func<Document, CancellationToken, Task<ImmutableArray<TaggedText>>>? getDescriptionAsync = null)
         {
             if (displayParts.Length == 0)

From a4690bbbb6d0a44c0320b61ea20e3cfab1bc42a7 Mon Sep 17 00:00:00 2001
From: Ankita Khera <ankitakhera@microsoft.com>
Date: Fri, 20 Aug 2021 09:45:26 -0700
Subject: [PATCH 020/444] working on replacing vars with type

---
 .../Core.Wpf/InlineHints/InlineHintsTag.cs    |  1 +
 .../AbstractInlineTypeHintsService.cs         | 33 ++++++++++++++++++-
 2 files changed, 33 insertions(+), 1 deletion(-)

diff --git a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
index 67fb9839236a2..994b362b9bfd2 100644
--- a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
@@ -67,6 +67,7 @@ private InlineHintsTag(
             adornment.ToolTipOpening += Border_ToolTipOpening;
 
             adornment.MouseLeftButtonDown += Adornment_MouseLeftButtonDown;
+            //adornment.MouseLeftButtonDown -= Adornment_MouseLeftButtonDown;
         }
 
         /// <summary>
diff --git a/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs b/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
index b49ce72cfc707..07196ad3ba09a 100644
--- a/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
+++ b/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
@@ -76,15 +76,46 @@ public async Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(
                     continue;
 
                 finalParts.AddRange(suffix);
+                var taggedText = finalParts.ToTaggedText();
+                var displayString = GetDisplayStringFromParts(taggedText);
 
                 result.Add(new InlineHint(
-                    span, finalParts.ToTaggedText(),
+                    span, taggedText,
                     InlineHintHelpers.GetDescriptionFunction(span.Start, type.GetSymbolKey(cancellationToken: cancellationToken))));
             }
 
             return result.ToImmutable();
         }
 
+        private static string? GetDisplayStringFromParts(ImmutableArray<TaggedText> taggedTexts)
+        {
+            var displayString = "";
+            if (taggedTexts.Length == 1)
+            {
+                var first = taggedTexts.First();
+
+                var trimStart = first.Text.TrimStart();
+                var trimBoth = trimStart.TrimEnd();
+                displayString += trimBoth;
+            }
+            else if (taggedTexts.Length >= 2)
+            {
+                var first = taggedTexts.First();
+                var trimStart = first.Text.TrimStart();
+
+                for (var i = 1; i < taggedTexts.Length - 1; i++)
+                {
+                    displayString += taggedTexts[i].Text;
+                }
+
+                var last = taggedTexts.Last();
+                var trimEnd = last.Text.TrimEnd();
+                displayString += trimEnd;
+            }
+
+            return displayString;
+        }
+
         private void AddParts(
             IAnonymousTypeDisplayService anonymousTypeService,
             ArrayBuilder<SymbolDisplayPart> finalParts,

From 1f28e1298057f1656ce1eb36a5fbaa523e060f70 Mon Sep 17 00:00:00 2001
From: Ankita Khera <ankitakhera@microsoft.com>
Date: Fri, 20 Aug 2021 12:26:51 -0700
Subject: [PATCH 021/444] need to fix stuff, get the overall span

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

diff --git a/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs b/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
index 07196ad3ba09a..36633ae98db05 100644
--- a/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
+++ b/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
@@ -80,7 +80,7 @@ public async Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(
                 var displayString = GetDisplayStringFromParts(taggedText);
 
                 result.Add(new InlineHint(
-                    span, taggedText,
+                    span, taggedText, displayString,
                     InlineHintHelpers.GetDescriptionFunction(span.Start, type.GetSymbolKey(cancellationToken: cancellationToken))));
             }
 
@@ -102,6 +102,7 @@ public async Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(
             {
                 var first = taggedTexts.First();
                 var trimStart = first.Text.TrimStart();
+                displayString += trimStart;
 
                 for (var i = 1; i < taggedTexts.Length - 1; i++)
                 {

From 615c104417cb0e949f083dd2bf9c4bda73d1f73d Mon Sep 17 00:00:00 2001
From: Ankita Khera <ankitakhera@microsoft.com>
Date: Fri, 20 Aug 2021 15:47:19 -0700
Subject: [PATCH 022/444] inserts the hints at the correct span, still need to
 test all cases of types

---
 .../Core.Wpf/InlineHints/InlineHintsTag.cs    |  3 ++-
 .../CSharpInlineTypeHintsService.cs           |  8 +++----
 ...AbstractInlineParameterNameHintsService.cs |  5 ++--
 .../AbstractInlineTypeHintsService.cs         | 24 ++++++++++++-------
 .../Core/Portable/InlineHints/InlineHint.cs   |  4 ++--
 .../Core/Portable/InlineHints/TypeHint.cs     |  7 ++++--
 6 files changed, 31 insertions(+), 20 deletions(-)

diff --git a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
index 994b362b9bfd2..c9b65c8e5253f 100644
--- a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
@@ -266,7 +266,8 @@ private void Adornment_MouseLeftButtonDown(object sender, MouseButtonEventArgs e
                 var replacementText = _hint.ReplacementText;
                 if (replacementText != null)
                 {
-                    _ = _textView.TextBuffer.Replace(_span, replacementText);
+                    var replacementValue = replacementText.Value;
+                    _ = _textView.TextBuffer.Replace(new VisualStudio.Text.Span(replacementValue.Span.Start, replacementValue.Span.Length), replacementValue.NewText);
                 }
             }
         }
diff --git a/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs b/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs
index cc423d436e8a3..006695cfaac45 100644
--- a/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs
+++ b/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs
@@ -57,7 +57,7 @@ public CSharpInlineTypeHintsService()
                     {
                         return node.Parent is VarPatternSyntax varPattern
                             ? CreateTypeHint(type, displayAllOverride, forImplicitVariableTypes, varPattern.VarKeyword, variableDesignation.Identifier)
-                            : new(type, new TextSpan(variableDesignation.Identifier.SpanStart, 0), trailingSpace: true);
+                            : new(type, new TextSpan(variableDesignation.Identifier.SpanStart, 0), null, trailingSpace: true);
                     }
                 }
                 else if (node is ForEachStatementSyntax { Type: { IsVar: true } } forEachStatement)
@@ -77,7 +77,7 @@ public CSharpInlineTypeHintsService()
                     if (parameter?.ContainingSymbol is IMethodSymbol { MethodKind: MethodKind.AnonymousFunction } &&
                         IsValidType(parameter?.Type))
                     {
-                        return new(parameter.Type, new TextSpan(parameterNode.Identifier.SpanStart, 0), trailingSpace: true);
+                        return new(parameter.Type, new TextSpan(parameterNode.Identifier.SpanStart, 0), null, trailingSpace: true);
                     }
                 }
             }
@@ -89,7 +89,7 @@ public CSharpInlineTypeHintsService()
                     var type = semanticModel.GetTypeInfo(implicitNew, cancellationToken).Type;
                     if (IsValidType(type))
                     {
-                        return new(type, new TextSpan(implicitNew.NewKeyword.Span.End, 0), leadingSpace: true);
+                        return new(type, new TextSpan(implicitNew.NewKeyword.Span.End, 0), null, leadingSpace: true);
                     }
                 }
             }
@@ -108,7 +108,7 @@ private static TypeHint CreateTypeHint(
             // if this is a hint that is placed in-situ (i.e. it's not overwriting text like 'var'), then place
             // a space after it to make things feel less cramped.
             var trailingSpace = span.Length == 0;
-            return new TypeHint(type, span, trailingSpace: trailingSpace);
+            return new TypeHint(type, span, displayAllSpan.Span, trailingSpace: trailingSpace);
         }
 
         private static TextSpan GetSpan(
diff --git a/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs b/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
index 8ca068d893f96..1f62e526305ba 100644
--- a/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
+++ b/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
@@ -91,10 +91,11 @@ void AddHintsIfAppropriate(SyntaxNode node)
                     if (HintMatches(kind, literalParameters, objectCreationParameters, otherParameters))
                     {
                         var inlineHintText = parameter.Name + ": ";
+                        var textSpan = new TextSpan(position, 0);
                         result.Add(new InlineHint(
-                            new TextSpan(position, 0),
+                            textSpan,
                             ImmutableArray.Create(new TaggedText(TextTags.Text, inlineHintText)),
-                            inlineHintText,
+                            new TextChange(textSpan, inlineHintText),
                             InlineHintHelpers.GetDescriptionFunction(position, parameter.GetSymbolKey(cancellationToken: cancellationToken))));
                     }
                 }
diff --git a/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs b/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
index 36633ae98db05..246390f218df0 100644
--- a/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
+++ b/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
@@ -63,7 +63,7 @@ public async Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(
                 if (hintOpt == null)
                     continue;
 
-                var (type, span, prefix, suffix) = hintOpt.Value;
+                var (type, span, insertSpan, prefix, suffix) = hintOpt.Value;
 
                 using var _2 = ArrayBuilder<SymbolDisplayPart>.GetInstance(out var finalParts);
                 finalParts.AddRange(prefix);
@@ -79,42 +79,48 @@ public async Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(
                 var taggedText = finalParts.ToTaggedText();
                 var displayString = GetDisplayStringFromParts(taggedText);
 
+                TextChange? textChange = null;
+                if (insertSpan is not null)
+                {
+                    textChange = new TextChange(insertSpan.Value, displayString);
+                }
+
                 result.Add(new InlineHint(
-                    span, taggedText, displayString,
+                    span, taggedText, textChange,
                     InlineHintHelpers.GetDescriptionFunction(span.Start, type.GetSymbolKey(cancellationToken: cancellationToken))));
             }
 
             return result.ToImmutable();
         }
 
-        private static string? GetDisplayStringFromParts(ImmutableArray<TaggedText> taggedTexts)
+        private static string GetDisplayStringFromParts(ImmutableArray<TaggedText> taggedTexts)
         {
-            var displayString = "";
+            var displayString = PooledStringBuilder.GetInstance();
             if (taggedTexts.Length == 1)
             {
                 var first = taggedTexts.First();
 
                 var trimStart = first.Text.TrimStart();
                 var trimBoth = trimStart.TrimEnd();
-                displayString += trimBoth;
+                return trimBoth;
             }
             else if (taggedTexts.Length >= 2)
             {
                 var first = taggedTexts.First();
                 var trimStart = first.Text.TrimStart();
-                displayString += trimStart;
+                displayString.Builder.Append(trimStart);
 
                 for (var i = 1; i < taggedTexts.Length - 1; i++)
                 {
-                    displayString += taggedTexts[i].Text;
+                    displayString.Builder.Append(taggedTexts[i].Text);
                 }
 
                 var last = taggedTexts.Last();
                 var trimEnd = last.Text.TrimEnd();
-                displayString += trimEnd;
+                displayString.Builder.Append(trimEnd);
             }
 
-            return displayString;
+            return displayString.ToStringAndFree();
         }
 
         private void AddParts(
diff --git a/src/Features/Core/Portable/InlineHints/InlineHint.cs b/src/Features/Core/Portable/InlineHints/InlineHint.cs
index 0a59e514388e8..d42bf7a67e508 100644
--- a/src/Features/Core/Portable/InlineHints/InlineHint.cs
+++ b/src/Features/Core/Portable/InlineHints/InlineHint.cs
@@ -15,7 +15,7 @@ internal readonly struct InlineHint
     {
         public readonly TextSpan Span;
         public readonly ImmutableArray<TaggedText> DisplayParts;
-        public readonly string? ReplacementText;
+        public readonly TextChange? ReplacementText;
         private readonly Func<Document, CancellationToken, Task<ImmutableArray<TaggedText>>>? _getDescriptionAsync;
 
         public InlineHint(
@@ -29,7 +29,7 @@ public InlineHint(
         public InlineHint(
             TextSpan span,
             ImmutableArray<TaggedText> displayParts,
-            string? replacementText,
+            TextChange? replacementText,
             Func<Document, CancellationToken, Task<ImmutableArray<TaggedText>>>? getDescriptionAsync = null)
         {
             if (displayParts.Length == 0)
diff --git a/src/Features/Core/Portable/InlineHints/TypeHint.cs b/src/Features/Core/Portable/InlineHints/TypeHint.cs
index b32021e2e05d5..4d25d1d0e51d6 100644
--- a/src/Features/Core/Portable/InlineHints/TypeHint.cs
+++ b/src/Features/Core/Portable/InlineHints/TypeHint.cs
@@ -14,13 +14,15 @@ internal readonly struct TypeHint
 
         public ITypeSymbol Type { get; }
         public TextSpan Span { get; }
+        public TextSpan? InsertSpan { get; }
         public ImmutableArray<SymbolDisplayPart> Prefix { get; }
         public ImmutableArray<SymbolDisplayPart> Suffix { get; }
 
-        public TypeHint(ITypeSymbol type, TextSpan span, bool leadingSpace = false, bool trailingSpace = false)
+        public TypeHint(ITypeSymbol type, TextSpan span, TextSpan? insertSpan, bool leadingSpace = false, bool trailingSpace = false)
         {
             Type = type;
             Span = span;
+            InsertSpan = insertSpan;
             Prefix = CreateSpaceSymbolPartArray(leadingSpace);
             Suffix = CreateSpaceSymbolPartArray(trailingSpace);
         }
@@ -28,10 +30,11 @@ public TypeHint(ITypeSymbol type, TextSpan span, bool leadingSpace = false, bool
         private static ImmutableArray<SymbolDisplayPart> CreateSpaceSymbolPartArray(bool hasSpace)
             => hasSpace ? s_spaceArray : ImmutableArray<SymbolDisplayPart>.Empty;
 
-        public void Deconstruct(out ITypeSymbol type, out TextSpan span, out ImmutableArray<SymbolDisplayPart> prefix, out ImmutableArray<SymbolDisplayPart> suffix)
+        public void Deconstruct(out ITypeSymbol type, out TextSpan span, out TextSpan? insertSpan, out ImmutableArray<SymbolDisplayPart> prefix, out ImmutableArray<SymbolDisplayPart> suffix)
         {
             type = Type;
             span = Span;
+            insertSpan = InsertSpan;
             prefix = Prefix;
             suffix = Suffix;
         }

From c50dc45b2495cb2c556aba2132e7fd1c6a7c5038 Mon Sep 17 00:00:00 2001
From: Ankita Khera <ankitakhera@microsoft.com>
Date: Fri, 20 Aug 2021 16:10:51 -0700
Subject: [PATCH 023/444] add support for implicit object creation

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

diff --git a/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs b/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs
index 006695cfaac45..98527e2fcb493 100644
--- a/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs
+++ b/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs
@@ -89,7 +89,8 @@ public CSharpInlineTypeHintsService()
                     var type = semanticModel.GetTypeInfo(implicitNew, cancellationToken).Type;
                     if (IsValidType(type))
                     {
-                        return new(type, new TextSpan(implicitNew.NewKeyword.Span.End, 0), null, leadingSpace: true);
+                        var span = new TextSpan(implicitNew.NewKeyword.Span.End, 0);
+                        return new(type, span, span, leadingSpace: true);
                     }
                 }
             }

From de5c2d5878d0d624ceab0e2a620e3b382e734694 Mon Sep 17 00:00:00 2001
From: Ankita Khera <ankitakhera@microsoft.com>
Date: Fri, 20 Aug 2021 21:36:25 -0700
Subject: [PATCH 024/444] need to insert something diff for vb/c#

---
 .../InlineHints/CSharpInlineParameterNameHintsService.cs     | 5 +++++
 .../InlineHints/AbstractInlineParameterNameHintsService.cs   | 5 +++--
 .../VisualBasicInlineParameterNameHintsService.vb            | 4 ++++
 3 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/Features/CSharp/Portable/InlineHints/CSharpInlineParameterNameHintsService.cs b/src/Features/CSharp/Portable/InlineHints/CSharpInlineParameterNameHintsService.cs
index 3448a64cc01c5..9fa448e42af50 100644
--- a/src/Features/CSharp/Portable/InlineHints/CSharpInlineParameterNameHintsService.cs
+++ b/src/Features/CSharp/Portable/InlineHints/CSharpInlineParameterNameHintsService.cs
@@ -91,5 +91,10 @@ protected override bool IsIndexer(SyntaxNode node, IParameterSymbol parameter)
         {
             return node is BracketedArgumentListSyntax;
         }
+
+        protected override string GetReplacementText(string parameterName)
+        {
+            return parameterName + ": ";
+        }
     }
 }
diff --git a/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs b/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
index 1f62e526305ba..23c34d7ca5e82 100644
--- a/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
+++ b/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
@@ -29,6 +29,7 @@ protected abstract void AddAllParameterNameHintLocations(
             CancellationToken cancellationToken);
 
         protected abstract bool IsIndexer(SyntaxNode node, IParameterSymbol parameter);
+        protected abstract string GetReplacementText(string parameterName);
 
         public async Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(Document document, TextSpan textSpan, CancellationToken cancellationToken)
         {
@@ -90,11 +91,11 @@ void AddHintsIfAppropriate(SyntaxNode node)
 
                     if (HintMatches(kind, literalParameters, objectCreationParameters, otherParameters))
                     {
-                        var inlineHintText = parameter.Name + ": ";
+                        var inlineHintText = GetReplacementText(parameter.Name);
                         var textSpan = new TextSpan(position, 0);
                         result.Add(new InlineHint(
                             textSpan,
-                            ImmutableArray.Create(new TaggedText(TextTags.Text, inlineHintText)),
+                            ImmutableArray.Create(new TaggedText(TextTags.Text, parameter.Name + ": ")),
                             new TextChange(textSpan, inlineHintText),
                             InlineHintHelpers.GetDescriptionFunction(position, parameter.GetSymbolKey(cancellationToken: cancellationToken))));
                     }
diff --git a/src/Features/VisualBasic/Portable/InlineHints/VisualBasicInlineParameterNameHintsService.vb b/src/Features/VisualBasic/Portable/InlineHints/VisualBasicInlineParameterNameHintsService.vb
index d39c903d08805..62d5984c72cef 100644
--- a/src/Features/VisualBasic/Portable/InlineHints/VisualBasicInlineParameterNameHintsService.vb
+++ b/src/Features/VisualBasic/Portable/InlineHints/VisualBasicInlineParameterNameHintsService.vb
@@ -91,5 +91,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.InlineHints
             Dim propertySymbol = TryCast(parameter.ContainingSymbol, IPropertySymbol)
             Return propertySymbol IsNot Nothing AndAlso propertySymbol.IsDefault
         End Function
+
+        Protected Overrides Function GetReplacementText(parameterName As String) As String
+            Return parameterName & ":="
+        End Function
     End Class
 End Namespace

From 7b3e5cf8410d6c73ef24f5e809c33bb3ac713c02 Mon Sep 17 00:00:00 2001
From: Ankita Khera <ankitakhera@microsoft.com>
Date: Tue, 7 Sep 2021 07:23:57 -0700
Subject: [PATCH 025/444] added named param for null

---
 .../Portable/InlineHints/CSharpInlineTypeHintsService.cs      | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs b/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs
index 98527e2fcb493..9eb7b09971d8d 100644
--- a/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs
+++ b/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs
@@ -57,7 +57,7 @@ public CSharpInlineTypeHintsService()
                     {
                         return node.Parent is VarPatternSyntax varPattern
                             ? CreateTypeHint(type, displayAllOverride, forImplicitVariableTypes, varPattern.VarKeyword, variableDesignation.Identifier)
-                            : new(type, new TextSpan(variableDesignation.Identifier.SpanStart, 0), null, trailingSpace: true);
+                            : new(type, new TextSpan(variableDesignation.Identifier.SpanStart, 0), insertSpan: null, trailingSpace: true);
                     }
                 }
                 else if (node is ForEachStatementSyntax { Type: { IsVar: true } } forEachStatement)
@@ -77,7 +77,7 @@ public CSharpInlineTypeHintsService()
                     if (parameter?.ContainingSymbol is IMethodSymbol { MethodKind: MethodKind.AnonymousFunction } &&
                         IsValidType(parameter?.Type))
                     {
-                        return new(parameter.Type, new TextSpan(parameterNode.Identifier.SpanStart, 0), null, trailingSpace: true);
+                        return new(parameter.Type, new TextSpan(parameterNode.Identifier.SpanStart, 0), insertSpan: null, trailingSpace: true);
                     }
                 }
             }

From 8d97d10cfc12e88f4d486430ce3a29583262ba53 Mon Sep 17 00:00:00 2001
From: Ankita Khera <ankitakhera@microsoft.com>
Date: Tue, 7 Sep 2021 07:35:01 -0700
Subject: [PATCH 026/444] format change

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

diff --git a/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs b/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
index 246390f218df0..d5350ddd22ffc 100644
--- a/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
+++ b/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
@@ -79,11 +79,9 @@ public async Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(
                 var taggedText = finalParts.ToTaggedText();
                 var displayString = GetDisplayStringFromParts(taggedText);
 
-                TextChange? textChange = null;
-                if (insertSpan is not null)
-                {
-                    textChange = new TextChange(insertSpan.Value, displayString);
-                }
+                var textChange = insertSpan is null
+                    ? (TextChange?)null
+                    : new TextChange(insertSpan.Value, displayString);
 
                 result.Add(new InlineHint(
                     span, taggedText, textChange,

From 88135cbef89e06e47767705880b5df10afa58034 Mon Sep 17 00:00:00 2001
From: Ankita Khera <ankitakhera@microsoft.com>
Date: Wed, 8 Sep 2021 09:38:03 -0700
Subject: [PATCH 027/444] pr feedback

---
 .../Core.Wpf/InlineHints/InlineHintsTag.cs         | 14 ++++++--------
 .../InlineHints/AbstractInlineTypeHintsService.cs  |  4 +---
 .../Core/Portable/InlineHints/InlineHint.cs        |  8 ++++----
 3 files changed, 11 insertions(+), 15 deletions(-)

diff --git a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
index c9b65c8e5253f..a4831014d90a8 100644
--- a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
@@ -66,8 +66,10 @@ private InlineHintsTag(
             adornment.ToolTip = "Quick info";
             adornment.ToolTipOpening += Border_ToolTipOpening;
 
-            adornment.MouseLeftButtonDown += Adornment_MouseLeftButtonDown;
-            //adornment.MouseLeftButtonDown -= Adornment_MouseLeftButtonDown;
+            if (_hint.ReplacementTextChange is not null)
+            {
+                adornment.MouseLeftButtonDown += Adornment_MouseLeftButtonDown;
+            }
         }
 
         /// <summary>
@@ -263,12 +265,8 @@ private void Adornment_MouseLeftButtonDown(object sender, MouseButtonEventArgs e
             if (e.ClickCount == 2)
             {
                 e.Handled = true;
-                var replacementText = _hint.ReplacementText;
-                if (replacementText != null)
-                {
-                    var replacementValue = replacementText.Value;
-                    _ = _textView.TextBuffer.Replace(new VisualStudio.Text.Span(replacementValue.Span.Start, replacementValue.Span.Length), replacementValue.NewText);
-                }
+                var replacementValue = _hint.ReplacementTextChange!.Value;
+                _ = _textView.TextBuffer.Replace(new VisualStudio.Text.Span(replacementValue.Span.Start, replacementValue.Span.Length), replacementValue.NewText);
             }
         }
     }
diff --git a/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs b/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
index d5350ddd22ffc..a6dd1ca67bb70 100644
--- a/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
+++ b/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
@@ -97,9 +97,7 @@ private static string GetDisplayStringFromParts(ImmutableArray<TaggedText> tagge
             if (taggedTexts.Length == 1)
             {
                 var first = taggedTexts.First();
-
-                var trimStart = first.Text.TrimStart();
-                var trimBoth = trimStart.TrimEnd();
+                var trimBoth = first.Text.Trim();
                 return trimBoth;
             }
             else if (taggedTexts.Length >= 2)
diff --git a/src/Features/Core/Portable/InlineHints/InlineHint.cs b/src/Features/Core/Portable/InlineHints/InlineHint.cs
index d42bf7a67e508..45f63b22ddb2e 100644
--- a/src/Features/Core/Portable/InlineHints/InlineHint.cs
+++ b/src/Features/Core/Portable/InlineHints/InlineHint.cs
@@ -15,21 +15,21 @@ internal readonly struct InlineHint
     {
         public readonly TextSpan Span;
         public readonly ImmutableArray<TaggedText> DisplayParts;
-        public readonly TextChange? ReplacementText;
+        public readonly TextChange? ReplacementTextChange;
         private readonly Func<Document, CancellationToken, Task<ImmutableArray<TaggedText>>>? _getDescriptionAsync;
 
         public InlineHint(
             TextSpan span,
             ImmutableArray<TaggedText> displayParts,
             Func<Document, CancellationToken, Task<ImmutableArray<TaggedText>>>? getDescriptionAsync = null)
-            : this(span, displayParts, replacementText: null, getDescriptionAsync)
+            : this(span, displayParts, replacementTextChange: null, getDescriptionAsync)
         {
         }
 
         public InlineHint(
             TextSpan span,
             ImmutableArray<TaggedText> displayParts,
-            TextChange? replacementText,
+            TextChange? replacementTextChange,
             Func<Document, CancellationToken, Task<ImmutableArray<TaggedText>>>? getDescriptionAsync = null)
         {
             if (displayParts.Length == 0)
@@ -38,7 +38,7 @@ public InlineHint(
             Span = span;
             DisplayParts = displayParts;
             _getDescriptionAsync = getDescriptionAsync;
-            ReplacementText = replacementText;
+            ReplacementTextChange = replacementTextChange;
         }
 
         /// <summary>

From 2cacb17996737cc6ba57fc7faee2c94830d32c44 Mon Sep 17 00:00:00 2001
From: Ankita Khera <ankitakhera@microsoft.com>
Date: Wed, 8 Sep 2021 12:21:33 -0700
Subject: [PATCH 028/444] moved to only construct string when necessary

---
 .../Core.Wpf/InlineHints/InlineHintsTag.cs    | 31 ++++++++++++++++++-
 .../AbstractInlineTypeHintsService.cs         | 31 +------------------
 2 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
index a4831014d90a8..d5956c09b79e0 100644
--- a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
@@ -266,8 +266,37 @@ private void Adornment_MouseLeftButtonDown(object sender, MouseButtonEventArgs e
             {
                 e.Handled = true;
                 var replacementValue = _hint.ReplacementTextChange!.Value;
-                _ = _textView.TextBuffer.Replace(new VisualStudio.Text.Span(replacementValue.Span.Start, replacementValue.Span.Length), replacementValue.NewText);
+                var replacementString = GetDisplayStringFromParts(_hint.DisplayParts);
+                _ = _textView.TextBuffer.Replace(new VisualStudio.Text.Span(replacementValue.Span.Start, replacementValue.Span.Length), replacementString);
             }
         }
+
+        private static string GetDisplayStringFromParts(ImmutableArray<TaggedText> taggedTexts)
+        {
+            var displayString = PooledStringBuilder.GetInstance();
+            if (taggedTexts.Length == 1)
+            {
+                var first = taggedTexts.First();
+                var trimBoth = first.Text.Trim();
+                return trimBoth;
+            }
+            else if (taggedTexts.Length >= 2)
+            {
+                var first = taggedTexts.First();
+                var trimStart = first.Text.TrimStart();
+                displayString.Builder.Append(trimStart);
+
+                for (var i = 1; i < taggedTexts.Length - 1; i++)
+                {
+                    displayString.Builder.Append(taggedTexts[i].Text);
+                }
+
+                var last = taggedTexts.Last();
+                var trimEnd = last.Text.TrimEnd();
+                displayString.Builder.Append(trimEnd);
+            }
+
+            return displayString.ToStringAndFree();
+        }
     }
 }
diff --git a/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs b/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
index a6dd1ca67bb70..d161a4c09b8a5 100644
--- a/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
+++ b/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
@@ -77,11 +77,10 @@ public async Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(
 
                 finalParts.AddRange(suffix);
                 var taggedText = finalParts.ToTaggedText();
-                var displayString = GetDisplayStringFromParts(taggedText);
 
                 var textChange = insertSpan is null
                     ? (TextChange?)null
-                    : new TextChange(insertSpan.Value, displayString);
+                    : new TextChange(insertSpan.Value, "");
 
                 result.Add(new InlineHint(
                     span, taggedText, textChange,
@@ -91,34 +90,6 @@ public async Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(
             return result.ToImmutable();
         }
 
-        private static string GetDisplayStringFromParts(ImmutableArray<TaggedText> taggedTexts)
-        {
-            var displayString = PooledStringBuilder.GetInstance();
-            if (taggedTexts.Length == 1)
-            {
-                var first = taggedTexts.First();
-                var trimBoth = first.Text.Trim();
-                return trimBoth;
-            }
-            else if (taggedTexts.Length >= 2)
-            {
-                var first = taggedTexts.First();
-                var trimStart = first.Text.TrimStart();
-                displayString.Builder.Append(trimStart);
-
-                for (var i = 1; i < taggedTexts.Length - 1; i++)
-                {
-                    displayString.Builder.Append(taggedTexts[i].Text);
-                }
-
-                var last = taggedTexts.Last();
-                var trimEnd = last.Text.TrimEnd();
-                displayString.Builder.Append(trimEnd);
-            }
-
-            return displayString.ToStringAndFree();
-        }
-
         private void AddParts(
             IAnonymousTypeDisplayService anonymousTypeService,
             ArrayBuilder<SymbolDisplayPart> finalParts,

From a6348426c506a48bb82330f418056eef9224f6a1 Mon Sep 17 00:00:00 2001
From: Ankita Khera <ankitakhera@microsoft.com>
Date: Wed, 8 Sep 2021 13:56:01 -0700
Subject: [PATCH 029/444] create textchange at the start, create the display
 string at the language level

---
 .../Core.Wpf/InlineHints/InlineHintsTag.cs    | 31 +------------------
 .../CSharpInlineTypeHintsService.cs           |  8 ++---
 .../AbstractInlineTypeHintsService.cs         |  8 ++---
 .../Core/Portable/InlineHints/TypeHint.cs     | 10 +++---
 4 files changed, 12 insertions(+), 45 deletions(-)

diff --git a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
index d5956c09b79e0..a4831014d90a8 100644
--- a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
@@ -266,37 +266,8 @@ private void Adornment_MouseLeftButtonDown(object sender, MouseButtonEventArgs e
             {
                 e.Handled = true;
                 var replacementValue = _hint.ReplacementTextChange!.Value;
-                var replacementString = GetDisplayStringFromParts(_hint.DisplayParts);
-                _ = _textView.TextBuffer.Replace(new VisualStudio.Text.Span(replacementValue.Span.Start, replacementValue.Span.Length), replacementString);
+                _ = _textView.TextBuffer.Replace(new VisualStudio.Text.Span(replacementValue.Span.Start, replacementValue.Span.Length), replacementValue.NewText);
             }
         }
-
-        private static string GetDisplayStringFromParts(ImmutableArray<TaggedText> taggedTexts)
-        {
-            var displayString = PooledStringBuilder.GetInstance();
-            if (taggedTexts.Length == 1)
-            {
-                var first = taggedTexts.First();
-                var trimBoth = first.Text.Trim();
-                return trimBoth;
-            }
-            else if (taggedTexts.Length >= 2)
-            {
-                var first = taggedTexts.First();
-                var trimStart = first.Text.TrimStart();
-                displayString.Builder.Append(trimStart);
-
-                for (var i = 1; i < taggedTexts.Length - 1; i++)
-                {
-                    displayString.Builder.Append(taggedTexts[i].Text);
-                }
-
-                var last = taggedTexts.Last();
-                var trimEnd = last.Text.TrimEnd();
-                displayString.Builder.Append(trimEnd);
-            }
-
-            return displayString.ToStringAndFree();
-        }
     }
 }
diff --git a/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs b/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs
index 9eb7b09971d8d..773b3b5a7a645 100644
--- a/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs
+++ b/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs
@@ -57,7 +57,7 @@ public CSharpInlineTypeHintsService()
                     {
                         return node.Parent is VarPatternSyntax varPattern
                             ? CreateTypeHint(type, displayAllOverride, forImplicitVariableTypes, varPattern.VarKeyword, variableDesignation.Identifier)
-                            : new(type, new TextSpan(variableDesignation.Identifier.SpanStart, 0), insertSpan: null, trailingSpace: true);
+                            : new(type, new TextSpan(variableDesignation.Identifier.SpanStart, 0), textChange: null, trailingSpace: true);
                     }
                 }
                 else if (node is ForEachStatementSyntax { Type: { IsVar: true } } forEachStatement)
@@ -77,7 +77,7 @@ public CSharpInlineTypeHintsService()
                     if (parameter?.ContainingSymbol is IMethodSymbol { MethodKind: MethodKind.AnonymousFunction } &&
                         IsValidType(parameter?.Type))
                     {
-                        return new(parameter.Type, new TextSpan(parameterNode.Identifier.SpanStart, 0), insertSpan: null, trailingSpace: true);
+                        return new(parameter.Type, new TextSpan(parameterNode.Identifier.SpanStart, 0), textChange: null, trailingSpace: true);
                     }
                 }
             }
@@ -90,7 +90,7 @@ public CSharpInlineTypeHintsService()
                     if (IsValidType(type))
                     {
                         var span = new TextSpan(implicitNew.NewKeyword.Span.End, 0);
-                        return new(type, span, span, leadingSpace: true);
+                        return new(type, span, new TextChange(span, type.ToDisplayString(s_minimalTypeStyle)), leadingSpace: true);
                     }
                 }
             }
@@ -109,7 +109,7 @@ private static TypeHint CreateTypeHint(
             // if this is a hint that is placed in-situ (i.e. it's not overwriting text like 'var'), then place
             // a space after it to make things feel less cramped.
             var trailingSpace = span.Length == 0;
-            return new TypeHint(type, span, displayAllSpan.Span, trailingSpace: trailingSpace);
+            return new TypeHint(type, span, new TextChange(displayAllSpan.Span, type.ToDisplayString(s_minimalTypeStyle)), trailingSpace: trailingSpace);
         }
 
         private static TextSpan GetSpan(
diff --git a/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs b/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
index d161a4c09b8a5..8585861122c87 100644
--- a/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
+++ b/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
@@ -17,7 +17,7 @@ namespace Microsoft.CodeAnalysis.InlineHints
 {
     internal abstract class AbstractInlineTypeHintsService : IInlineTypeHintsService
     {
-        private static readonly SymbolDisplayFormat s_minimalTypeStyle = new SymbolDisplayFormat(
+        protected static readonly SymbolDisplayFormat s_minimalTypeStyle = new SymbolDisplayFormat(
             genericsOptions: SymbolDisplayGenericsOptions.IncludeTypeParameters,
             miscellaneousOptions: SymbolDisplayMiscellaneousOptions.AllowDefaultLiteral | SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier | SymbolDisplayMiscellaneousOptions.UseSpecialTypes);
 
@@ -63,7 +63,7 @@ public async Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(
                 if (hintOpt == null)
                     continue;
 
-                var (type, span, insertSpan, prefix, suffix) = hintOpt.Value;
+                var (type, span, textChange, prefix, suffix) = hintOpt.Value;
 
                 using var _2 = ArrayBuilder<SymbolDisplayPart>.GetInstance(out var finalParts);
                 finalParts.AddRange(prefix);
@@ -78,10 +78,6 @@ public async Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(
                 finalParts.AddRange(suffix);
                 var taggedText = finalParts.ToTaggedText();
 
-                var textChange = insertSpan is null
-                    ? (TextChange?)null
-                    : new TextChange(insertSpan.Value, "");
-
                 result.Add(new InlineHint(
                     span, taggedText, textChange,
                     InlineHintHelpers.GetDescriptionFunction(span.Start, type.GetSymbolKey(cancellationToken: cancellationToken))));
diff --git a/src/Features/Core/Portable/InlineHints/TypeHint.cs b/src/Features/Core/Portable/InlineHints/TypeHint.cs
index 4d25d1d0e51d6..dd3795998a070 100644
--- a/src/Features/Core/Portable/InlineHints/TypeHint.cs
+++ b/src/Features/Core/Portable/InlineHints/TypeHint.cs
@@ -14,15 +14,15 @@ internal readonly struct TypeHint
 
         public ITypeSymbol Type { get; }
         public TextSpan Span { get; }
-        public TextSpan? InsertSpan { get; }
+        public TextChange? TextChange { get; }
         public ImmutableArray<SymbolDisplayPart> Prefix { get; }
         public ImmutableArray<SymbolDisplayPart> Suffix { get; }
 
-        public TypeHint(ITypeSymbol type, TextSpan span, TextSpan? insertSpan, bool leadingSpace = false, bool trailingSpace = false)
+        public TypeHint(ITypeSymbol type, TextSpan span, TextChange? textChange, bool leadingSpace = false, bool trailingSpace = false)
         {
             Type = type;
             Span = span;
-            InsertSpan = insertSpan;
+            TextChange = textChange;
             Prefix = CreateSpaceSymbolPartArray(leadingSpace);
             Suffix = CreateSpaceSymbolPartArray(trailingSpace);
         }
@@ -30,11 +30,11 @@ public TypeHint(ITypeSymbol type, TextSpan span, TextSpan? insertSpan, bool lead
         private static ImmutableArray<SymbolDisplayPart> CreateSpaceSymbolPartArray(bool hasSpace)
             => hasSpace ? s_spaceArray : ImmutableArray<SymbolDisplayPart>.Empty;
 
-        public void Deconstruct(out ITypeSymbol type, out TextSpan span, out TextSpan? insertSpan, out ImmutableArray<SymbolDisplayPart> prefix, out ImmutableArray<SymbolDisplayPart> suffix)
+        public void Deconstruct(out ITypeSymbol type, out TextSpan span, out TextChange? textChange, out ImmutableArray<SymbolDisplayPart> prefix, out ImmutableArray<SymbolDisplayPart> suffix)
         {
             type = Type;
             span = Span;
-            insertSpan = InsertSpan;
+            textChange = TextChange;
             prefix = Prefix;
             suffix = Suffix;
         }

From 7f96d2bf2a3f43509e086a71bc0d9e88506cfcf5 Mon Sep 17 00:00:00 2001
From: Ankita Khera <ankitakhera@microsoft.com>
Date: Wed, 8 Sep 2021 14:42:41 -0700
Subject: [PATCH 030/444] do not use the top level buffer, get the subject
 buffer

---
 src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs | 8 ++++++--
 .../Core.Wpf/InlineHints/InlineHintsTagger.cs             | 3 +--
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
index a4831014d90a8..7d3d5b92c4b48 100644
--- a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
@@ -38,6 +38,7 @@ internal class InlineHintsTag : IntraTextAdornmentTag
 
         private readonly IToolTipService _toolTipService;
         private readonly ITextView _textView;
+        private readonly ITextBuffer _subjectBuffer;
         private readonly SnapshotSpan _span;
         private readonly InlineHint _hint;
         private readonly IThreadingContext _threadingContext;
@@ -46,6 +47,7 @@ internal class InlineHintsTag : IntraTextAdornmentTag
         private InlineHintsTag(
             FrameworkElement adornment,
             ITextView textView,
+            ITextBuffer subjectBuffer,
             SnapshotSpan span,
             InlineHint hint,
             InlineHintsTaggerProvider taggerProvider)
@@ -54,6 +56,7 @@ private InlineHintsTag(
                    PositionAffinity.Predecessor)
         {
             _textView = textView;
+            _subjectBuffer = subjectBuffer;
             _span = span;
             _hint = hint;
             _streamingPresenter = taggerProvider.StreamingFindUsagesPresenter;
@@ -85,11 +88,12 @@ public static InlineHintsTag Create(
             SnapshotSpan span,
             InlineHintsTaggerProvider taggerProvider,
             IClassificationFormatMap formatMap,
+            ITextBuffer subjectBuffer,
             bool classify)
         {
             return new InlineHintsTag(
                 CreateElement(hint.DisplayParts, textView, format, formatMap, taggerProvider.TypeMap, classify),
-                textView, span, hint, taggerProvider);
+                textView, subjectBuffer, span, hint, taggerProvider);
         }
 
         public async Task<IReadOnlyCollection<object>> CreateDescriptionAsync(CancellationToken cancellationToken)
@@ -266,7 +270,7 @@ private void Adornment_MouseLeftButtonDown(object sender, MouseButtonEventArgs e
             {
                 e.Handled = true;
                 var replacementValue = _hint.ReplacementTextChange!.Value;
-                _ = _textView.TextBuffer.Replace(new VisualStudio.Text.Span(replacementValue.Span.Start, replacementValue.Span.Length), replacementValue.NewText);
+                _ = _subjectBuffer.Replace(new VisualStudio.Text.Span(replacementValue.Span.Start, replacementValue.Span.Length), replacementValue.NewText);
             }
         }
     }
diff --git a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTagger.cs b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTagger.cs
index 8bcf4daf765f1..bc84a57b16df9 100644
--- a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTagger.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTagger.cs
@@ -115,7 +115,6 @@ public IEnumerable<ITagSpan<IntraTextAdornmentTag>> GetTags(NormalizedSnapshotSp
                 // Calculate UI elements
                 _cache.Clear();
                 _cacheSnapshot = snapshot;
-
                 var document = snapshot.GetOpenDocumentInCurrentContextWithChanges();
                 var classify = document?.Project.Solution.Workspace.Options.GetOption(InlineHintsOptions.ColorHints, document?.Project.Language) ?? false;
 
@@ -133,7 +132,7 @@ public IEnumerable<ITagSpan<IntraTextAdornmentTag>> GetTags(NormalizedSnapshotSp
                     {
                         var dataTagSpan = dataTagSpans[0];
                         var parameterHintUITag = InlineHintsTag.Create(
-                            tag.Tag.Hint, Format, _textView, dataTagSpan, _taggerProvider, _formatMap, classify);
+                            tag.Tag.Hint, Format, _textView, dataTagSpan, _taggerProvider, _formatMap, snapshot.TextBuffer, classify);
 
                         _cache.Add(new TagSpan<IntraTextAdornmentTag>(dataTagSpan, parameterHintUITag));
                     }

From 8db4bfce7dcbf964a99884703a01ee7a8202c21e Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Sep 2021 18:45:56 -0700
Subject: [PATCH 031/444] Only produce suppressions/config for the normal
 priority group.

---
 .../Test2/CodeFixes/CodeFixServiceTests.vb           | 12 ++++++------
 .../Core/Portable/CodeFixes/ICodeFixService.cs       |  8 ++++----
 .../UnifiedSuggestedActionsSource.cs                 |  8 +++++++-
 3 files changed, 17 insertions(+), 11 deletions(-)

diff --git a/src/EditorFeatures/Test2/CodeFixes/CodeFixServiceTests.vb b/src/EditorFeatures/Test2/CodeFixes/CodeFixServiceTests.vb
index 9ed42e74f49bb..d2b1624fc3d3f 100644
--- a/src/EditorFeatures/Test2/CodeFixes/CodeFixServiceTests.vb
+++ b/src/EditorFeatures/Test2/CodeFixes/CodeFixServiceTests.vb
@@ -75,7 +75,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.CodeFixes.UnitTests
                 ' Verify available codefix with a global fixer
                 Dim fixes = Await codefixService.GetFixesAsync(document,
                     (Await document.GetSyntaxRootAsync()).FullSpan,
-                    includeConfigurationFixes:=True, cancellationToken:=CancellationToken.None)
+                    includeSuppressionFixes:=True, cancellationToken:=CancellationToken.None)
                 Assert.Equal(0, fixes.Count())
 
                 ' Verify available codefix with a global fixer + a project fixer
@@ -88,7 +88,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.CodeFixes.UnitTests
                 document = project.Documents.Single()
                 fixes = Await codefixService.GetFixesAsync(document,
                                                      (Await document.GetSyntaxRootAsync()).FullSpan,
-                                                     includeConfigurationFixes:=True, cancellationToken:=CancellationToken.None)
+                                                     includeSuppressionFixes:=True, cancellationToken:=CancellationToken.None)
                 Assert.Equal(1, fixes.Count())
 
                 ' Remove a project analyzer
@@ -96,7 +96,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.CodeFixes.UnitTests
                 document = project.Documents.Single()
                 fixes = Await codefixService.GetFixesAsync(document,
                                                      (Await document.GetSyntaxRootAsync()).FullSpan,
-                                                     includeConfigurationFixes:=True, cancellationToken:=CancellationToken.None)
+                                                     includeSuppressionFixes:=True, cancellationToken:=CancellationToken.None)
                 Assert.Equal(0, fixes.Count())
             End Using
         End Function
@@ -143,7 +143,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.CodeFixes.UnitTests
                 ' Verify no codefix with a global fixer
                 Dim fixes = Await codefixService.GetFixesAsync(document,
                                                          (Await document.GetSyntaxRootAsync()).FullSpan,
-                                                         includeConfigurationFixes:=True, cancellationToken:=CancellationToken.None)
+                                                         includeSuppressionFixes:=True, cancellationToken:=CancellationToken.None)
                 Assert.Equal(0, fixes.Count())
 
                 ' Verify no codefix with a global fixer + a project fixer
@@ -155,8 +155,8 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.CodeFixes.UnitTests
                 project = project.WithAnalyzerReferences(projectAnalyzerReferences)
                 document = project.Documents.Single()
                 fixes = Await codefixService.GetFixesAsync(document,
-                                                     (Await document.GetSyntaxRootAsync()).FullSpan,
-                                                     includeConfigurationFixes:=True, cancellationToken:=CancellationToken.None)
+                    (Await document.GetSyntaxRootAsync()).FullSpan,
+                    includeSuppressionFixes:=True, cancellationToken:=CancellationToken.None)
                 Assert.Equal(0, fixes.Count())
             End Using
         End Function
diff --git a/src/Features/Core/Portable/CodeFixes/ICodeFixService.cs b/src/Features/Core/Portable/CodeFixes/ICodeFixService.cs
index 4d31f79a088cc..d8d28dca33473 100644
--- a/src/Features/Core/Portable/CodeFixes/ICodeFixService.cs
+++ b/src/Features/Core/Portable/CodeFixes/ICodeFixService.cs
@@ -24,10 +24,10 @@ internal interface ICodeFixService
 
     internal static class ICodeFixServiceExtensions
     {
-        public static Task<ImmutableArray<CodeFixCollection>> GetFixesAsync(this ICodeFixService service, Document document, TextSpan range, bool includeConfigurationFixes, CancellationToken cancellationToken)
-            => service.GetFixesAsync(document, range, includeConfigurationFixes, isBlocking: false, cancellationToken);
+        public static Task<ImmutableArray<CodeFixCollection>> GetFixesAsync(this ICodeFixService service, Document document, TextSpan range, bool includeSuppressionFixes, CancellationToken cancellationToken)
+            => service.GetFixesAsync(document, range, includeSuppressionFixes, isBlocking: false, cancellationToken);
 
-        public static Task<ImmutableArray<CodeFixCollection>> GetFixesAsync(this ICodeFixService service, Document document, TextSpan range, bool includeConfigurationFixes, bool isBlocking, CancellationToken cancellationToken)
-            => service.GetFixesAsync(document, range, includeConfigurationFixes, CodeActionRequestPriority.None, isBlocking, addOperationScope: _ => null, cancellationToken);
+        public static Task<ImmutableArray<CodeFixCollection>> GetFixesAsync(this ICodeFixService service, Document document, TextSpan range, bool includeSuppressionFixes, bool isBlocking, CancellationToken cancellationToken)
+            => service.GetFixesAsync(document, range, includeSuppressionFixes, CodeActionRequestPriority.None, isBlocking, addOperationScope: _ => null, cancellationToken);
     }
 }
diff --git a/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs b/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs
index 3fe32ecc48cf8..ec31257aa1816 100644
--- a/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs
+++ b/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs
@@ -42,7 +42,13 @@ public static async ValueTask<ImmutableArray<UnifiedSuggestedActionSet>> GetFilt
             // Intentionally switch to a threadpool thread to compute fixes.  We do not want to accidentally
             // run any of this on the UI thread and potentially allow any code to take a dependency on that.
             var fixes = await Task.Run(() => codeFixService.GetFixesAsync(
-                document, selection, includeSuppressionFixes: true, priority, isBlocking, addOperationScope, cancellationToken), cancellationToken).ConfigureAwait(false);
+                document,
+                selection,
+                includeSuppressionFixes: priority == CodeActionRequestPriority.Normal,
+                priority,
+                isBlocking,
+                addOperationScope,
+                cancellationToken), cancellationToken).ConfigureAwait(false);
 
             var filteredFixes = fixes.WhereAsArray(c => c.Fixes.Length > 0);
             var organizedFixes = OrganizeFixes(workspace, filteredFixes);

From 7e1b922ed9c71e81adb75f1bfd76dc75cd152b1f Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Sep 2021 18:50:21 -0700
Subject: [PATCH 032/444] Add comment

---
 .../UnifiedSuggestions/UnifiedSuggestedActionsSource.cs       | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs b/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs
index ec31257aa1816..0b6d2ad4e6a2a 100644
--- a/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs
+++ b/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs
@@ -41,6 +41,10 @@ public static async ValueTask<ImmutableArray<UnifiedSuggestedActionSet>> GetFilt
         {
             // Intentionally switch to a threadpool thread to compute fixes.  We do not want to accidentally
             // run any of this on the UI thread and potentially allow any code to take a dependency on that.
+            //
+            // Only request suppression fixes if we're in the norma priority group.  The high priority group
+            // should not show them as that would cause them to appear higher than normal pri fixes and we
+            // always want these last.
             var fixes = await Task.Run(() => codeFixService.GetFixesAsync(
                 document,
                 selection,

From 7a423237e9c627f9a731900e5ba35cc0f19acf62 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Sep 2021 20:25:56 -0700
Subject: [PATCH 033/444] Fix tests

---
 .../Diagnostics/Suppression/SuppressionTests.cs           | 2 +-
 src/EditorFeatures/Test/CodeFixes/CodeFixServiceTests.cs  | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/Suppression/SuppressionTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/Suppression/SuppressionTests.cs
index 630addd939c8c..37829d27d62b9 100644
--- a/src/EditorFeatures/CSharpTest/Diagnostics/Suppression/SuppressionTests.cs
+++ b/src/EditorFeatures/CSharpTest/Diagnostics/Suppression/SuppressionTests.cs
@@ -270,7 +270,7 @@ void Method()
                     var diagnostics = await diagnosticService.GetDiagnosticsForSpanAsync(document, span);
                     Assert.Equal(2, diagnostics.Where(d => d.Id == "CS0219").Count());
 
-                    var allFixes = (await fixService.GetFixesAsync(document, span, includeConfigurationFixes: true, cancellationToken: CancellationToken.None))
+                    var allFixes = (await fixService.GetFixesAsync(document, span, includeSuppressionFixes: true, cancellationToken: CancellationToken.None))
                         .SelectMany(fixCollection => fixCollection.Fixes);
 
                     var cs0219Fixes = allFixes.Where(fix => fix.PrimaryDiagnostic.Id == "CS0219").ToArray();
diff --git a/src/EditorFeatures/Test/CodeFixes/CodeFixServiceTests.cs b/src/EditorFeatures/Test/CodeFixes/CodeFixServiceTests.cs
index 07bcb195d2f42..635b90542e6e7 100644
--- a/src/EditorFeatures/Test/CodeFixes/CodeFixServiceTests.cs
+++ b/src/EditorFeatures/Test/CodeFixes/CodeFixServiceTests.cs
@@ -87,7 +87,7 @@ public async Task TestGetFixesAsyncWithDuplicateDiagnostics()
             GetDocumentAndExtensionManager(tuple.analyzerService, workspace, out var document, out var extensionManager, analyzerReference);
 
             // Verify that we do not crash when computing fixes.
-            _ = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), includeConfigurationFixes: false, cancellationToken: CancellationToken.None);
+            _ = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), includeSuppressionFixes: false, cancellationToken: CancellationToken.None);
 
             // Verify that code fix is invoked with both the diagnostics in the context,
             // i.e. duplicate diagnostics are not silently discarded by the CodeFixService.
@@ -113,7 +113,7 @@ public async Task TestGetFixesAsyncHasNoDuplicateConfigurationActions()
             GetDocumentAndExtensionManager(tuple.analyzerService, workspace, out var document, out var extensionManager, analyzerReference);
 
             // Verify registered configuration code actions do not have duplicates.
-            var fixCollections = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), includeConfigurationFixes: true, cancellationToken: CancellationToken.None);
+            var fixCollections = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), includeSuppressionFixes: true, cancellationToken: CancellationToken.None);
             var codeActions = fixCollections.SelectMany(c => c.Fixes.Select(f => f.Action)).ToImmutableArray();
             Assert.Equal(7, codeActions.Length);
             var uniqueTitles = new HashSet<string>();
@@ -203,7 +203,7 @@ private static async Task<ImmutableArray<CodeFixCollection>> GetAddedFixesAsync(
             var reference = new MockAnalyzerReference(codefix, ImmutableArray.Create(diagnosticAnalyzer));
             var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);
             document = project.Documents.Single();
-            var fixes = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), includeConfigurationFixes: true, cancellationToken: CancellationToken.None);
+            var fixes = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), includeSuppressionFixes: true, cancellationToken: CancellationToken.None);
 
             if (exception)
             {
@@ -581,7 +581,7 @@ private static async Task<ImmutableArray<CodeFixCollection>> GetNuGetAndVsixCode
             var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);
 
             var document = project.Documents.Single();
-            return await fixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), includeConfigurationFixes: false, cancellationToken: CancellationToken.None);
+            return await fixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), includeSuppressionFixes: false, cancellationToken: CancellationToken.None);
         }
 
         private sealed class NuGetCodeFixProvider : AbstractNuGetOrVsixCodeFixProvider

From 4781ad56a8aef1a92be61d664bace3befa41fc8b Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Sep 2021 22:35:38 -0700
Subject: [PATCH 034/444] Include in the none-normal buckets

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

diff --git a/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs b/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs
index 0b6d2ad4e6a2a..3889d6dc43242 100644
--- a/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs
+++ b/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs
@@ -42,13 +42,13 @@ public static async ValueTask<ImmutableArray<UnifiedSuggestedActionSet>> GetFilt
             // Intentionally switch to a threadpool thread to compute fixes.  We do not want to accidentally
             // run any of this on the UI thread and potentially allow any code to take a dependency on that.
             //
-            // Only request suppression fixes if we're in the norma priority group.  The high priority group
+            // Only request suppression fixes if we're not in the high priority group.  The high priority group
             // should not show them as that would cause them to appear higher than normal pri fixes and we
             // always want these last.
             var fixes = await Task.Run(() => codeFixService.GetFixesAsync(
                 document,
                 selection,
-                includeSuppressionFixes: priority == CodeActionRequestPriority.Normal,
+                includeSuppressionFixes: priority != CodeActionRequestPriority.High,
                 priority,
                 isBlocking,
                 addOperationScope,

From ea1c6824284194eaec2b71056e1cbb1e102c8f1c Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Sep 2021 22:43:42 -0700
Subject: [PATCH 035/444] Have callers specify behavior.

---
 .../AsyncSuggestedActionsSource.cs            | 11 +++++++++--
 .../Suggestions/SuggestedActionsSource.cs     | 19 +++++++++++++------
 .../UnifiedSuggestedActionsSource.cs          |  7 ++-----
 .../Handler/CodeActions/CodeActionHelpers.cs  |  8 ++++++--
 4 files changed, 30 insertions(+), 15 deletions(-)

diff --git a/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs b/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs
index e20a234270372..96741296483ef 100644
--- a/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs
+++ b/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs
@@ -101,8 +101,14 @@ private async Task GetSuggestedActionsWorkerAsync(
 
                         if (priority != null)
                         {
+                            // Only request suppression fixes if we're not in the lowest priority group.  The other groups
+                            // should not show suppressions them as that would cause them to not appear at the end.
+
                             var allSets = GetCodeFixesAndRefactoringsAsync(
-                                state, requestedActionCategories, document, range, selection, _ => null,
+                                state, requestedActionCategories, document,
+                                range, selection,
+                                addOperationScope: _ => null,
+                                includeSuppressionFixes: priority.Value == CodeActionRequestPriority.Normal,
                                 priority.Value, cancellationToken).WithCancellation(cancellationToken).ConfigureAwait(false);
 
                             await foreach (var set in allSets)
@@ -125,6 +131,7 @@ private async IAsyncEnumerable<SuggestedActionSet> GetCodeFixesAndRefactoringsAs
                 SnapshotSpan range,
                 TextSpan? selection,
                 Func<string, IDisposable?> addOperationScope,
+                bool includeSuppressionFixes,
                 CodeActionRequestPriority priority,
                 [EnumeratorCancellation] CancellationToken cancellationToken)
             {
@@ -133,7 +140,7 @@ private async IAsyncEnumerable<SuggestedActionSet> GetCodeFixesAndRefactoringsAs
 
                 var fixesTask = GetCodeFixesAsync(
                     state, supportsFeatureService, requestedActionCategories, workspace, document, range,
-                    addOperationScope, priority, isBlocking: false, cancellationToken);
+                    addOperationScope, includeSuppressionFixes, priority, isBlocking: false, cancellationToken);
                 var refactoringsTask = GetRefactoringsAsync(
                     state, supportsFeatureService, requestedActionCategories, GlobalOptions, workspace, document, selection,
                     addOperationScope, priority, isBlocking: false, cancellationToken);
diff --git a/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionsSource.cs b/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionsSource.cs
index b7baa85aeca6a..a6c4d38c044c3 100644
--- a/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionsSource.cs
+++ b/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionsSource.cs
@@ -179,14 +179,20 @@ public bool TryGetTelemetryId(out Guid telemetryId)
 
                     // We convert the code fixes and refactorings to UnifiedSuggestedActionSets instead of
                     // SuggestedActionSets so that we can share logic between local Roslyn and LSP.
-                    var fixes = GetCodeFixesAsync(
+                    var fixesTask = GetCodeFixesAsync(
                         state, supportsFeatureService, requestedActionCategories, workspace, document, range,
-                        addOperationScope, CodeActionRequestPriority.None, isBlocking: true, cancellationToken).WaitAndGetResult(cancellationToken);
-                    var refactorings = GetRefactoringsAsync(
+                        addOperationScope, includeSuppressionFixes: true, CodeActionRequestPriority.None,
+                        isBlocking: true, cancellationToken);
+                    var refactoringsTask = GetRefactoringsAsync(
                         state, supportsFeatureService, requestedActionCategories, GlobalOptions, workspace, document, selection,
-                        addOperationScope, CodeActionRequestPriority.None, isBlocking: true, cancellationToken).WaitAndGetResult(cancellationToken);
+                        addOperationScope, CodeActionRequestPriority.None, isBlocking: true, cancellationToken);
 
-                    return ConvertToSuggestedActionSets(state, selection, fixes, refactorings);
+                    Task.WhenAll(fixesTask, refactoringsTask).WaitAndGetResult(cancellationToken);
+
+                    return ConvertToSuggestedActionSets(
+                        state, selection,
+                        fixesTask.WaitAndGetResult(cancellationToken),
+                        refactoringsTask.WaitAndGetResult(cancellationToken));
                 }
             }
 
@@ -258,6 +264,7 @@ protected static Task<ImmutableArray<UnifiedSuggestedActionSet>> GetCodeFixesAsy
                 Document document,
                 SnapshotSpan range,
                 Func<string, IDisposable?> addOperationScope,
+                bool includeSuppressionFixes,
                 CodeActionRequestPriority priority,
                 bool isBlocking,
                 CancellationToken cancellationToken)
@@ -271,7 +278,7 @@ protected static Task<ImmutableArray<UnifiedSuggestedActionSet>> GetCodeFixesAsy
 
                 return UnifiedSuggestedActionsSource.GetFilterAndOrderCodeFixesAsync(
                     workspace, state.Target.Owner._codeFixService, document, range.Span.ToTextSpan(),
-                    priority, isBlocking, addOperationScope, cancellationToken).AsTask();
+                    includeSuppressionFixes, priority, isBlocking, addOperationScope, cancellationToken).AsTask();
             }
 
             private static string GetFixCategory(DiagnosticSeverity severity)
diff --git a/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs b/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs
index 3889d6dc43242..8379e667cb3a7 100644
--- a/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs
+++ b/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs
@@ -34,6 +34,7 @@ public static async ValueTask<ImmutableArray<UnifiedSuggestedActionSet>> GetFilt
             ICodeFixService codeFixService,
             Document document,
             TextSpan selection,
+            bool includeSuppressionFixes,
             CodeActionRequestPriority priority,
             bool isBlocking,
             Func<string, IDisposable?> addOperationScope,
@@ -41,14 +42,10 @@ public static async ValueTask<ImmutableArray<UnifiedSuggestedActionSet>> GetFilt
         {
             // Intentionally switch to a threadpool thread to compute fixes.  We do not want to accidentally
             // run any of this on the UI thread and potentially allow any code to take a dependency on that.
-            //
-            // Only request suppression fixes if we're not in the high priority group.  The high priority group
-            // should not show them as that would cause them to appear higher than normal pri fixes and we
-            // always want these last.
             var fixes = await Task.Run(() => codeFixService.GetFixesAsync(
                 document,
                 selection,
-                includeSuppressionFixes: priority != CodeActionRequestPriority.High,
+                includeSuppressionFixes,
                 priority,
                 isBlocking,
                 addOperationScope,
diff --git a/src/Features/LanguageServer/Protocol/Handler/CodeActions/CodeActionHelpers.cs b/src/Features/LanguageServer/Protocol/Handler/CodeActions/CodeActionHelpers.cs
index 445c13e9a4877..86e31e77eca4f 100644
--- a/src/Features/LanguageServer/Protocol/Handler/CodeActions/CodeActionHelpers.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/CodeActions/CodeActionHelpers.cs
@@ -222,8 +222,12 @@ private static async ValueTask<ImmutableArray<UnifiedSuggestedActionSet>> GetAct
             var textSpan = ProtocolConversions.RangeToTextSpan(selection, text);
 
             var codeFixes = await UnifiedSuggestedActionsSource.GetFilterAndOrderCodeFixesAsync(
-                document.Project.Solution.Workspace, codeFixService, document, textSpan, CodeActionRequestPriority.None,
-                isBlocking: false, addOperationScope: _ => null, cancellationToken).ConfigureAwait(false);
+                document.Project.Solution.Workspace, codeFixService,
+                document, textSpan,
+                includeSuppressionFixes: true,
+                CodeActionRequestPriority.None,
+                isBlocking: false, addOperationScope: _ => null,
+                cancellationToken).ConfigureAwait(false);
 
             var codeRefactorings = await UnifiedSuggestedActionsSource.GetFilterAndOrderCodeRefactoringsAsync(
                 document.Project.Solution.Workspace, codeRefactoringService, document, textSpan, CodeActionRequestPriority.None, isBlocking: false,

From a9a316e25f187f589926225687a5cfd778708b1d Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Sep 2021 22:45:02 -0700
Subject: [PATCH 036/444] fix comment

---
 .../Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs b/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs
index 96741296483ef..0bcd83cd52f9d 100644
--- a/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs
+++ b/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs
@@ -101,7 +101,7 @@ private async Task GetSuggestedActionsWorkerAsync(
 
                         if (priority != null)
                         {
-                            // Only request suppression fixes if we're not in the lowest priority group.  The other groups
+                            // Only request suppression fixes if we're in the lowest priority group.  The other groups
                             // should not show suppressions them as that would cause them to not appear at the end.
 
                             var allSets = GetCodeFixesAndRefactoringsAsync(

From 59446d95139249fafd9eb268831a6dbf11eb706c Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Sep 2021 12:45:13 -0700
Subject: [PATCH 037/444] Enable async lightbulbs by default

---
 .../Core.Wpf/Suggestions/SuggestedActionsSourceProvider.cs | 6 +++---
 .../Core/Implementation/Suggestions/SuggestionsOptions.cs  | 6 +++---
 .../Suggestions/SuggestionsOptionsProvider.cs              | 2 +-
 .../CSharp/Impl/Options/AdvancedOptionPageControl.xaml     | 4 ++--
 .../CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs  | 7 +------
 .../CSharp/Impl/Options/AdvancedOptionPageStrings.cs       | 4 ++--
 src/VisualStudio/Core/Def/ServicesVSResources.resx         | 4 ++--
 .../Impl/Options/AdvancedOptionPageControl.xaml            | 4 ++--
 .../Impl/Options/AdvancedOptionPageControl.xaml.vb         | 6 +-----
 .../VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb  | 4 ++--
 10 files changed, 19 insertions(+), 28 deletions(-)

diff --git a/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionsSourceProvider.cs b/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionsSourceProvider.cs
index dc374051f4763..2c51f5ce827ba 100644
--- a/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionsSourceProvider.cs
+++ b/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionsSourceProvider.cs
@@ -90,10 +90,10 @@ public SuggestedActionsSourceProvider(
             if (textBuffer.IsInLspEditorContext())
                 return null;
 
-            var asyncEnabled = _globalOptions.GetOption(SuggestionsOptions.Asynchronous) ??
-                               _globalOptions.GetOption(SuggestionsOptions.AsynchronousFeatureFlag);
+            var asyncEnabled = _globalOptions.GetOption(SuggestionsOptions.Asynchronous) &&
+                               !_globalOptions.GetOption(SuggestionsOptions.AsynchronousQuickActionsDisableFeatureFlag);
 
-            return asyncEnabled == true
+            return asyncEnabled
                 ? new AsyncSuggestedActionsSource(_threadingContext, _globalOptions, this, textView, textBuffer, _suggestedActionCategoryRegistry)
                 : new SyncSuggestedActionsSource(_threadingContext, _globalOptions, this, textView, textBuffer, _suggestedActionCategoryRegistry);
         }
diff --git a/src/EditorFeatures/Core/Implementation/Suggestions/SuggestionsOptions.cs b/src/EditorFeatures/Core/Implementation/Suggestions/SuggestionsOptions.cs
index 968b578dd7ce1..9cdb4f646f82a 100644
--- a/src/EditorFeatures/Core/Implementation/Suggestions/SuggestionsOptions.cs
+++ b/src/EditorFeatures/Core/Implementation/Suggestions/SuggestionsOptions.cs
@@ -10,10 +10,10 @@ internal static class SuggestionsOptions
     {
         private const string FeatureName = "SuggestionsOptions";
 
-        public static readonly Option2<bool?> Asynchronous = new(FeatureName, nameof(Asynchronous), defaultValue: null,
+        public static readonly Option2<bool> Asynchronous = new(FeatureName, nameof(Asynchronous), defaultValue: true,
             new RoamingProfileStorageLocation("TextEditor.Specific.Suggestions.Asynchronous2"));
 
-        public static readonly Option2<bool> AsynchronousFeatureFlag = new(FeatureName, nameof(AsynchronousFeatureFlag), defaultValue: false,
-            new FeatureFlagStorageLocation("Roslyn.AsynchronousQuickActions"));
+        public static readonly Option2<bool> AsynchronousQuickActionsDisableFeatureFlag = new(FeatureName, nameof(AsynchronousQuickActionsDisableFeatureFlag), defaultValue: false,
+            new FeatureFlagStorageLocation("Roslyn.AsynchronousQuickActionsDisable"));
     }
 }
diff --git a/src/EditorFeatures/Core/Implementation/Suggestions/SuggestionsOptionsProvider.cs b/src/EditorFeatures/Core/Implementation/Suggestions/SuggestionsOptionsProvider.cs
index 56f4d8039e687..88d1cdf54ddb2 100644
--- a/src/EditorFeatures/Core/Implementation/Suggestions/SuggestionsOptionsProvider.cs
+++ b/src/EditorFeatures/Core/Implementation/Suggestions/SuggestionsOptionsProvider.cs
@@ -22,6 +22,6 @@ public SuggestionsOptionsProvider()
 
         public ImmutableArray<IOption> Options { get; } = ImmutableArray.Create<IOption>(
             SuggestionsOptions.Asynchronous,
-            SuggestionsOptions.AsynchronousFeatureFlag);
+            SuggestionsOptions.AsynchronousQuickActionsDisableFeatureFlag);
     }
 }
diff --git a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
index ab75a36c38e54..fb4f40cd68c6d 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
+++ b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
@@ -78,8 +78,8 @@
             <GroupBox x:Uid="QuickActionsBox"
                       Header="{x:Static local:AdvancedOptionPageStrings.Option_Quick_Actions}">
                 <StackPanel>
-                    <CheckBox x:Name="ComputeQuickActionsAsynchronouslyExperimental"
-                              Content="{x:Static local:AdvancedOptionPageStrings.Option_Compute_Quick_Actions_asynchronously_experimental}" />
+                    <CheckBox x:Name="ComputeQuickActionsAsynchronously"
+                              Content="{x:Static local:AdvancedOptionPageStrings.Option_Compute_Quick_Actions_asynchronously}" />
                 </StackPanel>
             </GroupBox>
             <GroupBox x:Uid="HighlightingGroupBox"
diff --git a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
index ea972366fdc65..60eb4d4464710 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
@@ -90,12 +90,7 @@ public AdvancedOptionPageControl(OptionStore optionStore, IComponentModel compon
             BindToOption(DisplayLineSeparators, FeatureOnOffOptions.LineSeparator, LanguageNames.CSharp);
 
             // Quick Actions
-            BindToOption(ComputeQuickActionsAsynchronouslyExperimental, SuggestionsOptions.Asynchronous, () =>
-            {
-                // If the option has not been set by the user, check if the option is enabled from experimentation.
-                // If so, default to that.
-                return optionStore.GetOption(SuggestionsOptions.AsynchronousFeatureFlag);
-            });
+            BindToOption(ComputeQuickActionsAsynchronously, SuggestionsOptions.Asynchronous);
 
             // Highlighting
             BindToOption(EnableHighlightReferences, FeatureOnOffOptions.ReferenceHighlighting, LanguageNames.CSharp);
diff --git a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs
index cabd02fb86aa0..ad6f03bf36349 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs
@@ -168,8 +168,8 @@ public static string Option_OptimizeForSolutionSize_Small
         public static string Option_Quick_Actions
             => ServicesVSResources.Quick_Actions;
 
-        public static string Option_Compute_Quick_Actions_asynchronously_experimental
-            => ServicesVSResources.Compute_Quick_Actions_asynchronously_experimental;
+        public static string Option_Compute_Quick_Actions_asynchronously
+            => ServicesVSResources.Compute_Quick_Actions_asynchronously;
 
         public static string Option_Outlining
             => ServicesVSResources.Outlining;
diff --git a/src/VisualStudio/Core/Def/ServicesVSResources.resx b/src/VisualStudio/Core/Def/ServicesVSResources.resx
index 0c89926d1c1e5..0c82a04c80d92 100644
--- a/src/VisualStudio/Core/Def/ServicesVSResources.resx
+++ b/src/VisualStudio/Core/Def/ServicesVSResources.resx
@@ -1787,8 +1787,8 @@ Additional information: {1}</value>
   <data name="Run_code_analysis_in_separate_process_requires_restart" xml:space="preserve">
     <value>Run code analysis in separate process (requires restart)</value>
   </data>
-  <data name="Compute_Quick_Actions_asynchronously_experimental" xml:space="preserve">
-    <value>Compute Quick Actions asynchronously (experimental, requires restart)</value>
+  <data name="Compute_Quick_Actions_asynchronously" xml:space="preserve">
+    <value>Compute Quick Actions asynchronously (requires restart)</value>
   </data>
   <data name="Quick_Actions" xml:space="preserve">
     <value>Quick Actions</value>
diff --git a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml
index df980c678a9e8..2aa93cfcf0322 100644
--- a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml
+++ b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml
@@ -62,8 +62,8 @@
             <GroupBox x:Uid="QuickActionsBox"
                       Header="{x:Static local:AdvancedOptionPageStrings.Option_Quick_Actions}">
                 <StackPanel>
-                    <CheckBox x:Name="ComputeQuickActionsAsynchronouslyExperimental"
-                              Content="{x:Static local:AdvancedOptionPageStrings.Option_Compute_Quick_Actions_asynchronously_experimental}" />
+                    <CheckBox x:Name="ComputeQuickActionsAsynchronously"
+                              Content="{x:Static local:AdvancedOptionPageStrings.Option_Compute_Quick_Actions_asynchronously}" />
                 </StackPanel>
             </GroupBox>
             <GroupBox x:Uid="HighlightingGroupBox"
diff --git a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb
index 514df6fe8bd38..266ff22fc38e4 100644
--- a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb
+++ b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb
@@ -68,11 +68,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Options
                          End Function)
 
             ' Quick Actions
-            BindToOption(ComputeQuickActionsAsynchronouslyExperimental, SuggestionsOptions.Asynchronous,
-                         Function()
-                             ' If the option has Not been set by the user, check if the option is enabled from experimentation.
-                             Return optionStore.GetOption(SuggestionsOptions.AsynchronousFeatureFlag)
-                         End Function)
+            BindToOption(ComputeQuickActionsAsynchronously, SuggestionsOptions.Asynchronous)
 
             ' Highlighting
             BindToOption(EnableHighlightReferences, FeatureOnOffOptions.ReferenceHighlighting, LanguageNames.VisualBasic)
diff --git a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb
index 11556798bcd3c..589e0ea516ffe 100644
--- a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb
+++ b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb
@@ -84,8 +84,8 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Options
         Public ReadOnly Property Option_Quick_Actions As String =
             ServicesVSResources.Quick_Actions
 
-        Public ReadOnly Property Option_Compute_Quick_Actions_asynchronously_experimental As String =
-            ServicesVSResources.Compute_Quick_Actions_asynchronously_experimental
+        Public ReadOnly Property Option_Compute_Quick_Actions_asynchronously As String =
+            ServicesVSResources.Compute_Quick_Actions_asynchronously
 
         Public ReadOnly Property Option_EnableLineCommit As String
             Get

From ef63c48cf4613091892cf26bc8107d3306dfb4a8 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Sep 2021 13:51:00 -0700
Subject: [PATCH 038/444] REmove optino

---
 .../CSharp/Impl/Options/AdvancedOptionPageControl.xaml     | 7 -------
 .../CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs  | 3 ---
 .../CSharp/Impl/Options/AdvancedOptionPageStrings.cs       | 3 ---
 src/VisualStudio/Core/Def/ServicesVSResources.resx         | 3 ---
 .../Impl/Options/AdvancedOptionPageControl.xaml            | 7 -------
 .../Impl/Options/AdvancedOptionPageControl.xaml.vb         | 3 ---
 .../VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb  | 3 ---
 7 files changed, 29 deletions(-)

diff --git a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
index fb4f40cd68c6d..2ab7d5e4ed383 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
+++ b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
@@ -75,13 +75,6 @@
                               Content="{x:Static local:AdvancedOptionPageStrings.Option_Add_missing_using_directives_on_paste}" />
                 </StackPanel>
             </GroupBox>
-            <GroupBox x:Uid="QuickActionsBox"
-                      Header="{x:Static local:AdvancedOptionPageStrings.Option_Quick_Actions}">
-                <StackPanel>
-                    <CheckBox x:Name="ComputeQuickActionsAsynchronously"
-                              Content="{x:Static local:AdvancedOptionPageStrings.Option_Compute_Quick_Actions_asynchronously}" />
-                </StackPanel>
-            </GroupBox>
             <GroupBox x:Uid="HighlightingGroupBox"
                       Header="{x:Static local:AdvancedOptionPageStrings.Option_Highlighting}">
                 <StackPanel>
diff --git a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
index 60eb4d4464710..7c566e5590024 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
@@ -89,9 +89,6 @@ public AdvancedOptionPageControl(OptionStore optionStore, IComponentModel compon
             BindToOption(ShowRemarksInQuickInfo, QuickInfoOptions.ShowRemarksInQuickInfo, LanguageNames.CSharp);
             BindToOption(DisplayLineSeparators, FeatureOnOffOptions.LineSeparator, LanguageNames.CSharp);
 
-            // Quick Actions
-            BindToOption(ComputeQuickActionsAsynchronously, SuggestionsOptions.Asynchronous);
-
             // Highlighting
             BindToOption(EnableHighlightReferences, FeatureOnOffOptions.ReferenceHighlighting, LanguageNames.CSharp);
             BindToOption(EnableHighlightKeywords, FeatureOnOffOptions.KeywordHighlighting, LanguageNames.CSharp);
diff --git a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs
index ad6f03bf36349..d4cddeec99eb6 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs
@@ -168,9 +168,6 @@ public static string Option_OptimizeForSolutionSize_Small
         public static string Option_Quick_Actions
             => ServicesVSResources.Quick_Actions;
 
-        public static string Option_Compute_Quick_Actions_asynchronously
-            => ServicesVSResources.Compute_Quick_Actions_asynchronously;
-
         public static string Option_Outlining
             => ServicesVSResources.Outlining;
 
diff --git a/src/VisualStudio/Core/Def/ServicesVSResources.resx b/src/VisualStudio/Core/Def/ServicesVSResources.resx
index 0c82a04c80d92..d7e22004ec9f9 100644
--- a/src/VisualStudio/Core/Def/ServicesVSResources.resx
+++ b/src/VisualStudio/Core/Def/ServicesVSResources.resx
@@ -1787,9 +1787,6 @@ Additional information: {1}</value>
   <data name="Run_code_analysis_in_separate_process_requires_restart" xml:space="preserve">
     <value>Run code analysis in separate process (requires restart)</value>
   </data>
-  <data name="Compute_Quick_Actions_asynchronously" xml:space="preserve">
-    <value>Compute Quick Actions asynchronously (requires restart)</value>
-  </data>
   <data name="Quick_Actions" xml:space="preserve">
     <value>Quick Actions</value>
   </data>
diff --git a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml
index 2aa93cfcf0322..0b92e48506ea5 100644
--- a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml
+++ b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml
@@ -59,13 +59,6 @@
                               Content="{x:Static local:AdvancedOptionPageStrings.Option_Add_missing_imports_on_paste}" />
                 </StackPanel>
             </GroupBox>
-            <GroupBox x:Uid="QuickActionsBox"
-                      Header="{x:Static local:AdvancedOptionPageStrings.Option_Quick_Actions}">
-                <StackPanel>
-                    <CheckBox x:Name="ComputeQuickActionsAsynchronously"
-                              Content="{x:Static local:AdvancedOptionPageStrings.Option_Compute_Quick_Actions_asynchronously}" />
-                </StackPanel>
-            </GroupBox>
             <GroupBox x:Uid="HighlightingGroupBox"
                       Header="{x:Static local:AdvancedOptionPageStrings.Option_Highlighting}">
                 <StackPanel>
diff --git a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb
index 266ff22fc38e4..2d88214abdccf 100644
--- a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb
+++ b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb
@@ -67,9 +67,6 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Options
                              Return False
                          End Function)
 
-            ' Quick Actions
-            BindToOption(ComputeQuickActionsAsynchronously, SuggestionsOptions.Asynchronous)
-
             ' Highlighting
             BindToOption(EnableHighlightReferences, FeatureOnOffOptions.ReferenceHighlighting, LanguageNames.VisualBasic)
             BindToOption(EnableHighlightKeywords, FeatureOnOffOptions.KeywordHighlighting, LanguageNames.VisualBasic)
diff --git a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb
index 589e0ea516ffe..ffb21980b4e80 100644
--- a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb
+++ b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb
@@ -84,9 +84,6 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Options
         Public ReadOnly Property Option_Quick_Actions As String =
             ServicesVSResources.Quick_Actions
 
-        Public ReadOnly Property Option_Compute_Quick_Actions_asynchronously As String =
-            ServicesVSResources.Compute_Quick_Actions_asynchronously
-
         Public ReadOnly Property Option_EnableLineCommit As String
             Get
                 Return BasicVSResources.Pretty_listing_reformatting_of_code

From bed0584fe2343cfd352555437dd234d3ea617727 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Tue, 21 Sep 2021 00:26:09 -0700
Subject: [PATCH 039/444] Generate xlf

---
 src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf     | 5 -----
 src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf     | 5 -----
 src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf     | 5 -----
 src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf     | 5 -----
 src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf     | 5 -----
 src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf     | 5 -----
 src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf     | 5 -----
 src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf     | 5 -----
 src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf  | 5 -----
 src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf     | 5 -----
 src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf     | 5 -----
 .../Core/Def/xlf/ServicesVSResources.zh-Hans.xlf             | 5 -----
 .../Core/Def/xlf/ServicesVSResources.zh-Hant.xlf             | 5 -----
 13 files changed, 65 deletions(-)

diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
index 89172149a05d7..d707c16da31bc 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
@@ -232,11 +232,6 @@
         <target state="translated">Komentáře</target>
         <note />
       </trans-unit>
-      <trans-unit id="Compute_Quick_Actions_asynchronously_experimental">
-        <source>Compute Quick Actions asynchronously (experimental, requires restart)</source>
-        <target state="translated">Asynchronní výpočet rychlých akcí (experimentální, vyžaduje restartování)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Containing_member">
         <source>Containing Member</source>
         <target state="translated">Obsahující člen</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
index e93c11295c2e8..a926da54e7669 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
@@ -232,11 +232,6 @@
         <target state="translated">Kommentare</target>
         <note />
       </trans-unit>
-      <trans-unit id="Compute_Quick_Actions_asynchronously_experimental">
-        <source>Compute Quick Actions asynchronously (experimental, requires restart)</source>
-        <target state="translated">Schnelle Aktionen asynchron berechnen (experimentell, Neustart erforderlich)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Containing_member">
         <source>Containing Member</source>
         <target state="translated">Enthaltender Member</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
index 8d5461370213d..c7b6eb08df3a1 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
@@ -232,11 +232,6 @@
         <target state="translated">Comentarios</target>
         <note />
       </trans-unit>
-      <trans-unit id="Compute_Quick_Actions_asynchronously_experimental">
-        <source>Compute Quick Actions asynchronously (experimental, requires restart)</source>
-        <target state="translated">Procesar acciones rápidas de forma asincrónica (experimental, requiere reinicio)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Containing_member">
         <source>Containing Member</source>
         <target state="translated">Miembro contenedor</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
index 5edf9fb232b1e..602147cb13cff 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
@@ -232,11 +232,6 @@
         <target state="translated">Commentaires</target>
         <note />
       </trans-unit>
-      <trans-unit id="Compute_Quick_Actions_asynchronously_experimental">
-        <source>Compute Quick Actions asynchronously (experimental, requires restart)</source>
-        <target state="translated">Calculer les actions rapides de manière asynchrone (expérimental, requiert un redémarrage)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Containing_member">
         <source>Containing Member</source>
         <target state="translated">Membre conteneur</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
index 251e983d4b638..18d52b16f8bb9 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
@@ -232,11 +232,6 @@
         <target state="translated">Commenti</target>
         <note />
       </trans-unit>
-      <trans-unit id="Compute_Quick_Actions_asynchronously_experimental">
-        <source>Compute Quick Actions asynchronously (experimental, requires restart)</source>
-        <target state="translated">Calcola Azioni rapide in modo asincrono (sperimentale, richiede il riavvio)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Containing_member">
         <source>Containing Member</source>
         <target state="translated">Membro contenitore</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
index 968e71fa0f0fa..a9b614ec08c26 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
@@ -232,11 +232,6 @@
         <target state="translated">コメント</target>
         <note />
       </trans-unit>
-      <trans-unit id="Compute_Quick_Actions_asynchronously_experimental">
-        <source>Compute Quick Actions asynchronously (experimental, requires restart)</source>
-        <target state="translated">クイック アクションを非同期で計算する (試験的、再起動が必要)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Containing_member">
         <source>Containing Member</source>
         <target state="translated">含んでいるメンバー</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
index d4d7216c53055..b5d8c6c6082f4 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
@@ -232,11 +232,6 @@
         <target state="translated">설명</target>
         <note />
       </trans-unit>
-      <trans-unit id="Compute_Quick_Actions_asynchronously_experimental">
-        <source>Compute Quick Actions asynchronously (experimental, requires restart)</source>
-        <target state="translated">빠른 작업을 비동기적으로 컴퓨팅(실험적, 다시 시작해야 함)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Containing_member">
         <source>Containing Member</source>
         <target state="translated">포함하는 멤버</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
index 76671b6fac935..6badc7958a6ae 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
@@ -232,11 +232,6 @@
         <target state="translated">Komentarze</target>
         <note />
       </trans-unit>
-      <trans-unit id="Compute_Quick_Actions_asynchronously_experimental">
-        <source>Compute Quick Actions asynchronously (experimental, requires restart)</source>
-        <target state="translated">Asynchroniczne szybkie akcje środowiska obliczeniowego (eksperymentalne, wymaga ponownego uruchomienia)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Containing_member">
         <source>Containing Member</source>
         <target state="translated">Zawierająca składowa</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
index 985b8b48d20d2..13d5c0b0b1a3f 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
@@ -232,11 +232,6 @@
         <target state="translated">Comentários</target>
         <note />
       </trans-unit>
-      <trans-unit id="Compute_Quick_Actions_asynchronously_experimental">
-        <source>Compute Quick Actions asynchronously (experimental, requires restart)</source>
-        <target state="translated">Calcular Ações Rápidas de forma assíncrona (experimental, requer reinicialização)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Containing_member">
         <source>Containing Member</source>
         <target state="translated">Contendo Membro</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
index 483f90220ef85..8c92c77a13feb 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
@@ -232,11 +232,6 @@
         <target state="translated">Комментарии</target>
         <note />
       </trans-unit>
-      <trans-unit id="Compute_Quick_Actions_asynchronously_experimental">
-        <source>Compute Quick Actions asynchronously (experimental, requires restart)</source>
-        <target state="translated">Асинхронное вычисление быстрых действий (экспериментальная функция, требуется перезапуск)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Containing_member">
         <source>Containing Member</source>
         <target state="translated">Содержащий член</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
index ef748e78efecf..0abfa879ea540 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
@@ -232,11 +232,6 @@
         <target state="translated">Açıklamalar</target>
         <note />
       </trans-unit>
-      <trans-unit id="Compute_Quick_Actions_asynchronously_experimental">
-        <source>Compute Quick Actions asynchronously (experimental, requires restart)</source>
-        <target state="translated">Hızlı Eylemleri zaman uyumsuz şekilde hesapla (deneysel, yeniden başlatma gerektirir)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Containing_member">
         <source>Containing Member</source>
         <target state="translated">Kapsayan Üye</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
index 955f4d4989c0e..d303d4b3c9b5f 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
@@ -232,11 +232,6 @@
         <target state="translated">备注</target>
         <note />
       </trans-unit>
-      <trans-unit id="Compute_Quick_Actions_asynchronously_experimental">
-        <source>Compute Quick Actions asynchronously (experimental, requires restart)</source>
-        <target state="translated">异步计算快速操作(实验性，需要重启)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Containing_member">
         <source>Containing Member</source>
         <target state="translated">包含成员</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
index 2bbede91c7f04..3a270a940a765 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
@@ -232,11 +232,6 @@
         <target state="translated">註解</target>
         <note />
       </trans-unit>
-      <trans-unit id="Compute_Quick_Actions_asynchronously_experimental">
-        <source>Compute Quick Actions asynchronously (experimental, requires restart)</source>
-        <target state="translated">非同步計算快速動作 (實驗性，需要重新開機)</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Containing_member">
         <source>Containing Member</source>
         <target state="translated">包含的成員</target>

From 4fe4995ebabc9493d06696c7a16cb9ed86ca4eb4 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Tue, 21 Sep 2021 09:12:00 -0700
Subject: [PATCH 040/444] Add fallback

---
 .../SuggestedActionsSourceProvider.cs           | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionsSourceProvider.cs b/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionsSourceProvider.cs
index 2c51f5ce827ba..a0f75236e4c14 100644
--- a/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionsSourceProvider.cs
+++ b/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionsSourceProvider.cs
@@ -12,6 +12,7 @@
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Editor.Tags;
+using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
@@ -90,12 +91,18 @@ public SuggestedActionsSourceProvider(
             if (textBuffer.IsInLspEditorContext())
                 return null;
 
-            var asyncEnabled = _globalOptions.GetOption(SuggestionsOptions.Asynchronous) &&
-                               !_globalOptions.GetOption(SuggestionsOptions.AsynchronousQuickActionsDisableFeatureFlag);
+            try
+            {
+                var asyncEnabled = _globalOptions.GetOption(SuggestionsOptions.Asynchronous) &&
+                                   !_globalOptions.GetOption(SuggestionsOptions.AsynchronousQuickActionsDisableFeatureFlag);
+                if (asyncEnabled)
+                    return new AsyncSuggestedActionsSource(_threadingContext, _globalOptions, this, textView, textBuffer, _suggestedActionCategoryRegistry);
+            }
+            catch (Exception ex) when (FatalError.ReportAndCatch(ex))
+            {
+            }
 
-            return asyncEnabled
-                ? new AsyncSuggestedActionsSource(_threadingContext, _globalOptions, this, textView, textBuffer, _suggestedActionCategoryRegistry)
-                : new SyncSuggestedActionsSource(_threadingContext, _globalOptions, this, textView, textBuffer, _suggestedActionCategoryRegistry);
+            return new SyncSuggestedActionsSource(_threadingContext, _globalOptions, this, textView, textBuffer, _suggestedActionCategoryRegistry);
         }
     }
 }

From 2afc0fc882acb6ce056144368f5ed3907ed4ea91 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Tue, 21 Sep 2021 10:20:19 -0700
Subject: [PATCH 041/444] New reg value

---
 .../Core/Implementation/Suggestions/SuggestionsOptions.cs       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/EditorFeatures/Core/Implementation/Suggestions/SuggestionsOptions.cs b/src/EditorFeatures/Core/Implementation/Suggestions/SuggestionsOptions.cs
index 9cdb4f646f82a..15d189c892015 100644
--- a/src/EditorFeatures/Core/Implementation/Suggestions/SuggestionsOptions.cs
+++ b/src/EditorFeatures/Core/Implementation/Suggestions/SuggestionsOptions.cs
@@ -11,7 +11,7 @@ internal static class SuggestionsOptions
         private const string FeatureName = "SuggestionsOptions";
 
         public static readonly Option2<bool> Asynchronous = new(FeatureName, nameof(Asynchronous), defaultValue: true,
-            new RoamingProfileStorageLocation("TextEditor.Specific.Suggestions.Asynchronous2"));
+            new RoamingProfileStorageLocation("TextEditor.Specific.Suggestions.Asynchronous3"));
 
         public static readonly Option2<bool> AsynchronousQuickActionsDisableFeatureFlag = new(FeatureName, nameof(AsynchronousQuickActionsDisableFeatureFlag), defaultValue: false,
             new FeatureFlagStorageLocation("Roslyn.AsynchronousQuickActionsDisable"));

From bbba16c5aaf41a6400510c75f0229a67bb5f2cf6 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Tue, 21 Sep 2021 12:43:54 -0700
Subject: [PATCH 042/444] Revert

---
 .../SuggestedActionsSourceProvider.cs           | 17 +++++------------
 1 file changed, 5 insertions(+), 12 deletions(-)

diff --git a/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionsSourceProvider.cs b/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionsSourceProvider.cs
index a0f75236e4c14..4977842adc9bb 100644
--- a/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionsSourceProvider.cs
+++ b/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionsSourceProvider.cs
@@ -91,18 +91,11 @@ public SuggestedActionsSourceProvider(
             if (textBuffer.IsInLspEditorContext())
                 return null;
 
-            try
-            {
-                var asyncEnabled = _globalOptions.GetOption(SuggestionsOptions.Asynchronous) &&
-                                   !_globalOptions.GetOption(SuggestionsOptions.AsynchronousQuickActionsDisableFeatureFlag);
-                if (asyncEnabled)
-                    return new AsyncSuggestedActionsSource(_threadingContext, _globalOptions, this, textView, textBuffer, _suggestedActionCategoryRegistry);
-            }
-            catch (Exception ex) when (FatalError.ReportAndCatch(ex))
-            {
-            }
-
-            return new SyncSuggestedActionsSource(_threadingContext, _globalOptions, this, textView, textBuffer, _suggestedActionCategoryRegistry);
+            var asyncEnabled = _globalOptions.GetOption(SuggestionsOptions.Asynchronous) &&
+                               !_globalOptions.GetOption(SuggestionsOptions.AsynchronousQuickActionsDisableFeatureFlag);
+            return asyncEnabled
+                ? new AsyncSuggestedActionsSource(_threadingContext, _globalOptions, this, textView, textBuffer, _suggestedActionCategoryRegistry)
+                : new SyncSuggestedActionsSource(_threadingContext, _globalOptions, this, textView, textBuffer, _suggestedActionCategoryRegistry);
         }
     }
 }

From c968da8b6e4db651bd684f84fffdd21cca72b167 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Tue, 21 Sep 2021 14:05:21 -0700
Subject: [PATCH 043/444] Spin until complete

---
 .../InProcess/TextViewWindow_InProc.cs            | 15 ++++++++++++++-
 .../TestUtilities/TestUtilities.cs                |  6 +++++-
 2 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs
index 1fc5a23030288..2bb5abc51c5ee 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs
@@ -362,9 +362,22 @@ private async Task<IEnumerable<ISuggestedAction>> GetLightBulbActionsAsync(ILigh
                 throw new InvalidOperationException(string.Format("No expanded light bulb session found after View.ShowSmartTag.  Buffer content type={0}", bufferType));
             }
 
-            if (activeSession.TryGetSuggestedActionSets(out var actionSets) != QuerySuggestedActionCompletionStatus.Completed)
+            var start = DateTime.Now;
+            IEnumerable<SuggestedActionSet> actionSets = Array.Empty<SuggestedActionSet>();
+            while (DateTime.Now - start < TimeSpan.FromSeconds(30))
             {
+                var status = activeSession.TryGetSuggestedActionSets(out actionSets);
+                if (status == QuerySuggestedActionCompletionStatus.CompletedWithoutData)
+                {
+                    await Task.Delay(TimeSpan.FromSeconds(1));
+                    continue;
+                }
+
+                if (status == QuerySuggestedActionCompletionStatus.Completed)
+                    break;
+
                 actionSets = Array.Empty<SuggestedActionSet>();
+                break;
             }
 
             return await SelectActionsAsync(actionSets);
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/TestUtilities.cs b/src/VisualStudio/IntegrationTest/TestUtilities/TestUtilities.cs
index 571fdf71a1c55..2965465cd73cd 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/TestUtilities.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/TestUtilities.cs
@@ -26,7 +26,7 @@ public static void ThrowIfExpectedItemNotFound<TCollection>(IEnumerable<TCollect
         {
             var shouldThrow = false;
             var sb = new StringBuilder();
-            sb.Append("The following expected item(s) not found:\r\n");
+            sb.AppendLine("The following expected item(s) not found:");
 
             foreach (var item in expected)
             {
@@ -39,6 +39,10 @@ public static void ThrowIfExpectedItemNotFound<TCollection>(IEnumerable<TCollect
 
             if (shouldThrow)
             {
+                sb.AppendLine("Actual items:");
+                foreach (var item in actual)
+                    sb.AppendLine(item.ToString());
+
                 throw new Exception(sb.ToString());
             }
         }

From f8b73829da174262b733770b2db689d2c1379f26 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Tue, 21 Sep 2021 14:10:57 -0700
Subject: [PATCH 044/444] Simplify

---
 .../TestUtilities/InProcess/TextViewWindow_InProc.cs         | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs
index 2bb5abc51c5ee..4a14054075310 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs
@@ -373,10 +373,9 @@ private async Task<IEnumerable<ISuggestedAction>> GetLightBulbActionsAsync(ILigh
                     continue;
                 }
 
-                if (status == QuerySuggestedActionCompletionStatus.Completed)
-                    break;
+                if (status != QuerySuggestedActionCompletionStatus.Completed)
+                    actionSets = Array.Empty<SuggestedActionSet>();
 
-                actionSets = Array.Empty<SuggestedActionSet>();
                 break;
             }
 

From 5e6b691ecb171016ad0149c01373981ffe8c1d01 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Tue, 21 Sep 2021 14:36:02 -0700
Subject: [PATCH 045/444] Remove incorrect check

---
 .../TestUtilities/InProcess/TextViewWindow_InProc.cs            | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs
index 4a14054075310..263bd1abb2ae3 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs
@@ -356,7 +356,7 @@ private async Task<IEnumerable<ISuggestedAction>> GetLightBulbActionsAsync(ILigh
             }
 
             var activeSession = broker.GetSession(view);
-            if (activeSession == null || !activeSession.IsExpanded)
+            if (activeSession == null)
             {
                 var bufferType = view.TextBuffer.ContentType.DisplayName;
                 throw new InvalidOperationException(string.Format("No expanded light bulb session found after View.ShowSmartTag.  Buffer content type={0}", bufferType));

From 0e31b8f57588d091a6630e06f167d06c48aab43d Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Tue, 21 Sep 2021 14:36:19 -0700
Subject: [PATCH 046/444] avoid hardcoded check

---
 .../TestUtilities/InProcess/TextViewWindow_InProc.cs            | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs
index 263bd1abb2ae3..bebe31050ed6c 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs
@@ -364,7 +364,7 @@ private async Task<IEnumerable<ISuggestedAction>> GetLightBulbActionsAsync(ILigh
 
             var start = DateTime.Now;
             IEnumerable<SuggestedActionSet> actionSets = Array.Empty<SuggestedActionSet>();
-            while (DateTime.Now - start < TimeSpan.FromSeconds(30))
+            while (DateTime.Now - start < Helper.HangMitigatingTimeout)
             {
                 var status = activeSession.TryGetSuggestedActionSets(out actionSets);
                 if (status == QuerySuggestedActionCompletionStatus.CompletedWithoutData)

From ce1a78b3bacf8fd72ce43582f3868e0b1352888e Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Tue, 21 Sep 2021 14:57:01 -0700
Subject: [PATCH 047/444] make sure add-using comes first

---
 .../AsyncSuggestedActionsSource.cs            | 36 ++-----------------
 1 file changed, 3 insertions(+), 33 deletions(-)

diff --git a/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs b/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs
index 0bcd83cd52f9d..8bcf3156e8b69 100644
--- a/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs
+++ b/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs
@@ -145,39 +145,9 @@ private async IAsyncEnumerable<SuggestedActionSet> GetCodeFixesAndRefactoringsAs
                     state, supportsFeatureService, requestedActionCategories, GlobalOptions, workspace, document, selection,
                     addOperationScope, priority, isBlocking: false, cancellationToken);
 
-                if (priority == CodeActionRequestPriority.High)
-                {
-                    // in a high pri scenario, return data as soon as possible so that the user can interact with them.
-                    // this is especially important for state-machine oriented refactorings (like rename) where the user
-                    // should always have access to them effectively synchronously.
-                    var firstTask = await Task.WhenAny(fixesTask, refactoringsTask).ConfigureAwait(false);
-                    var secondTask = firstTask == fixesTask ? refactoringsTask : fixesTask;
-
-                    var orderedTasks = new[] { firstTask, secondTask };
-                    foreach (var task in orderedTasks)
-                    {
-                        if (task == fixesTask)
-                        {
-                            var fixes = await fixesTask.ConfigureAwait(false);
-                            foreach (var set in ConvertToSuggestedActionSets(state, selection, fixes, ImmutableArray<UnifiedSuggestedActionSet>.Empty))
-                                yield return set;
-                        }
-                        else
-                        {
-                            Contract.ThrowIfFalse(task == refactoringsTask);
-
-                            var refactorings = await refactoringsTask.ConfigureAwait(false);
-                            foreach (var set in ConvertToSuggestedActionSets(state, selection, ImmutableArray<UnifiedSuggestedActionSet>.Empty, refactorings))
-                                yield return set;
-                        }
-                    }
-                }
-                else
-                {
-                    var actionsArray = await Task.WhenAll(fixesTask, refactoringsTask).ConfigureAwait(false);
-                    foreach (var set in ConvertToSuggestedActionSets(state, selection, fixes: actionsArray[0], refactorings: actionsArray[1]))
-                        yield return set;
-                }
+                var actionsArray = await Task.WhenAll(fixesTask, refactoringsTask).ConfigureAwait(false);
+                foreach (var set in ConvertToSuggestedActionSets(state, selection, fixes: actionsArray[0], refactorings: actionsArray[1]))
+                    yield return set;
             }
         }
     }

From 9619266a29859df9d914877e878b81b30405a6e6 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Tue, 21 Sep 2021 15:13:45 -0700
Subject: [PATCH 048/444] Test fixes

---
 .../AsyncSuggestedActionsSource.cs            |  2 +-
 .../IntegrationTest/TestUtilities/Helper.cs   |  2 +-
 .../InProcess/TextViewWindow_InProc.cs        | 18 +-------
 .../TestUtilities/LightBulbHelper.cs          | 41 ++++++++++++++++++-
 4 files changed, 42 insertions(+), 21 deletions(-)

diff --git a/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs b/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs
index 8bcf3156e8b69..abfda2b5a936f 100644
--- a/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs
+++ b/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs
@@ -146,7 +146,7 @@ private async IAsyncEnumerable<SuggestedActionSet> GetCodeFixesAndRefactoringsAs
                     addOperationScope, priority, isBlocking: false, cancellationToken);
 
                 var actionsArray = await Task.WhenAll(fixesTask, refactoringsTask).ConfigureAwait(false);
-                foreach (var set in ConvertToSuggestedActionSets(state, selection, fixes: actionsArray[0], refactorings: actionsArray[1]))
+                foreach (var set in ConvertToSuggestedActionSets(state, selection, fixes: await fixesTask.ConfigureAwait(false), refactorings: await refactoringsTask.ConfigureAwait(false)))
                     yield return set;
             }
         }
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/Helper.cs b/src/VisualStudio/IntegrationTest/TestUtilities/Helper.cs
index 8d6473ffc2eef..711bb43059e8c 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/Helper.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/Helper.cs
@@ -15,7 +15,7 @@ public static class Helper
         /// <summary>
         /// A long timeout used to avoid hangs in tests, where a test failure manifests as an operation never occurring.
         /// </summary>
-        public static readonly TimeSpan HangMitigatingTimeout = TimeSpan.FromMinutes(1);
+        public static readonly TimeSpan HangMitigatingTimeout = TimeSpan.FromSeconds(15);
 
         private static IUIAutomation2? _automation;
 
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs
index bebe31050ed6c..6ae52a9cd0c68 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/InProcess/TextViewWindow_InProc.cs
@@ -362,23 +362,7 @@ private async Task<IEnumerable<ISuggestedAction>> GetLightBulbActionsAsync(ILigh
                 throw new InvalidOperationException(string.Format("No expanded light bulb session found after View.ShowSmartTag.  Buffer content type={0}", bufferType));
             }
 
-            var start = DateTime.Now;
-            IEnumerable<SuggestedActionSet> actionSets = Array.Empty<SuggestedActionSet>();
-            while (DateTime.Now - start < Helper.HangMitigatingTimeout)
-            {
-                var status = activeSession.TryGetSuggestedActionSets(out actionSets);
-                if (status == QuerySuggestedActionCompletionStatus.CompletedWithoutData)
-                {
-                    await Task.Delay(TimeSpan.FromSeconds(1));
-                    continue;
-                }
-
-                if (status != QuerySuggestedActionCompletionStatus.Completed)
-                    actionSets = Array.Empty<SuggestedActionSet>();
-
-                break;
-            }
-
+            var actionSets = await LightBulbHelper.WaitForItemsAsync(broker, view);
             return await SelectActionsAsync(actionSets);
         }
 
diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/LightBulbHelper.cs b/src/VisualStudio/IntegrationTest/TestUtilities/LightBulbHelper.cs
index dfae5b60282e3..99765bc3aa17e 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/LightBulbHelper.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/LightBulbHelper.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.Language.Intellisense;
 using Microsoft.VisualStudio.Text.Editor;
@@ -11,11 +12,11 @@ namespace Microsoft.VisualStudio.IntegrationTest.Utilities
 {
     public static class LightBulbHelper
     {
-        public static Task<bool> WaitForLightBulbSessionAsync(ILightBulbBroker broker, IWpfTextView view)
+        public static async Task<bool> WaitForLightBulbSessionAsync(ILightBulbBroker broker, IWpfTextView view)
         {
             var startTime = DateTimeOffset.Now;
 
-            return Helper.RetryAsync(async () =>
+            var active = await Helper.RetryAsync(async () =>
             {
                 if (broker.IsLightBulbSessionActive(view))
                 {
@@ -33,6 +34,42 @@ public static Task<bool> WaitForLightBulbSessionAsync(ILightBulbBroker broker, I
 
                 return broker.IsLightBulbSessionActive(view);
             }, TimeSpan.Zero);
+
+            if (!active)
+                return false;
+
+            await WaitForItemsAsync(broker, view);
+            return true;
+        }
+
+        public static async Task<IEnumerable<SuggestedActionSet>> WaitForItemsAsync(ILightBulbBroker broker, IWpfTextView view)
+        {
+            var activeSession = broker.GetSession(view);
+            if (activeSession == null)
+            {
+                var bufferType = view.TextBuffer.ContentType.DisplayName;
+                throw new InvalidOperationException(string.Format("No expanded light bulb session found after View.ShowSmartTag.  Buffer content type={0}", bufferType));
+            }
+
+            var start = DateTime.Now;
+            IEnumerable<SuggestedActionSet> actionSets = Array.Empty<SuggestedActionSet>();
+            while (DateTime.Now - start < Helper.HangMitigatingTimeout)
+            {
+                var status = activeSession.TryGetSuggestedActionSets(out actionSets);
+                if (status is not QuerySuggestedActionCompletionStatus.Completed and
+                              not QuerySuggestedActionCompletionStatus.Canceled)
+                {
+                    await Task.Delay(TimeSpan.FromSeconds(1));
+                    continue;
+                }
+
+                if (status != QuerySuggestedActionCompletionStatus.Completed)
+                    actionSets = Array.Empty<SuggestedActionSet>();
+
+                break;
+            }
+
+            return actionSets;
         }
     }
 }

From bb7a01eb0162be8d706e90c6095a2e9b3483310a Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Tue, 21 Sep 2021 15:21:02 -0700
Subject: [PATCH 049/444] Test fixes

---
 .../IntegrationTests/CSharp/CSharpCodeActions.cs                | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpCodeActions.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpCodeActions.cs
index f07268c128b14..0442a82d82fe3 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpCodeActions.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpCodeActions.cs
@@ -511,12 +511,12 @@ static void Main(string[] args)
             var expectedItems = new[]
             {
                 "Rename 'P2' to 'Foober'",
+                "Goober - using N;",
                 "Generate type 'Foober'",
                 "Generate class 'Foober' in new file",
                 "Generate class 'Foober'",
                 "Generate nested class 'Foober'",
                 "Generate new type...",
-                "Goober - using N;",
                 "Suppress or Configure issues",
                 "Suppress CS0168",
                 "in Source",

From 7524b9d92962b720553ede5033bf601084053fea Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Tue, 21 Sep 2021 15:34:18 -0700
Subject: [PATCH 050/444] remove var

---
 .../Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs b/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs
index abfda2b5a936f..3a51e1fd4f9df 100644
--- a/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs
+++ b/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs
@@ -145,7 +145,7 @@ private async IAsyncEnumerable<SuggestedActionSet> GetCodeFixesAndRefactoringsAs
                     state, supportsFeatureService, requestedActionCategories, GlobalOptions, workspace, document, selection,
                     addOperationScope, priority, isBlocking: false, cancellationToken);
 
-                var actionsArray = await Task.WhenAll(fixesTask, refactoringsTask).ConfigureAwait(false);
+                await Task.WhenAll(fixesTask, refactoringsTask).ConfigureAwait(false);
                 foreach (var set in ConvertToSuggestedActionSets(state, selection, fixes: await fixesTask.ConfigureAwait(false), refactorings: await refactoringsTask.ConfigureAwait(false)))
                     yield return set;
             }

From d8548ce4574ab7f400373cbe310042770d3dd397 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Tue, 21 Sep 2021 19:53:59 -0700
Subject: [PATCH 051/444] remove entry that is now inlined.

---
 .../IntegrationTest/IntegrationTests/CSharp/CSharpCodeActions.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpCodeActions.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpCodeActions.cs
index 0442a82d82fe3..e055f0f719b5e 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpCodeActions.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpCodeActions.cs
@@ -512,7 +512,6 @@ static void Main(string[] args)
             {
                 "Rename 'P2' to 'Foober'",
                 "Goober - using N;",
-                "Generate type 'Foober'",
                 "Generate class 'Foober' in new file",
                 "Generate class 'Foober'",
                 "Generate nested class 'Foober'",

From c123b935e9b0e9d363f75ae340f0cb3b0d8ed501 Mon Sep 17 00:00:00 2001
From: Ankita Khera <ankitakhera@microsoft.com>
Date: Wed, 22 Sep 2021 12:24:16 -0700
Subject: [PATCH 052/444] need to figure out how test double click on an
 adornment

---
 .../InlineHints/AbstractInlineHintsTests.vb   | 21 +++++++++++++++++++
 .../InlineHints/CSharpInlineTypeHintsTests.vb | 20 ++++++++++++++++++
 2 files changed, 41 insertions(+)

diff --git a/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb b/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb
index 7ff6ad62d5b99..eb15103d48289 100644
--- a/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb
+++ b/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb
@@ -66,5 +66,26 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
                 ValidateSpans(hostDocument, producedTags)
             End Using
         End Function
+
+        'Protected Async Function VerifyTypeHintsDoubleClick(test As XElement, Optional optionIsEnabled As Boolean = True, Optional ephemeral As Boolean = False) As Task
+        '    Using workspace = TestWorkspace.Create(test)
+        '        WpfTestRunner.RequireWpfFact($"{NameOf(AbstractInlineHintsTests)}.{NameOf(Me.VerifyTypeHints)} creates asynchronous taggers")
+
+        '        Dim language = workspace.CurrentSolution.Projects().First().Language
+        '        workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(
+        '        workspace.Options.WithChangedOption(InlineHintsOptions.EnabledForTypes, language, optionIsEnabled AndAlso Not ephemeral).
+        '                          WithChangedOption(InlineHintsOptions.DisplayAllOverride, ephemeral)))
+
+        '        Dim hostDocument = workspace.Documents.Single()
+        '        Dim snapshot = hostDocument.GetTextBuffer().CurrentSnapshot
+        '        Dim document = workspace.CurrentSolution.GetDocument(hostDocument.Id)
+        '        Dim tagService = document.GetRequiredLanguageService(Of IInlineTypeHintsService)
+        '        Dim typeHints = Await tagService.GetInlineHintsAsync(document, New Text.TextSpan(0, snapshot.Length), New CancellationToken())
+
+        '        For Each hint In typeHints
+        '            hint.ReplacementTextChange.Value.
+        '        Next
+        '    End Using
+        'End Function
     End Class
 End Namespace
diff --git a/src/EditorFeatures/Test2/InlineHints/CSharpInlineTypeHintsTests.vb b/src/EditorFeatures/Test2/InlineHints/CSharpInlineTypeHintsTests.vb
index cba5324c556e7..9232ddeef73a5 100644
--- a/src/EditorFeatures/Test2/InlineHints/CSharpInlineTypeHintsTests.vb
+++ b/src/EditorFeatures/Test2/InlineHints/CSharpInlineTypeHintsTests.vb
@@ -461,5 +461,25 @@ class A
 
             Await VerifyTypeHints(input)
         End Function
+
+        <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
+        Public Async Function TestDoubleClickOnNonOverwriteType() As Task
+            Dim input =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void Main() 
+    {
+        var {|int :|}i = 0;
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyTypeHints(input)
+        End Function
     End Class
 End Namespace

From f581e990f9fb058b243bbc0c25ce4eb4b8679150 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Wed, 22 Sep 2021 18:50:36 -0700
Subject: [PATCH 053/444] Don't inline lightbulb actions if the total count
 would be too high

---
 .../AsyncSuggestedActionsSource.cs            | 20 +++++++++++++++++--
 .../Suggestions/SuggestedActionsSource.cs     | 12 ++++++++---
 .../Handlers/CodeActions/CodeActionHelpers.cs |  3 ++-
 .../UnifiedSuggestedActionsSource.cs          | 17 ++++++++--------
 .../CSharp/CSharpCodeActions.cs               |  1 +
 5 files changed, 38 insertions(+), 15 deletions(-)

diff --git a/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs b/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs
index 9d6528d333460..71a7bb34c8fca 100644
--- a/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs
+++ b/src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs
@@ -89,6 +89,14 @@ private async Task GetSuggestedActionsWorkerAsync(
                     if (document is null)
                         return;
 
+                    // Keep track of how many actions we've put in the lightbulb at each priority level.  We do
+                    // this as each priority level will both sort and inline actions.  However, we don't want to
+                    // inline actions at each priority if it's going to make the total number of actions too high.
+                    // This does mean we might inline actions from a higher priority group, and then disable 
+                    // inlining for lower pri groups.  However, intuitively, that is what we want.  More important
+                    // items should be pushed higher up, and less important items shouldn't take up that much space.
+                    var currentActionCount = 0;
+
                     // Collectors are in priority order.  So just walk them from highest to lowest.
                     foreach (var collector in collectors)
                     {
@@ -109,10 +117,14 @@ private async Task GetSuggestedActionsWorkerAsync(
                                 range, selection,
                                 addOperationScope: _ => null,
                                 includeSuppressionFixes: priority.Value == CodeActionRequestPriority.Normal,
-                                priority.Value, cancellationToken).WithCancellation(cancellationToken).ConfigureAwait(false);
+                                priority.Value,
+                                currentActionCount, cancellationToken).WithCancellation(cancellationToken).ConfigureAwait(false);
 
                             await foreach (var set in allSets)
+                            {
+                                currentActionCount += set.Actions.Count();
                                 collector.Add(set);
+                            }
                         }
 
                         // Ensure we always complete the collector even if we didn't add any items to it.
@@ -133,6 +145,7 @@ private async IAsyncEnumerable<SuggestedActionSet> GetCodeFixesAndRefactoringsAs
                 Func<string, IDisposable?> addOperationScope,
                 bool includeSuppressionFixes,
                 CodeActionRequestPriority priority,
+                int currentActionCount,
                 [EnumeratorCancellation] CancellationToken cancellationToken)
             {
                 var workspace = document.Project.Solution.Workspace;
@@ -146,7 +159,10 @@ private async IAsyncEnumerable<SuggestedActionSet> GetCodeFixesAndRefactoringsAs
                     addOperationScope, priority, isBlocking: false, cancellationToken);
 
                 await Task.WhenAll(fixesTask, refactoringsTask).ConfigureAwait(false);
-                foreach (var set in ConvertToSuggestedActionSets(state, selection, fixes: await fixesTask.ConfigureAwait(false), refactorings: await refactoringsTask.ConfigureAwait(false)))
+
+                var fixes = await fixesTask.ConfigureAwait(false);
+                var refactorings = await refactoringsTask.ConfigureAwait(false);
+                foreach (var set in ConvertToSuggestedActionSets(state, selection, fixes, refactorings, currentActionCount))
                     yield return set;
             }
         }
diff --git a/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionsSource.cs b/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionsSource.cs
index a6c4d38c044c3..8bd8d132fbc6f 100644
--- a/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionsSource.cs
+++ b/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionsSource.cs
@@ -192,13 +192,19 @@ public bool TryGetTelemetryId(out Guid telemetryId)
                     return ConvertToSuggestedActionSets(
                         state, selection,
                         fixesTask.WaitAndGetResult(cancellationToken),
-                        refactoringsTask.WaitAndGetResult(cancellationToken));
+                        refactoringsTask.WaitAndGetResult(cancellationToken),
+                        currentActionCount: 0);
                 }
             }
 
-            protected IEnumerable<SuggestedActionSet> ConvertToSuggestedActionSets(ReferenceCountedDisposable<State> state, TextSpan? selection, ImmutableArray<UnifiedSuggestedActionSet> fixes, ImmutableArray<UnifiedSuggestedActionSet> refactorings)
+            protected IEnumerable<SuggestedActionSet> ConvertToSuggestedActionSets(
+                ReferenceCountedDisposable<State> state,
+                TextSpan? selection,
+                ImmutableArray<UnifiedSuggestedActionSet> fixes,
+                ImmutableArray<UnifiedSuggestedActionSet> refactorings,
+                int currentActionCount)
             {
-                var filteredSets = UnifiedSuggestedActionsSource.FilterAndOrderActionSets(fixes, refactorings, selection);
+                var filteredSets = UnifiedSuggestedActionsSource.FilterAndOrderActionSets(fixes, refactorings, selection, currentActionCount);
                 return filteredSets.SelectAsArray(s => ConvertToSuggestedActionSet(s, state.Target.Owner, state.Target.SubjectBuffer)).WhereNotNull();
             }
 
diff --git a/src/EditorFeatures/Core/Implementation/LanguageServer/Handlers/CodeActions/CodeActionHelpers.cs b/src/EditorFeatures/Core/Implementation/LanguageServer/Handlers/CodeActions/CodeActionHelpers.cs
index 86e31e77eca4f..ee5753a9b6595 100644
--- a/src/EditorFeatures/Core/Implementation/LanguageServer/Handlers/CodeActions/CodeActionHelpers.cs
+++ b/src/EditorFeatures/Core/Implementation/LanguageServer/Handlers/CodeActions/CodeActionHelpers.cs
@@ -233,7 +233,8 @@ private static async ValueTask<ImmutableArray<UnifiedSuggestedActionSet>> GetAct
                 document.Project.Solution.Workspace, codeRefactoringService, document, textSpan, CodeActionRequestPriority.None, isBlocking: false,
                 addOperationScope: _ => null, filterOutsideSelection: false, cancellationToken).ConfigureAwait(false);
 
-            var actionSets = UnifiedSuggestedActionsSource.FilterAndOrderActionSets(codeFixes, codeRefactorings, textSpan);
+            var actionSets = UnifiedSuggestedActionsSource.FilterAndOrderActionSets(
+                codeFixes, codeRefactorings, textSpan, currentActionCount: 0);
             return actionSets;
         }
 
diff --git a/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs b/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs
index 255cbfb79f9ae..cd29f22ce0d69 100644
--- a/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs
+++ b/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs
@@ -518,7 +518,8 @@ private static UnifiedSuggestedActionSetPriority GetUnifiedSuggestedActionSetPri
         public static ImmutableArray<UnifiedSuggestedActionSet> FilterAndOrderActionSets(
             ImmutableArray<UnifiedSuggestedActionSet> fixes,
             ImmutableArray<UnifiedSuggestedActionSet> refactorings,
-            TextSpan? selectionOpt)
+            TextSpan? selectionOpt,
+            int currentActionCount)
         {
             // Get the initial set of action sets, with refactorings and fixes appropriately
             // ordered against each other.
@@ -528,7 +529,7 @@ public static ImmutableArray<UnifiedSuggestedActionSet> FilterAndOrderActionSets
 
             // Now that we have the entire set of action sets, inline, sort and filter
             // them appropriately against each other.
-            var allActionSets = InlineActionSetsIfDesirable(result);
+            var allActionSets = InlineActionSetsIfDesirable(result, currentActionCount);
             var orderedActionSets = OrderActionSets(allActionSets, selectionOpt);
             var filteredSets = FilterActionSetsByTitle(orderedActionSets);
 
@@ -592,17 +593,15 @@ private static UnifiedSuggestedActionSet WithPriority(
             => new(set.CategoryName, set.Actions, set.Title, priority, set.ApplicableToSpan);
 
         private static ImmutableArray<UnifiedSuggestedActionSet> InlineActionSetsIfDesirable(
-            ImmutableArray<UnifiedSuggestedActionSet> allActionSets)
+            ImmutableArray<UnifiedSuggestedActionSet> allActionSets,
+            int currentActionCount)
         {
             // If we only have a single set of items, and that set only has three max suggestion
             // offered. Then we can consider inlining any nested actions into the top level list.
             // (but we only do this if the parent of the nested actions isn't invokable itself).
-            if (allActionSets.Sum(a => a.Actions.Count()) > 3)
-            {
-                return allActionSets;
-            }
-
-            return allActionSets.SelectAsArray(InlineActions);
+            return currentActionCount + allActionSets.Sum(a => a.Actions.Count()) > 3
+                ? allActionSets
+                : allActionSets.SelectAsArray(InlineActions);
         }
 
         private static UnifiedSuggestedActionSet InlineActions(UnifiedSuggestedActionSet actionSet)
diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpCodeActions.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpCodeActions.cs
index e055f0f719b5e..e2707bba25d1f 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpCodeActions.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpCodeActions.cs
@@ -464,6 +464,7 @@ public class P2 { }");
             {
                 "using System.IO;",
                 "Rename 'P2' to 'Stream'",
+                "Generate type 'Foober'",
                 "System.IO.Stream",
                 "Generate class 'Stream' in new file",
                 "Generate class 'Stream'",

From 8726661a65c06ffe554cd45aed375d92b323247e Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Wed, 22 Sep 2021 21:12:28 -0700
Subject: [PATCH 054/444] rename

---
 .../UnifiedSuggestions/UnifiedSuggestedActionsSource.cs   | 8 ++++----
 .../IntegrationTests/CSharp/CSharpCodeActions.cs          | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs b/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs
index cd29f22ce0d69..64921721806f8 100644
--- a/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs
+++ b/src/Features/Core/Portable/UnifiedSuggestions/UnifiedSuggestedActionsSource.cs
@@ -593,15 +593,15 @@ private static UnifiedSuggestedActionSet WithPriority(
             => new(set.CategoryName, set.Actions, set.Title, priority, set.ApplicableToSpan);
 
         private static ImmutableArray<UnifiedSuggestedActionSet> InlineActionSetsIfDesirable(
-            ImmutableArray<UnifiedSuggestedActionSet> allActionSets,
+            ImmutableArray<UnifiedSuggestedActionSet> actionSets,
             int currentActionCount)
         {
             // If we only have a single set of items, and that set only has three max suggestion
             // offered. Then we can consider inlining any nested actions into the top level list.
             // (but we only do this if the parent of the nested actions isn't invokable itself).
-            return currentActionCount + allActionSets.Sum(a => a.Actions.Count()) > 3
-                ? allActionSets
-                : allActionSets.SelectAsArray(InlineActions);
+            return currentActionCount + actionSets.Sum(a => a.Actions.Count()) > 3
+                ? actionSets
+                : actionSets.SelectAsArray(InlineActions);
         }
 
         private static UnifiedSuggestedActionSet InlineActions(UnifiedSuggestedActionSet actionSet)
diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpCodeActions.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpCodeActions.cs
index e2707bba25d1f..0442a82d82fe3 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpCodeActions.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpCodeActions.cs
@@ -464,7 +464,6 @@ public class P2 { }");
             {
                 "using System.IO;",
                 "Rename 'P2' to 'Stream'",
-                "Generate type 'Foober'",
                 "System.IO.Stream",
                 "Generate class 'Stream' in new file",
                 "Generate class 'Stream'",
@@ -513,6 +512,7 @@ static void Main(string[] args)
             {
                 "Rename 'P2' to 'Foober'",
                 "Goober - using N;",
+                "Generate type 'Foober'",
                 "Generate class 'Foober' in new file",
                 "Generate class 'Foober'",
                 "Generate nested class 'Foober'",

From ee6ac3d004ca471c5145903a231e080af5b5cbf9 Mon Sep 17 00:00:00 2001
From: Jonathon Marolf <jmarolf@microsoft.com>
Date: Mon, 27 Sep 2021 18:36:28 -0700
Subject: [PATCH 055/444] add PreferExtendedPropertyPattern to ECUI

---
 src/VisualStudio/CSharp/Impl/CSharpVSResources.resx          | 3 +++
 .../CodeStyle/CSharpCodeStyleSettingsProvider.cs             | 1 +
 src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.cs.xlf    | 5 +++++
 src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.de.xlf    | 5 +++++
 src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.es.xlf    | 5 +++++
 src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.fr.xlf    | 5 +++++
 src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.it.xlf    | 5 +++++
 src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ja.xlf    | 5 +++++
 src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ko.xlf    | 5 +++++
 src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pl.xlf    | 5 +++++
 src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pt-BR.xlf | 5 +++++
 src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ru.xlf    | 5 +++++
 src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.tr.xlf    | 5 +++++
 .../CSharp/Impl/xlf/CSharpVSResources.zh-Hans.xlf            | 5 +++++
 .../CSharp/Impl/xlf/CSharpVSResources.zh-Hant.xlf            | 5 +++++
 15 files changed, 69 insertions(+)

diff --git a/src/VisualStudio/CSharp/Impl/CSharpVSResources.resx b/src/VisualStudio/CSharp/Impl/CSharpVSResources.resx
index ac658678d6ddd..258958fa8a8b1 100644
--- a/src/VisualStudio/CSharp/Impl/CSharpVSResources.resx
+++ b/src/VisualStudio/CSharp/Impl/CSharpVSResources.resx
@@ -649,4 +649,7 @@
   <data name="File_scoped" xml:space="preserve">
     <value>File scoped</value>
   </data>
+  <data name="Prefer_extended_property_pattern" xml:space="preserve">
+    <value>Prefer extended property pattern</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/VisualStudio/CSharp/Impl/EditorConfigSettings/DataProvider/CodeStyle/CSharpCodeStyleSettingsProvider.cs b/src/VisualStudio/CSharp/Impl/EditorConfigSettings/DataProvider/CodeStyle/CSharpCodeStyleSettingsProvider.cs
index 62c98493a5839..5003c4942abd8 100644
--- a/src/VisualStudio/CSharp/Impl/EditorConfigSettings/DataProvider/CodeStyle/CSharpCodeStyleSettingsProvider.cs
+++ b/src/VisualStudio/CSharp/Impl/EditorConfigSettings/DataProvider/CodeStyle/CSharpCodeStyleSettingsProvider.cs
@@ -150,6 +150,7 @@ private IEnumerable<CodeStyleSetting> GetPatternMatchingCodeStyleOptions(Analyze
             yield return CodeStyleSetting.Create(CSharpCodeStyleOptions.PreferPatternMatchingOverIsWithCastCheck, description: CSharpVSResources.Prefer_pattern_matching_over_is_with_cast_check, editorConfigOptions, visualStudioOptions, updaterService, FileName);
             yield return CodeStyleSetting.Create(CSharpCodeStyleOptions.PreferPatternMatchingOverAsWithNullCheck, description: CSharpVSResources.Prefer_pattern_matching_over_as_with_null_check, editorConfigOptions, visualStudioOptions, updaterService, FileName);
             yield return CodeStyleSetting.Create(CSharpCodeStyleOptions.PreferNotPattern, description: CSharpVSResources.Prefer_pattern_matching_over_mixed_type_check, editorConfigOptions, visualStudioOptions, updaterService, FileName);
+            yield return CodeStyleSetting.Create(CSharpCodeStyleOptions.PreferExtendedPropertyPattern, description: CSharpVSResources.Prefer_extended_property_pattern, editorConfigOptions, visualStudioOptions, updaterService, FileName);
         }
 
         private IEnumerable<CodeStyleSetting> GetVariableCodeStyleOptions(AnalyzerConfigOptions editorConfigOptions, OptionSet visualStudioOptions, OptionUpdater updaterService)
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.cs.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.cs.xlf
index 7a45c3942a644..bcb0b9dda1e3a 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.cs.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.cs.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Pro objekty, kolekce, pole a inicializátory with umístit levou složenou závorku na nový řádek</target>
         <note>{Locked="with"}</note>
       </trans-unit>
+      <trans-unit id="Prefer_extended_property_pattern">
+        <source>Prefer extended property pattern</source>
+        <target state="new">Prefer extended property pattern</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
         <source>Prefer implicit object creation when type is apparent</source>
         <target state="translated">Upřednostňovat implicitní vytvoření objektu, pokud je typ zřejmý</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.de.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.de.xlf
index 47c48d780eb5b..c8727c855de95 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.de.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.de.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Öffnende geschweifte Klammer für Objekt-, Sammlungs-, Array- und with-Initialisierer in neue Zeile einfügen</target>
         <note>{Locked="with"}</note>
       </trans-unit>
+      <trans-unit id="Prefer_extended_property_pattern">
+        <source>Prefer extended property pattern</source>
+        <target state="new">Prefer extended property pattern</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
         <source>Prefer implicit object creation when type is apparent</source>
         <target state="translated">Implizite Objekterstellung bevorzugen, wenn der Typ offensichtlich ist</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.es.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.es.xlf
index c21877e8022ab..9f520f7aa0694 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.es.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.es.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Colocar llave de apertura en la nueva línea para los inicializadores de objeto, colección, matriz y with</target>
         <note>{Locked="with"}</note>
       </trans-unit>
+      <trans-unit id="Prefer_extended_property_pattern">
+        <source>Prefer extended property pattern</source>
+        <target state="new">Prefer extended property pattern</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
         <source>Prefer implicit object creation when type is apparent</source>
         <target state="translated">Preferir la creación implícita de objetos cuando el tipo sea aparente</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.fr.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.fr.xlf
index 4165017841717..4b3d4bbe92c02 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.fr.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.fr.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Placer une accolade ouvrante sur une nouvelle ligne pour les initialiseurs d'objets, de collections, de tableaux et with</target>
         <note>{Locked="with"}</note>
       </trans-unit>
+      <trans-unit id="Prefer_extended_property_pattern">
+        <source>Prefer extended property pattern</source>
+        <target state="new">Prefer extended property pattern</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
         <source>Prefer implicit object creation when type is apparent</source>
         <target state="translated">Préférer la création d'objets implicites quand le type est apparent</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.it.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.it.xlf
index 73ef541343de6..436467d250a55 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.it.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.it.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Inserisci parentesi graffa di apertura in una nuova riga per oggetto, raccolta, matrice e inizializzatori with</target>
         <note>{Locked="with"}</note>
       </trans-unit>
+      <trans-unit id="Prefer_extended_property_pattern">
+        <source>Prefer extended property pattern</source>
+        <target state="new">Prefer extended property pattern</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
         <source>Prefer implicit object creation when type is apparent</source>
         <target state="translated">Preferisci la creazione implicita di oggetti quando il tipo è apparente</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ja.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ja.xlf
index a561631cdb436..74ded6521f820 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ja.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ja.xlf
@@ -122,6 +122,11 @@
         <target state="translated">新しい行にオブジェクト、コレクション、配列、with 初期化子用の始めかっこを配置する</target>
         <note>{Locked="with"}</note>
       </trans-unit>
+      <trans-unit id="Prefer_extended_property_pattern">
+        <source>Prefer extended property pattern</source>
+        <target state="new">Prefer extended property pattern</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
         <source>Prefer implicit object creation when type is apparent</source>
         <target state="translated">型が明白な場合に暗黙的なオブジェクトの作成を優先する</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ko.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ko.xlf
index d687361a31db9..ae5e528b54aef 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ko.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ko.xlf
@@ -122,6 +122,11 @@
         <target state="translated">개체, 컬렉션, 배열 및 with 이니셜라이저의 여는 중괄호를 새 줄에 배치</target>
         <note>{Locked="with"}</note>
       </trans-unit>
+      <trans-unit id="Prefer_extended_property_pattern">
+        <source>Prefer extended property pattern</source>
+        <target state="new">Prefer extended property pattern</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
         <source>Prefer implicit object creation when type is apparent</source>
         <target state="translated">형식이 명백한 경우 암시적 개체 만들기 선호</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pl.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pl.xlf
index f251b1862090e..230dbc961c0fd 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pl.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pl.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Umieść otwierający nawias klamrowy w nowym wierszu dla inicjatorów obiektów, kolekcji, tablic i with</target>
         <note>{Locked="with"}</note>
       </trans-unit>
+      <trans-unit id="Prefer_extended_property_pattern">
+        <source>Prefer extended property pattern</source>
+        <target state="new">Prefer extended property pattern</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
         <source>Prefer implicit object creation when type is apparent</source>
         <target state="translated">Preferuj niejawne tworzenie obiektu, gdy typ jest oczywisty</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pt-BR.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pt-BR.xlf
index ae4bcd22d4a22..c5ae128b775b0 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pt-BR.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pt-BR.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Colocar uma chave de abertura em uma nova linha para inicializadores de objeto, coleção, matriz e with</target>
         <note>{Locked="with"}</note>
       </trans-unit>
+      <trans-unit id="Prefer_extended_property_pattern">
+        <source>Prefer extended property pattern</source>
+        <target state="new">Prefer extended property pattern</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
         <source>Prefer implicit object creation when type is apparent</source>
         <target state="translated">Preferir a criação de objeto implícito quando o tipo for aparente</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ru.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ru.xlf
index 6c5d5cccc5314..c020550f114e7 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ru.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ru.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Помещать открывающую фигурную скобку на новой строке для объекта, коллекции, массива и инициализаторов with</target>
         <note>{Locked="with"}</note>
       </trans-unit>
+      <trans-unit id="Prefer_extended_property_pattern">
+        <source>Prefer extended property pattern</source>
+        <target state="new">Prefer extended property pattern</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
         <source>Prefer implicit object creation when type is apparent</source>
         <target state="translated">Предпочитать неявное создание объекта, когда тип очевиден.</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.tr.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.tr.xlf
index 28494b15495ca..d95ae7aa6044c 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.tr.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.tr.xlf
@@ -122,6 +122,11 @@
         <target state="translated">Nesne, koleksiyon, dizi ve with başlatıcıları için açma küme ayracını yeni satıra yerleştir</target>
         <note>{Locked="with"}</note>
       </trans-unit>
+      <trans-unit id="Prefer_extended_property_pattern">
+        <source>Prefer extended property pattern</source>
+        <target state="new">Prefer extended property pattern</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
         <source>Prefer implicit object creation when type is apparent</source>
         <target state="translated">Tür görünür olduğunda örtük nesne oluşturmayı tercih et</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hans.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hans.xlf
index b3a1061b2647c..36757db206d37 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hans.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hans.xlf
@@ -122,6 +122,11 @@
         <target state="translated">对于对象、集合、数组和 with 初始值设定项，另起一行放置左花括号</target>
         <note>{Locked="with"}</note>
       </trans-unit>
+      <trans-unit id="Prefer_extended_property_pattern">
+        <source>Prefer extended property pattern</source>
+        <target state="new">Prefer extended property pattern</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
         <source>Prefer implicit object creation when type is apparent</source>
         <target state="translated">类型明显时首选隐式对象创建</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hant.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hant.xlf
index 9e3a5cd033865..d020b3844fde6 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hant.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hant.xlf
@@ -122,6 +122,11 @@
         <target state="translated">在物件、集合、陣列以及 with 初始設定式的新行上放上左大括弧</target>
         <note>{Locked="with"}</note>
       </trans-unit>
+      <trans-unit id="Prefer_extended_property_pattern">
+        <source>Prefer extended property pattern</source>
+        <target state="new">Prefer extended property pattern</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
         <source>Prefer implicit object creation when type is apparent</source>
         <target state="translated">當類型為實際型態時，建議建立隱含物件</target>

From 2e3946485dab86933f4f6c7cd0a30a95a92bdd9e Mon Sep 17 00:00:00 2001
From: Jonathon Marolf <jmarolf@microsoft.com>
Date: Mon, 27 Sep 2021 18:39:43 -0700
Subject: [PATCH 056/444] add PreferTupleSwap

---
 .../DataProvider/CodeStyle/CSharpCodeStyleSettingsProvider.cs    | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/VisualStudio/CSharp/Impl/EditorConfigSettings/DataProvider/CodeStyle/CSharpCodeStyleSettingsProvider.cs b/src/VisualStudio/CSharp/Impl/EditorConfigSettings/DataProvider/CodeStyle/CSharpCodeStyleSettingsProvider.cs
index 5003c4942abd8..1e726b9de6f24 100644
--- a/src/VisualStudio/CSharp/Impl/EditorConfigSettings/DataProvider/CodeStyle/CSharpCodeStyleSettingsProvider.cs
+++ b/src/VisualStudio/CSharp/Impl/EditorConfigSettings/DataProvider/CodeStyle/CSharpCodeStyleSettingsProvider.cs
@@ -142,6 +142,7 @@ private IEnumerable<CodeStyleSetting> GetExpressionCodeStyleOptions(AnalyzerConf
             yield return CodeStyleSetting.Create(CSharpCodeStyleOptions.PreferIndexOperator, description: ServicesVSResources.Prefer_index_operator, editorConfigOptions, visualStudioOptions, updaterService, FileName);
             yield return CodeStyleSetting.Create(CSharpCodeStyleOptions.PreferRangeOperator, description: ServicesVSResources.Prefer_range_operator, editorConfigOptions, visualStudioOptions, updaterService, FileName);
             yield return CodeStyleSetting.Create(CSharpCodeStyleOptions.ImplicitObjectCreationWhenTypeIsApparent, description: CSharpVSResources.Prefer_implicit_object_creation_when_type_is_apparent, editorConfigOptions, visualStudioOptions, updaterService, FileName);
+            yield return CodeStyleSetting.Create(CSharpCodeStyleOptions.PreferTupleSwap, description: ServicesVSResources.Prefer_tuple_swap, editorConfigOptions, visualStudioOptions, updaterService, FileName);
         }
 
         private IEnumerable<CodeStyleSetting> GetPatternMatchingCodeStyleOptions(AnalyzerConfigOptions editorConfigOptions, OptionSet visualStudioOptions, OptionUpdater updaterService)

From 8e1a51d02d1eaf3018a0f46bd49f453a34d2a2d5 Mon Sep 17 00:00:00 2001
From: Jon Fortescue <jofortes@microsoft.com>
Date: Fri, 29 Oct 2021 16:27:56 -0700
Subject: [PATCH 057/444] Switch to 1ES servicing pools on
 release/dev16.11-vs-deps

---
 azure-pipelines-integration-lsp.yml           |  4 ++--
 azure-pipelines-integration.yml               |  4 ++--
 azure-pipelines-official.yml                  |  4 ++--
 azure-pipelines-richnav.yml                   |  4 ++--
 azure-pipelines.yml                           | 22 +++++++++----------
 eng/pipelines/build-unix-job.yml              |  4 ++--
 eng/pipelines/build-windows-job.yml           |  4 ++--
 .../test-unix-job-single-machine.yml          |  4 ++--
 .../test-windows-job-single-machine.yml       |  6 ++---
 9 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/azure-pipelines-integration-lsp.yml b/azure-pipelines-integration-lsp.yml
index d436a7353ad62..05d4db8879b5f 100644
--- a/azure-pipelines-integration-lsp.yml
+++ b/azure-pipelines-integration-lsp.yml
@@ -19,8 +19,8 @@ pr:
 jobs:
 - job: VS_Integration_LSP
   pool:
-    name: NetCorePublic-Pool
-    queue: $(queueName)
+    name: NetCore1ESPool-Svc-Public
+    demands: ImageOverride -equals Build.Windows.Amd64.VS2022.Pre.Open
   timeoutInMinutes: 135
 
   steps:
diff --git a/azure-pipelines-integration.yml b/azure-pipelines-integration.yml
index 0cab841f373f3..f13f564123161 100644
--- a/azure-pipelines-integration.yml
+++ b/azure-pipelines-integration.yml
@@ -17,8 +17,8 @@ pr:
 jobs:
 - job: VS_Integration
   pool:
-    name: NetCorePublic-Pool
-    queue: BuildPool.Windows.VS2019.Pre.Scouting.Open
+    name: NetCore1ESPool-Svc-Public
+    demands: ImageOverride -equals Build.Windows.VS2019.Pre.Scouting.Open
   strategy:
     maxParallel: 4
     matrix:
diff --git a/azure-pipelines-official.yml b/azure-pipelines-official.yml
index c231b7b60e394..ff322d94d9cd6 100644
--- a/azure-pipelines-official.yml
+++ b/azure-pipelines-official.yml
@@ -71,8 +71,8 @@ stages:
     displayName: Official Build
     timeoutInMinutes: 360
     pool:
-      name: NetCoreInternal-Pool
-      queue: BuildPool.Server.Amd64.VS2017
+      name: NetCore1ESPool-Svc-Internal
+      demands: ImageOverride -equals Build.Server.Amd64.VS2017
 
     steps:
     - powershell: Write-Host "##vso[task.setvariable variable=SourceBranchName]$('$(Build.SourceBranch)'.Substring('refs/heads/'.Length))"
diff --git a/azure-pipelines-richnav.yml b/azure-pipelines-richnav.yml
index 6652eb3757fae..cbc9cedd90d45 100644
--- a/azure-pipelines-richnav.yml
+++ b/azure-pipelines-richnav.yml
@@ -5,8 +5,8 @@ pr: none
 jobs:
 - job: RichCodeNav_Indexing
   pool:
-    name: NetCorePublic-Pool
-    queue: BuildPool.Windows.10.Amd64.Open
+    name: NetCore1ESPool-Svc-Public
+    demands: ImageOverride -equals Build.Windows.10.Amd64.Open
   variables:
     EnableRichCodeNavigation: true
   timeoutInMinutes: 200
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index 4aff1d181fdf4..2bacd7dbad12c 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -21,14 +21,14 @@ jobs:
     jobName: Build_Windows_Debug
     testArtifactName: Transport_Artifacts_Windows_Debug
     configuration: Debug
-    queueName: BuildPool.Windows.10.Amd64.Open
+    queueName: Build.Windows.10.Amd64.Open
 
 - template: eng/pipelines/build-windows-job.yml
   parameters:
     jobName: Build_Windows_Release
     testArtifactName: Transport_Artifacts_Windows_Release
     configuration: Release
-    queueName: BuildPool.Windows.10.Amd64.Open
+    queueName: Build.Windows.10.Amd64.Open
     buildArguments: "/p:Features=run-nullable-analysis=never"
 
 - template: eng/pipelines/test-windows-job.yml
@@ -137,7 +137,7 @@ jobs:
     testArtifactName: Transport_Artifacts_Unix_Debug
     configuration: Debug
     testArguments: --testCoreClr
-    queueName: 'BuildPool.Ubuntu.1804.amd64.Open'
+    queueName: 'Build.Ubuntu.1804.amd64.Open'
 
 - template: eng/pipelines/test-unix-job.yml
   parameters:
@@ -152,8 +152,8 @@ jobs:
 
 - job: Correctness_Determinism
   pool:
-    name: NetCorePublic-Pool
-    queue: BuildPool.Windows.10.Amd64.VS2017.Open
+    name: NetCore1ESPool-Svc-Public
+    demands: ImageOverride -equals Build.Windows.10.Amd64.VS2017.Open
   timeoutInMinutes: 90
   steps:
     - template: eng/pipelines/checkout-windows-task.yml
@@ -168,8 +168,8 @@ jobs:
 
 - job: Correctness_Build
   pool:
-    name: NetCorePublic-Pool
-    queue: BuildPool.Windows.10.Amd64.VS2017.Open
+    name: NetCore1ESPool-Svc-Public
+    demands: ImageOverride -equals Build.Windows.10.Amd64.VS2017.Open
   timeoutInMinutes: 90
   steps:
     - template: eng/pipelines/checkout-windows-task.yml
@@ -200,8 +200,8 @@ jobs:
 
 - job: Correctness_SourceBuild
   pool:
-   name: NetCorePublic-Pool
-   queue: BuildPool.Ubuntu.1804.amd64.Open
+   name: NetCore1ESPool-Svc-Public
+   demands: ImageOverride -equals Build.Ubuntu.1804.amd64.Open
   timeoutInMinutes: 90
   steps:
     - template: eng/pipelines/checkout-unix-task.yml
@@ -224,8 +224,8 @@ jobs:
 
 - job: Correctness_Rebuild
   pool:
-    name: NetCorePublic-Pool
-    queue: BuildPool.Windows.10.Amd64.Open
+    name: NetCore1ESPool-Svc-Public
+    demands: ImageOverride -equals Build.Windows.10.Amd64.Open
   timeoutInMinutes: 90
   steps:
     - template: eng/pipelines/checkout-windows-task.yml
diff --git a/eng/pipelines/build-unix-job.yml b/eng/pipelines/build-unix-job.yml
index a78aa0d14874a..b2c892e2bdad7 100644
--- a/eng/pipelines/build-unix-job.yml
+++ b/eng/pipelines/build-unix-job.yml
@@ -20,8 +20,8 @@ jobs:
 - job: ${{ parameters.jobName }}
   pool:
     ${{ if ne(parameters.queueName, '') }}:
-      name: NetCorePublic-Pool
-      queue: ${{ parameters.queueName }}
+      name: NetCore1ESPool-Svc-Public
+      demands ImageOverride -equals ${{ parameters.queueName }}
 
     ${{ if ne(parameters.vmImageName, '') }}:
       vmImage: ${{ parameters.vmImageName }}
diff --git a/eng/pipelines/build-windows-job.yml b/eng/pipelines/build-windows-job.yml
index f23bfa359dcc8..36238eddba0d4 100644
--- a/eng/pipelines/build-windows-job.yml
+++ b/eng/pipelines/build-windows-job.yml
@@ -23,8 +23,8 @@ jobs:
 - job: ${{ parameters.jobName }}
   pool:
     ${{ if ne(parameters.queueName, '') }}:
-      name: NetCorePublic-Pool
-      queue: ${{ parameters.queueName }}
+      name: NetCore1ESPool-Svc-Public
+      demands ImageOverride -equals ${{ parameters.queueName }}
 
     ${{ if ne(parameters.vmImageName, '') }}:
       vmImage: ${{ parameters.vmImageName }}
diff --git a/eng/pipelines/test-unix-job-single-machine.yml b/eng/pipelines/test-unix-job-single-machine.yml
index 703d92c13c492..f0831e3c89258 100644
--- a/eng/pipelines/test-unix-job-single-machine.yml
+++ b/eng/pipelines/test-unix-job-single-machine.yml
@@ -30,8 +30,8 @@ jobs:
   dependsOn: ${{ parameters.buildJobName }}
   pool:
     ${{ if ne(parameters.queueName, '') }}:
-      name: NetCorePublic-Pool
-      queue: ${{ parameters.queueName }}
+      name: NetCore1ESPool-Svc-Public
+      demands ImageOverride -equals ${{ parameters.queueName }}
 
     ${{ if ne(parameters.vmImageName, '') }}:
       vmImage: ${{ parameters.vmImageName }}
diff --git a/eng/pipelines/test-windows-job-single-machine.yml b/eng/pipelines/test-windows-job-single-machine.yml
index 250db3a9c4424..4676dda470013 100644
--- a/eng/pipelines/test-windows-job-single-machine.yml
+++ b/eng/pipelines/test-windows-job-single-machine.yml
@@ -20,14 +20,14 @@ parameters:
   default: ''
 - name: queueName
   type: string
-  default: 'BuildPool.Windows.10.Amd64.Open'
+  default: 'Build.Windows.10.Amd64.Open'
 
 jobs:
 - job: ${{ parameters.jobName }}
   dependsOn: ${{ parameters.buildJobName }}
   pool:
-    name: NetCorePublic-Pool
-    queue: ${{ parameters.queueName }}
+    name: NetCore1ESPool-Svc-Public
+    demands ImageOverride -equals ${{ parameters.queueName }}
   timeoutInMinutes: 120
   variables:
     DOTNET_ROLL_FORWARD: LatestMajor

From 984f7deaa23b01509a6acd526fd949c8a6e6dceb Mon Sep 17 00:00:00 2001
From: Jon Fortescue <jofortes@microsoft.com>
Date: Mon, 1 Nov 2021 09:24:09 -0700
Subject: [PATCH 058/444] Remove Scouting from image

---
 azure-pipelines-integration.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/azure-pipelines-integration.yml b/azure-pipelines-integration.yml
index f13f564123161..f66928ec8da6d 100644
--- a/azure-pipelines-integration.yml
+++ b/azure-pipelines-integration.yml
@@ -18,7 +18,7 @@ jobs:
 - job: VS_Integration
   pool:
     name: NetCore1ESPool-Svc-Public
-    demands: ImageOverride -equals Build.Windows.VS2019.Pre.Scouting.Open
+    demands: ImageOverride -equals Build.Windows.VS2019.Pre.Open
   strategy:
     maxParallel: 4
     matrix:

From f66867e87dd79cfbabd090d9040c1b592b5b139c Mon Sep 17 00:00:00 2001
From: Jon Fortescue <jofortes@microsoft.com>
Date: Mon, 1 Nov 2021 09:26:59 -0700
Subject: [PATCH 059/444] Add Amd64

---
 azure-pipelines-integration.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/azure-pipelines-integration.yml b/azure-pipelines-integration.yml
index f66928ec8da6d..9ca2bd351fa75 100644
--- a/azure-pipelines-integration.yml
+++ b/azure-pipelines-integration.yml
@@ -18,7 +18,7 @@ jobs:
 - job: VS_Integration
   pool:
     name: NetCore1ESPool-Svc-Public
-    demands: ImageOverride -equals Build.Windows.VS2019.Pre.Open
+    demands: ImageOverride -equals Build.Windows.Amd64.VS2019.Pre.Open
   strategy:
     maxParallel: 4
     matrix:

From c0d9dd3bc3e4662a4e41af9475bfe81b73b2e5e7 Mon Sep 17 00:00:00 2001
From: Jon Fortescue <jofortes@microsoft.com>
Date: Mon, 1 Nov 2021 09:28:44 -0700
Subject: [PATCH 060/444] Add 10

---
 azure-pipelines-integration.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/azure-pipelines-integration.yml b/azure-pipelines-integration.yml
index 9ca2bd351fa75..d19080a279992 100644
--- a/azure-pipelines-integration.yml
+++ b/azure-pipelines-integration.yml
@@ -18,7 +18,7 @@ jobs:
 - job: VS_Integration
   pool:
     name: NetCore1ESPool-Svc-Public
-    demands: ImageOverride -equals Build.Windows.Amd64.VS2019.Pre.Open
+    demands: ImageOverride -equals Build.Windows.10.Amd64.VS2019.Pre.Open
   strategy:
     maxParallel: 4
     matrix:

From ac537ad79cc574a8aadca85cdd6b218516ab6871 Mon Sep 17 00:00:00 2001
From: Jon Fortescue <jofortes@microsoft.com>
Date: Mon, 1 Nov 2021 12:04:48 -0700
Subject: [PATCH 061/444] No pre

---
 azure-pipelines-integration.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/azure-pipelines-integration.yml b/azure-pipelines-integration.yml
index d19080a279992..18641e6a0705f 100644
--- a/azure-pipelines-integration.yml
+++ b/azure-pipelines-integration.yml
@@ -18,7 +18,7 @@ jobs:
 - job: VS_Integration
   pool:
     name: NetCore1ESPool-Svc-Public
-    demands: ImageOverride -equals Build.Windows.10.Amd64.VS2019.Pre.Open
+    demands: ImageOverride -equals Build.Windows.10.Amd64.VS2019.Open
   strategy:
     maxParallel: 4
     matrix:

From 215453d3d4544062650613eb06790dd8f68f11d1 Mon Sep 17 00:00:00 2001
From: Jon Fortescue <jofortes@microsoft.com>
Date: Mon, 1 Nov 2021 13:10:21 -0700
Subject: [PATCH 062/444] Switch to 1ES servicing pools on
 release/dev16.7-vs-deps

---
 azure-pipelines-integration.yml |  4 ++--
 azure-pipelines-official.yml    |  4 ++--
 azure-pipelines-richnav.yml     |  4 ++--
 azure-pipelines.yml             | 28 ++++++++++++++--------------
 4 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/azure-pipelines-integration.yml b/azure-pipelines-integration.yml
index 0881cab68895e..c565982dc595d 100644
--- a/azure-pipelines-integration.yml
+++ b/azure-pipelines-integration.yml
@@ -17,8 +17,8 @@ pr:
 jobs:
 - job: VS_Integration
   pool:
-    name: NetCorePublic-Pool
-    queue: buildpool.windows.10.amd64.vs2019.open
+    name: NetCore1ESPool-Svc-Public
+    demands: ImageOverride -demands build.windows.10.amd64.vs2019.open
   strategy:
     maxParallel: 2
     matrix:
diff --git a/azure-pipelines-official.yml b/azure-pipelines-official.yml
index 3124b72c8b7cc..334ac70be1733 100644
--- a/azure-pipelines-official.yml
+++ b/azure-pipelines-official.yml
@@ -52,8 +52,8 @@ stages:
         - visualstudio
         - DotNetFramework
       ${{ if eq(variables['System.TeamProject'], 'internal') }}:
-        name: NetCoreInternal-Pool
-        queue: BuildPool.Windows.10.Amd64.VS2019.Pre
+        name: NetCore1ESPool-Svc-Internal
+        demands: ImageOverride -demands Build.Windows.10.Amd64.VS2019.Pre
 
     steps:        
     # Make sure our two pipelines generate builds with distinct build numbers to avoid confliction.
diff --git a/azure-pipelines-richnav.yml b/azure-pipelines-richnav.yml
index 1fddf03aa0c66..ed024cb3f487c 100644
--- a/azure-pipelines-richnav.yml
+++ b/azure-pipelines-richnav.yml
@@ -11,8 +11,8 @@ schedules:
 jobs:
 - job: RichCodeNav_Indexing
   pool:
-    name: NetCorePublic-Pool
-    queue: BuildPool.Windows.10.Amd64.Open
+    name: NetCore1ESPool-Svc-Public
+    demands: ImageOverride -demands Build.Windows.10.Amd64.Open
   variables:
     EnableRichCodeNavigation: true
   timeoutInMinutes: 200
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index e11c5c60e2c4d..6fe64ccec11e2 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -17,8 +17,8 @@ pr:
 jobs:
 - job: Windows_Desktop_Unit_Tests
   pool:
-    name: NetCorePublic-Pool
-    queue: BuildPool.Windows.10.Amd64.Open
+    name: NetCore1ESPool-Svc-Public
+    demands: ImageOverride -demands Build.Windows.10.Amd64.Open
   strategy:
     maxParallel: 4
     matrix:
@@ -60,8 +60,8 @@ jobs:
 
 - job: Windows_Desktop_Spanish_Unit_Tests
   pool:
-    name: NetCorePublic-Pool
-    queue: BuildPool.Windows.10.Amd64.ES.VS2017.Open
+    name: NetCore1ESPool-Svc-Public
+    demands: ImageOverride -demands Build.Windows.10.Amd64.ES.VS2017.Open
   timeoutInMinutes: 120
 
   steps:
@@ -87,8 +87,8 @@ jobs:
 
 - job: Windows_CoreClr_Unit_Tests
   pool:
-    name: NetCorePublic-Pool
-    queue: BuildPool.Windows.10.Amd64.VS2017.Open
+    name: NetCore1ESPool-Svc-Public
+    demands: ImageOverride -demands Build.Windows.10.Amd64.VS2017.Open
   strategy:
     maxParallel: 2
     matrix:
@@ -122,8 +122,8 @@ jobs:
            
 - job: Windows_Determinism_Test
   pool:
-    name: NetCorePublic-Pool
-    queue: BuildPool.Windows.10.Amd64.VS2017.Open
+    name: NetCore1ESPool-Svc-Public
+    demands: ImageOverride -demands Build.Windows.10.Amd64.VS2017.Open
   timeoutInMinutes: 90
   steps:
     - script: eng/test-determinism.cmd -configuration Debug
@@ -140,8 +140,8 @@ jobs:
 
 - job: Windows_Correctness_Test
   pool:
-    name: NetCorePublic-Pool
-    queue: BuildPool.Windows.10.Amd64.VS2017.Open
+    name: NetCore1ESPool-Svc-Public
+    demands: ImageOverride -demands Build.Windows.10.Amd64.VS2017.Open
   timeoutInMinutes: 90
   steps:
     - script: eng/test-build-correctness.cmd -configuration Release
@@ -174,8 +174,8 @@ jobs:
 
 - job: Linux_Test
   pool:
-   name: NetCorePublic-Pool
-   queue: BuildPool.Ubuntu.1604.amd64.Open
+   name: NetCore1ESPool-Svc-Public
+   demands: ImageOverride -demands Build.Ubuntu.1604.amd64.Open
   strategy:
     maxParallel: 2
     matrix:
@@ -212,8 +212,8 @@ jobs:
 
 - job: SourceBuild_Test
   pool:
-   name: NetCorePublic-Pool
-   queue: BuildPool.Ubuntu.1604.amd64.Open
+   name: NetCore1ESPool-Svc-Public
+   demands: ImageOverride -demands Build.Ubuntu.1604.amd64.Open
   timeoutInMinutes: 90
   steps:
     - script: ./eng/cibuild.sh --configuration Debug --prepareMachine --docker --sourceBuild

From 91672dbe24ec1a2ac6eea33d2297af086fa9a711 Mon Sep 17 00:00:00 2001
From: Jon Fortescue <jofortes@microsoft.com>
Date: Mon, 1 Nov 2021 13:18:39 -0700
Subject: [PATCH 063/444] Switch to 1ES servicing pools on
 release/dev16.9-vs-deps

---
 azure-pipelines-integration.yml                   |  4 ++--
 azure-pipelines-official.yml                      |  4 ++--
 azure-pipelines-richnav.yml                       |  4 ++--
 azure-pipelines.yml                               | 12 ++++++------
 eng/pipelines/build-unix-job.yml                  |  4 ++--
 eng/pipelines/build-windows-job.yml               |  4 ++--
 eng/pipelines/test-unix-job-single-machine.yml    |  4 ++--
 eng/pipelines/test-windows-job-single-machine.yml |  4 ++--
 8 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/azure-pipelines-integration.yml b/azure-pipelines-integration.yml
index 54cf4819baf2a..e714c3c656a00 100644
--- a/azure-pipelines-integration.yml
+++ b/azure-pipelines-integration.yml
@@ -17,8 +17,8 @@ pr:
 jobs:
 - job: VS_Integration
   pool:
-    name: NetCorePublic-Pool
-    queue: $(queueName)
+    name: NetCore1ESPool-Svc-Public
+    demands: ImageOverride -equals Build.Windows.10.Amd64.VS2019.Open
   strategy:
     maxParallel: 4
     matrix:
diff --git a/azure-pipelines-official.yml b/azure-pipelines-official.yml
index 93142f326c17e..aeb6f232c7f8a 100644
--- a/azure-pipelines-official.yml
+++ b/azure-pipelines-official.yml
@@ -64,8 +64,8 @@ stages:
         - visualstudio
         - DotNetFramework
       ${{ if eq(variables['System.TeamProject'], 'internal') }}:
-        name: NetCoreInternal-Pool
-        queue: BuildPool.Server.Amd64.VS2017
+        name: NetCore1ESPool-Svc-Internal
+        demands: ImageOverride -equals Build.Server.Amd64.VS2017
 
     steps:        
     # Make sure our two pipelines generate builds with distinct build numbers to avoid confliction.
diff --git a/azure-pipelines-richnav.yml b/azure-pipelines-richnav.yml
index f2f8f6ed712a6..f90e2a61fa2e8 100644
--- a/azure-pipelines-richnav.yml
+++ b/azure-pipelines-richnav.yml
@@ -5,8 +5,8 @@ pr: none
 jobs:
 - job: RichCodeNav_Indexing
   pool:
-    name: NetCorePublic-Pool
-    queue: BuildPool.Windows.10.Amd64.Open
+    name: NetCore1ESPool-Svc-Public
+    demands: ImageOverride -equals Build.Windows.10.Amd64.Open
   variables:
     EnableRichCodeNavigation: true
   timeoutInMinutes: 200
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index 2a6e36cdc8123..a69864b8d451b 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -142,8 +142,8 @@ jobs:
 
 - job: Correctness_Determinism
   pool:
-    name: NetCorePublic-Pool
-    queue: BuildPool.Windows.10.Amd64.VS2017.Open
+    name: NetCore1ESPool-Svc-Public
+    demands: ImageOverride -equals Build.Windows.10.Amd64.VS2017.Open
   timeoutInMinutes: 90
   steps:
     - template: eng/pipelines/checkout-windows-task.yml
@@ -158,8 +158,8 @@ jobs:
 
 - job: Correctness_Build
   pool:
-    name: NetCorePublic-Pool
-    queue: BuildPool.Windows.10.Amd64.VS2017.Open
+    name: NetCore1ESPool-Svc-Public
+    demands: ImageOverride -equals Build.Windows.10.Amd64.VS2017.Open
   timeoutInMinutes: 90
   steps:
     - template: eng/pipelines/checkout-windows-task.yml
@@ -190,8 +190,8 @@ jobs:
 
 - job: Correctness_SourceBuild
   pool:
-   name: NetCorePublic-Pool
-   queue: BuildPool.Ubuntu.1604.amd64.Open
+   name: NetCore1ESPool-Svc-Public
+   demands: ImageOverride -equals Build.Ubuntu.1604.amd64.Open
   timeoutInMinutes: 90
   steps:
     - template: eng/pipelines/checkout-unix-task.yml
diff --git a/eng/pipelines/build-unix-job.yml b/eng/pipelines/build-unix-job.yml
index a78aa0d14874a..a4f754c22c787 100644
--- a/eng/pipelines/build-unix-job.yml
+++ b/eng/pipelines/build-unix-job.yml
@@ -20,8 +20,8 @@ jobs:
 - job: ${{ parameters.jobName }}
   pool:
     ${{ if ne(parameters.queueName, '') }}:
-      name: NetCorePublic-Pool
-      queue: ${{ parameters.queueName }}
+      name: NetCore1ESPool-Svc-Public
+      demands: ImageOverride -demands ${{ parameters.queueName }}
 
     ${{ if ne(parameters.vmImageName, '') }}:
       vmImage: ${{ parameters.vmImageName }}
diff --git a/eng/pipelines/build-windows-job.yml b/eng/pipelines/build-windows-job.yml
index 5fef865412d59..acfa11406c477 100644
--- a/eng/pipelines/build-windows-job.yml
+++ b/eng/pipelines/build-windows-job.yml
@@ -20,8 +20,8 @@ jobs:
 - job: ${{ parameters.jobName }}
   pool:
     ${{ if ne(parameters.queueName, '') }}:
-      name: NetCorePublic-Pool
-      queue: ${{ parameters.queueName }}
+      name: NetCore1ESPool-Svc-Public
+      demands: ImageOverride -demands ${{ parameters.queueName }}
 
     ${{ if ne(parameters.vmImageName, '') }}:
       vmImage: ${{ parameters.vmImageName }}
diff --git a/eng/pipelines/test-unix-job-single-machine.yml b/eng/pipelines/test-unix-job-single-machine.yml
index 65f60b1fc5f1a..7b225d63dc75e 100644
--- a/eng/pipelines/test-unix-job-single-machine.yml
+++ b/eng/pipelines/test-unix-job-single-machine.yml
@@ -30,8 +30,8 @@ jobs:
   dependsOn: ${{ parameters.buildJobName }}
   pool:
     ${{ if ne(parameters.queueName, '') }}:
-      name: NetCorePublic-Pool
-      queue: ${{ parameters.queueName }}
+      name: NetCore1ESPool-Svc-Public
+      demands: ImageOverride -demands ${{ parameters.queueName }}
 
     ${{ if ne(parameters.vmImageName, '') }}:
       vmImage: ${{ parameters.vmImageName }}
diff --git a/eng/pipelines/test-windows-job-single-machine.yml b/eng/pipelines/test-windows-job-single-machine.yml
index 201f8d8be85ce..9c93de550eedb 100644
--- a/eng/pipelines/test-windows-job-single-machine.yml
+++ b/eng/pipelines/test-windows-job-single-machine.yml
@@ -26,8 +26,8 @@ jobs:
 - job: ${{ parameters.jobName }}
   dependsOn: ${{ parameters.buildJobName }}
   pool:
-    name: NetCorePublic-Pool
-    queue: ${{ parameters.queueName }}
+    name: NetCore1ESPool-Svc-Public
+    demands: ImageOverride -demands ${{ parameters.queueName }}
   timeoutInMinutes: 120
   steps:
     - checkout: none

From 56779deafbdceac9e64eaa4aca00fb295b3fdc05 Mon Sep 17 00:00:00 2001
From: Jon Fortescue <jofortes@microsoft.com>
Date: Mon, 1 Nov 2021 13:37:57 -0700
Subject: [PATCH 064/444] Move to pool def to stage

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

diff --git a/azure-pipelines-official.yml b/azure-pipelines-official.yml
index ff322d94d9cd6..9a2e689f5cd40 100644
--- a/azure-pipelines-official.yml
+++ b/azure-pipelines-official.yml
@@ -65,14 +65,14 @@ variables:
 stages:
 - stage: build
   displayName: Build and Test
+  pool:
+    name: NetCore1ESPool-Svc-Internal
+    demands: ImageOverride -equals Build.Server.Amd64.VS2017
 
   jobs:
   - job: OfficialBuild
     displayName: Official Build
     timeoutInMinutes: 360
-    pool:
-      name: NetCore1ESPool-Svc-Internal
-      demands: ImageOverride -equals Build.Server.Amd64.VS2017
 
     steps:
     - powershell: Write-Host "##vso[task.setvariable variable=SourceBranchName]$('$(Build.SourceBranch)'.Substring('refs/heads/'.Length))"

From 0a24f0bc527de2f5c8199a7f7948320e1fce9321 Mon Sep 17 00:00:00 2001
From: Jon Fortescue <jofortes@microsoft.com>
Date: Wed, 3 Nov 2021 11:34:45 -0700
Subject: [PATCH 065/444] learn to type

---
 azure-pipelines-integration.yml |  2 +-
 azure-pipelines-official.yml    |  2 +-
 azure-pipelines-richnav.yml     |  2 +-
 azure-pipelines.yml             | 14 +++++++-------
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/azure-pipelines-integration.yml b/azure-pipelines-integration.yml
index c565982dc595d..1b3f8f3ec33cc 100644
--- a/azure-pipelines-integration.yml
+++ b/azure-pipelines-integration.yml
@@ -18,7 +18,7 @@ jobs:
 - job: VS_Integration
   pool:
     name: NetCore1ESPool-Svc-Public
-    demands: ImageOverride -demands build.windows.10.amd64.vs2019.open
+    demands: ImageOverride -equals build.windows.10.amd64.vs2019.open
   strategy:
     maxParallel: 2
     matrix:
diff --git a/azure-pipelines-official.yml b/azure-pipelines-official.yml
index 334ac70be1733..60bc178419e66 100644
--- a/azure-pipelines-official.yml
+++ b/azure-pipelines-official.yml
@@ -53,7 +53,7 @@ stages:
         - DotNetFramework
       ${{ if eq(variables['System.TeamProject'], 'internal') }}:
         name: NetCore1ESPool-Svc-Internal
-        demands: ImageOverride -demands Build.Windows.10.Amd64.VS2019.Pre
+        demands: ImageOverride -equals Build.Windows.10.Amd64.VS2019.Pre
 
     steps:        
     # Make sure our two pipelines generate builds with distinct build numbers to avoid confliction.
diff --git a/azure-pipelines-richnav.yml b/azure-pipelines-richnav.yml
index ed024cb3f487c..f6d9052037005 100644
--- a/azure-pipelines-richnav.yml
+++ b/azure-pipelines-richnav.yml
@@ -12,7 +12,7 @@ jobs:
 - job: RichCodeNav_Indexing
   pool:
     name: NetCore1ESPool-Svc-Public
-    demands: ImageOverride -demands Build.Windows.10.Amd64.Open
+    demands: ImageOverride -equals Build.Windows.10.Amd64.Open
   variables:
     EnableRichCodeNavigation: true
   timeoutInMinutes: 200
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index 6fe64ccec11e2..b696a3cf6df73 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -18,7 +18,7 @@ jobs:
 - job: Windows_Desktop_Unit_Tests
   pool:
     name: NetCore1ESPool-Svc-Public
-    demands: ImageOverride -demands Build.Windows.10.Amd64.Open
+    demands: ImageOverride -equals Build.Windows.10.Amd64.Open
   strategy:
     maxParallel: 4
     matrix:
@@ -61,7 +61,7 @@ jobs:
 - job: Windows_Desktop_Spanish_Unit_Tests
   pool:
     name: NetCore1ESPool-Svc-Public
-    demands: ImageOverride -demands Build.Windows.10.Amd64.ES.VS2017.Open
+    demands: ImageOverride -equals Build.Windows.10.Amd64.ES.VS2017.Open
   timeoutInMinutes: 120
 
   steps:
@@ -88,7 +88,7 @@ jobs:
 - job: Windows_CoreClr_Unit_Tests
   pool:
     name: NetCore1ESPool-Svc-Public
-    demands: ImageOverride -demands Build.Windows.10.Amd64.VS2017.Open
+    demands: ImageOverride -equals Build.Windows.10.Amd64.VS2017.Open
   strategy:
     maxParallel: 2
     matrix:
@@ -123,7 +123,7 @@ jobs:
 - job: Windows_Determinism_Test
   pool:
     name: NetCore1ESPool-Svc-Public
-    demands: ImageOverride -demands Build.Windows.10.Amd64.VS2017.Open
+    demands: ImageOverride -equals Build.Windows.10.Amd64.VS2017.Open
   timeoutInMinutes: 90
   steps:
     - script: eng/test-determinism.cmd -configuration Debug
@@ -141,7 +141,7 @@ jobs:
 - job: Windows_Correctness_Test
   pool:
     name: NetCore1ESPool-Svc-Public
-    demands: ImageOverride -demands Build.Windows.10.Amd64.VS2017.Open
+    demands: ImageOverride -equals Build.Windows.10.Amd64.VS2017.Open
   timeoutInMinutes: 90
   steps:
     - script: eng/test-build-correctness.cmd -configuration Release
@@ -175,7 +175,7 @@ jobs:
 - job: Linux_Test
   pool:
    name: NetCore1ESPool-Svc-Public
-   demands: ImageOverride -demands Build.Ubuntu.1604.amd64.Open
+   demands: ImageOverride -equals Build.Ubuntu.1604.amd64.Open
   strategy:
     maxParallel: 2
     matrix:
@@ -213,7 +213,7 @@ jobs:
 - job: SourceBuild_Test
   pool:
    name: NetCore1ESPool-Svc-Public
-   demands: ImageOverride -demands Build.Ubuntu.1604.amd64.Open
+   demands: ImageOverride -equals Build.Ubuntu.1604.amd64.Open
   timeoutInMinutes: 90
   steps:
     - script: ./eng/cibuild.sh --configuration Debug --prepareMachine --docker --sourceBuild

From 75635082946b8aa24d18a7c55e38fe3ccfaefb14 Mon Sep 17 00:00:00 2001
From: Joey Robichaud <jorobich@microsoft.com>
Date: Wed, 3 Nov 2021 15:40:40 -0700
Subject: [PATCH 066/444] Revert official build to using VS2019

---
 azure-pipelines-official.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/azure-pipelines-official.yml b/azure-pipelines-official.yml
index b4a25c41026e9..6572395e03a4c 100644
--- a/azure-pipelines-official.yml
+++ b/azure-pipelines-official.yml
@@ -83,7 +83,7 @@ stages:
     timeoutInMinutes: 360
     pool:
       name: NetCore1ESPool-Svc-Internal
-      demands: ImageOverride -equals Build.Windows.Amd64.VS2022.Pre
+      demands: ImageOverride -equals Build.Server.Amd64.VS2019
 
     steps:
     - powershell: Write-Host "##vso[task.setvariable variable=SourceBranchName]$('$(Build.SourceBranch)'.Substring('refs/heads/'.Length))"

From d1d476f3d2d98f5d1314d4df3132e78f430627e1 Mon Sep 17 00:00:00 2001
From: Joey Robichaud <jorobich@microsoft.com>
Date: Fri, 5 Nov 2021 12:26:32 -0700
Subject: [PATCH 067/444] Revert to VS2019 for PR Validation

---
 azure-pipelines-pr-validation.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/azure-pipelines-pr-validation.yml b/azure-pipelines-pr-validation.yml
index e8a377024d3f0..259d77967a718 100644
--- a/azure-pipelines-pr-validation.yml
+++ b/azure-pipelines-pr-validation.yml
@@ -49,7 +49,7 @@ stages:
     timeoutInMinutes: 360
     # Conditionally set build pool so we can share this YAML when building with different pipeline
     pool:
-      name: VSEngSS-MicroBuild2022-1ES
+      name: VSEngSS-MicroBuild2019-1ES
       demands:
       - msbuild
       - visualstudio

From fcb94089f801e5dec5909f840aa7a0511feb97b7 Mon Sep 17 00:00:00 2001
From: Joey Robichaud <jorobich@microsoft.com>
Date: Fri, 5 Nov 2021 13:01:35 -0700
Subject: [PATCH 068/444] Install .NET SDK in PR Validation pipeline

---
 azure-pipelines-pr-validation.yml | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/azure-pipelines-pr-validation.yml b/azure-pipelines-pr-validation.yml
index 259d77967a718..720361ea86da7 100644
--- a/azure-pipelines-pr-validation.yml
+++ b/azure-pipelines-pr-validation.yml
@@ -89,6 +89,14 @@ stages:
       inputs:
         nuGetServiceConnections: azure-public/vs-impl, azure-public/vssdk
 
+    # 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

From 410fcc2d77b0cfa34f9ef0e259d44ad98730e861 Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Fri, 5 Nov 2021 16:50:43 -0700
Subject: [PATCH 069/444] Copy the handling of defaults source

---
 .../AsyncCompletion/ItemManager.cs            | 89 +++++++++++++++++++
 1 file changed, 89 insertions(+)

diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
index ddeb5475db2b0..af46d59aa3fce 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
@@ -36,6 +36,8 @@ internal class ItemManager : IAsyncCompletionItemManager
         private readonly RecentItemsManager _recentItemsManager;
         private readonly IGlobalOptionService _globalOptions;
 
+        private const string AggressiveDefaultsMatchingOptionName = "AggressiveDefaultsMatchingOption";
+
         /// <summary>
         /// For telemetry.
         /// </summary>
@@ -235,6 +237,8 @@ private static readonly ObjectPool<List<MatchResult<VSCompletionItem>>> s_listOf
                     ? GetUpdatedFilters(initialListOfItemsToBeIncluded, data.SelectedFilters)
                     : ImmutableArray<CompletionFilterWithState>.Empty;
 
+                var useAggressiveDefaultsMatching = session.TextView.Options.GetOptionValue<bool>(AggressiveDefaultsMatchingOptionName);
+
                 // If this was deletion, then we control the entire behavior of deletion ourselves.
                 if (initialRoslynTriggerKind == CompletionTriggerKind.Deletion)
                 {
@@ -759,5 +763,90 @@ private static bool IsPotentialFilterCharacter(char c)
                 || char.IsNumber(c)
                 || c == '_';
         }
+
+        private static (int index, bool forceHardSelection) GetDefaultsMatch(
+            string filterText,
+            ImmutableArray<(RoslynCompletionItem item, PatternMatch? patterMatch)> itemsWithMatch,
+            int selectedIndex,
+            ImmutableArray<string> defaults,
+            bool aggressive)
+        {
+            // We only preselect when we are very confident with the selection, so don't override it.
+            if (defaults.IsDefaultOrEmpty || itemsWithMatch[selectedIndex].item.Rules.MatchPriority >= MatchPriority.Preselect)
+                return (selectedIndex, false);
+
+            if (aggressive)
+            {
+                foreach (var defaultText in defaults)
+                {
+                    for (var itemIndex = 0; (itemIndex < itemsWithMatch.Length); ++itemIndex)
+                    {
+                        var (item, patternMatch) = itemsWithMatch[itemIndex];
+                        if (item.FilterText == defaultText)
+                        {
+                            if (patternMatch == null || patternMatch.Value.Kind <= PatternMatchKind.Prefix)
+                                return (itemIndex, true);
+
+                            break;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                int similarItemsStart;
+                int dissimilarItemIndex;
+
+                if (filterText.Length == 0)
+                {
+                    // If there is no applicableToSpan, then all items are equally similar.
+                    similarItemsStart = 0;
+                    dissimilarItemIndex = itemsWithMatch.Length;
+                }
+                else
+                {
+                    // Assume that the selectedIndex is in the middle of a range of -- as far as the pattern matcher is concerned --
+                    // equivalent items. Find the first & last items in the range and use that to limit the items searched for from
+                    // the defaults list.                    
+                    var (_, selectedItemMatch) = itemsWithMatch[selectedIndex];
+                    if (!selectedItemMatch.HasValue)
+                        return (selectedIndex, false);
+
+                    similarItemsStart = selectedIndex;
+                    while (--similarItemsStart >= 0)
+                    {
+                        var (_, itemMatch) = itemsWithMatch[similarItemsStart];
+                        if ((!itemMatch.HasValue) || itemMatch.Value.CompareTo(selectedItemMatch.Value) > 0)
+                            break;
+                    }
+
+                    similarItemsStart++;
+
+                    dissimilarItemIndex = selectedIndex;
+                    while (++dissimilarItemIndex < itemsWithMatch.Length)
+                    {
+                        var (_, itemMatch) = itemsWithMatch[dissimilarItemIndex];
+                        if ((!itemMatch.HasValue) || itemMatch.Value.CompareTo(selectedItemMatch.Value) > 0)
+                            break;
+                    }
+                }
+
+                if (dissimilarItemIndex > selectedIndex + 1)
+                {
+                    foreach (var defaultText in defaults)
+                    {
+                        for (var itemIndex = similarItemsStart; (itemIndex < dissimilarItemIndex); ++itemIndex)
+                        {
+                            if (itemsWithMatch[itemIndex].item.FilterText == defaultText)
+                            {
+                                return (itemIndex, false);
+                            }
+                        }
+                    }
+                }
+            }
+
+            return (selectedIndex, false);
+        }
     }
 }

From d19767675728dbf62ded21ce4f30aaa289011393 Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Fri, 5 Nov 2021 17:29:17 -0700
Subject: [PATCH 070/444] refactor completion list filtering

---
 .../AsyncCompletion/ItemManager.cs            | 79 ++++++++-----------
 1 file changed, 34 insertions(+), 45 deletions(-)

diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
index af46d59aa3fce..dcbe301cf8ad6 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
@@ -231,47 +231,46 @@ private static readonly ObjectPool<List<MatchResult<VSCompletionItem>>> s_listOf
                 // to `MatchResult` to achieve this.
                 initialListOfItemsToBeIncluded.Sort(MatchResult<VSCompletionItem>.SortingComparer);
 
-                var showCompletionItemFilters = _globalOptions.GetOption(CompletionViewOptions.ShowCompletionItemFilters, document?.Project.Language);
+                var filteringResult = initialRoslynTriggerKind == CompletionTriggerKind.Deletion
+                        ? HandleDeletionTrigger(reason, initialListOfItemsToBeIncluded, filterText, hasSuggestedItemOptions)
+                        : HandleNormalFiltering(GetFilterMethod(), filterText, filterReason, data.Trigger.Character, initialListOfItemsToBeIncluded, hasSuggestedItemOptions);
+
+                if (!filteringResult.HasValue)
+                    return null;
 
+                var (selectedItemIndex, selectionHint, uniqueItem) = filteringResult.Value;
+                var useAggressiveDefaultsMatching = session.TextView.Options.GetOptionValue<bool>(AggressiveDefaultsMatchingOptionName);
+                var showCompletionItemFilters = _globalOptions.GetOption(CompletionViewOptions.ShowCompletionItemFilters, document?.Project.Language);
                 var updatedFilters = showCompletionItemFilters
                     ? GetUpdatedFilters(initialListOfItemsToBeIncluded, data.SelectedFilters)
                     : ImmutableArray<CompletionFilterWithState>.Empty;
 
-                var useAggressiveDefaultsMatching = session.TextView.Options.GetOptionValue<bool>(AggressiveDefaultsMatchingOptionName);
-
-                // If this was deletion, then we control the entire behavior of deletion ourselves.
-                if (initialRoslynTriggerKind == CompletionTriggerKind.Deletion)
-                {
-                    return HandleDeletionTrigger(reason, initialListOfItemsToBeIncluded, filterText, updatedFilters, hasSuggestedItemOptions, highlightMatchingPortions, completionHelper);
-                }
+                return new FilteredCompletionModel(
+                    items: GetHighlightedList(initialListOfItemsToBeIncluded, filterText, highlightMatchingPortions, completionHelper),
+                    selectedItemIndex,
+                    updatedFilters,
+                    selectionHint,
+                    centerSelection: true,
+                    uniqueItem);
+            }
+            finally
+            {
+                // Don't call ClearAndFree, which resets the capacity to a default value.
+                initialListOfItemsToBeIncluded.Clear();
+                s_listOfMatchResultPool.Free(initialListOfItemsToBeIncluded);
+            }
 
-                Func<ImmutableArray<(RoslynCompletionItem, PatternMatch?)>, string, ImmutableArray<RoslynCompletionItem>> filterMethod;
+            Func<ImmutableArray<(RoslynCompletionItem, PatternMatch?)>, string, ImmutableArray<RoslynCompletionItem>> GetFilterMethod()
+            {
                 if (completionService == null)
                 {
-                    filterMethod = (itemsWithPatternMatches, text) => CompletionService.FilterItems(completionHelper, itemsWithPatternMatches, text);
+                    return (itemsWithPatternMatches, text) => CompletionService.FilterItems(completionHelper, itemsWithPatternMatches, text);
                 }
                 else
                 {
                     Contract.ThrowIfNull(document);
-                    filterMethod = (itemsWithPatternMatches, text) => completionService.FilterItems(document, itemsWithPatternMatches, text);
+                    return (itemsWithPatternMatches, text) => completionService.FilterItems(document, itemsWithPatternMatches, text);
                 }
-
-                return HandleNormalFiltering(
-                    filterMethod,
-                    filterText,
-                    updatedFilters,
-                    filterReason,
-                    data.Trigger.Character,
-                    initialListOfItemsToBeIncluded,
-                    hasSuggestedItemOptions,
-                    highlightMatchingPortions,
-                    completionHelper);
-            }
-            finally
-            {
-                // Don't call ClearAndFree, which resets the capacity to a default value.
-                initialListOfItemsToBeIncluded.Clear();
-                s_listOfMatchResultPool.Free(initialListOfItemsToBeIncluded);
             }
 
             static bool TryGetInitialTriggerLocation(AsyncCompletionSessionDataSnapshot data, out SnapshotPoint intialTriggerLocation)
@@ -326,16 +325,13 @@ private static bool IsAfterDot(ITextSnapshot snapshot, ITrackingSpan applicableT
             return position > 0 && snapshot[position - 1] == '.';
         }
 
-        private FilteredCompletionModel? HandleNormalFiltering(
+        private (int selectedItemIndex, UpdateSelectionHint selcetionHint, VSCompletionItem? uniqueItem)? HandleNormalFiltering(
             Func<ImmutableArray<(RoslynCompletionItem, PatternMatch?)>, string, ImmutableArray<RoslynCompletionItem>> filterMethod,
             string filterText,
-            ImmutableArray<CompletionFilterWithState> filters,
             CompletionFilterReason filterReason,
             char typeChar,
             List<MatchResult<VSCompletionItem>> itemsInList,
-            bool hasSuggestedItemOptions,
-            bool highlightMatchingPortions,
-            CompletionHelper completionHelper)
+            bool hasSuggestedItemOptions)
         {
             // Not deletion.  Defer to the language to decide which item it thinks best
             // matches the text typed so far.
@@ -413,19 +409,14 @@ private static bool IsAfterDot(ITextSnapshot snapshot, ITrackingSpan applicableT
 
             var updateSelectionHint = isHardSelection ? UpdateSelectionHint.Selected : UpdateSelectionHint.SoftSelected;
 
-            return new FilteredCompletionModel(
-                GetHighlightedList(itemsInList, filterText, highlightMatchingPortions, completionHelper), selectedItemIndex, filters,
-                updateSelectionHint, centerSelection: true, uniqueItem);
+            return (selectedItemIndex, updateSelectionHint, uniqueItem);
         }
 
-        private static FilteredCompletionModel? HandleDeletionTrigger(
+        private static (int selectedItemIndex, UpdateSelectionHint selcetionHint, VSCompletionItem? uniqueItem)? HandleDeletionTrigger(
             CompletionTriggerReason filterTriggerKind,
             List<MatchResult<VSCompletionItem>> matchResults,
             string filterText,
-            ImmutableArray<CompletionFilterWithState> filters,
-            bool hasSuggestedItemOptions,
-            bool highlightMatchingSpans,
-            CompletionHelper completionHelper)
+            bool hasSuggestedItemOptions)
         {
             var matchingItems = matchResults.Where(r => r.MatchedFilterText);
             if (filterTriggerKind == CompletionTriggerReason.Insertion &&
@@ -488,11 +479,9 @@ private static bool IsAfterDot(ITextSnapshot snapshot, ITrackingSpan applicableT
                 hardSelect = false;
             }
 
-            return new FilteredCompletionModel(
-                GetHighlightedList(matchResults, filterText, highlightMatchingSpans, completionHelper), index, filters,
+            return (index,
                 hardSelect ? UpdateSelectionHint.Selected : UpdateSelectionHint.SoftSelected,
-                centerSelection: true,
-                uniqueItem: moreThanOneMatchWithSamePriority ? null : bestMatchResult.GetValueOrDefault().EditorCompletionItem);
+                moreThanOneMatchWithSamePriority ? null : bestMatchResult.GetValueOrDefault().EditorCompletionItem);
         }
 
         private static ImmutableArray<CompletionItemWithHighlight> GetHighlightedList(

From ff7f2455013ee8a433e31eefe63804f9f1897c2e Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Mon, 8 Nov 2021 16:39:37 -0800
Subject: [PATCH 071/444] Move the handling of IAsyncCompletionDefaultsSource
 to Roslyn

See https://devdiv.visualstudio.com/DevDiv/_git/VS-Platform/pullrequest/353067
---
 .../AsyncCompletion/ItemManager.cs            |  33 +++--
 ...etionCommandHandlerTests_DefaultsSource.vb | 128 ++++++++++++++++++
 2 files changed, 147 insertions(+), 14 deletions(-)
 create mode 100644 src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_DefaultsSource.vb

diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
index dcbe301cf8ad6..81383e04a9d19 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
@@ -36,7 +36,7 @@ internal class ItemManager : IAsyncCompletionItemManager
         private readonly RecentItemsManager _recentItemsManager;
         private readonly IGlobalOptionService _globalOptions;
 
-        private const string AggressiveDefaultsMatchingOptionName = "AggressiveDefaultsMatchingOption";
+        public const string AggressiveDefaultsMatchingOptionName = "AggressiveDefaultsMatchingOption";
 
         /// <summary>
         /// For telemetry.
@@ -240,6 +240,11 @@ private static readonly ObjectPool<List<MatchResult<VSCompletionItem>>> s_listOf
 
                 var (selectedItemIndex, selectionHint, uniqueItem) = filteringResult.Value;
                 var useAggressiveDefaultsMatching = session.TextView.Options.GetOptionValue<bool>(AggressiveDefaultsMatchingOptionName);
+
+                (selectedItemIndex, var forchHardSelection) = GetDefaultsMatch(filterText, initialListOfItemsToBeIncluded, selectedItemIndex, data.Defaults, useAggressiveDefaultsMatching);
+                if (forchHardSelection)
+                    selectionHint = UpdateSelectionHint.Selected;
+
                 var showCompletionItemFilters = _globalOptions.GetOption(CompletionViewOptions.ShowCompletionItemFilters, document?.Project.Language);
                 var updatedFilters = showCompletionItemFilters
                     ? GetUpdatedFilters(initialListOfItemsToBeIncluded, data.SelectedFilters)
@@ -755,25 +760,25 @@ private static bool IsPotentialFilterCharacter(char c)
 
         private static (int index, bool forceHardSelection) GetDefaultsMatch(
             string filterText,
-            ImmutableArray<(RoslynCompletionItem item, PatternMatch? patterMatch)> itemsWithMatch,
+            List<MatchResult<VSCompletionItem>> itemsWithMatch,
             int selectedIndex,
             ImmutableArray<string> defaults,
             bool aggressive)
         {
             // We only preselect when we are very confident with the selection, so don't override it.
-            if (defaults.IsDefaultOrEmpty || itemsWithMatch[selectedIndex].item.Rules.MatchPriority >= MatchPriority.Preselect)
+            if (defaults.IsDefaultOrEmpty || itemsWithMatch[selectedIndex].RoslynCompletionItem.Rules.MatchPriority >= MatchPriority.Preselect)
                 return (selectedIndex, false);
 
             if (aggressive)
             {
                 foreach (var defaultText in defaults)
                 {
-                    for (var itemIndex = 0; (itemIndex < itemsWithMatch.Length); ++itemIndex)
+                    for (var itemIndex = 0; (itemIndex < itemsWithMatch.Count); ++itemIndex)
                     {
-                        var (item, patternMatch) = itemsWithMatch[itemIndex];
-                        if (item.FilterText == defaultText)
+                        var itemWithMatch = itemsWithMatch[itemIndex];
+                        if (itemWithMatch.RoslynCompletionItem.FilterText == defaultText)
                         {
-                            if (patternMatch == null || patternMatch.Value.Kind <= PatternMatchKind.Prefix)
+                            if (itemWithMatch.PatternMatch == null || itemWithMatch.PatternMatch.Value.Kind <= PatternMatchKind.Prefix)
                                 return (itemIndex, true);
 
                             break;
@@ -790,21 +795,21 @@ private static (int index, bool forceHardSelection) GetDefaultsMatch(
                 {
                     // If there is no applicableToSpan, then all items are equally similar.
                     similarItemsStart = 0;
-                    dissimilarItemIndex = itemsWithMatch.Length;
+                    dissimilarItemIndex = itemsWithMatch.Count;
                 }
                 else
                 {
                     // Assume that the selectedIndex is in the middle of a range of -- as far as the pattern matcher is concerned --
                     // equivalent items. Find the first & last items in the range and use that to limit the items searched for from
-                    // the defaults list.                    
-                    var (_, selectedItemMatch) = itemsWithMatch[selectedIndex];
+                    // the defaults list.          
+                    var selectedItemMatch = itemsWithMatch[selectedIndex].PatternMatch;
                     if (!selectedItemMatch.HasValue)
                         return (selectedIndex, false);
 
                     similarItemsStart = selectedIndex;
                     while (--similarItemsStart >= 0)
                     {
-                        var (_, itemMatch) = itemsWithMatch[similarItemsStart];
+                        var itemMatch = itemsWithMatch[similarItemsStart].PatternMatch;
                         if ((!itemMatch.HasValue) || itemMatch.Value.CompareTo(selectedItemMatch.Value) > 0)
                             break;
                     }
@@ -812,9 +817,9 @@ private static (int index, bool forceHardSelection) GetDefaultsMatch(
                     similarItemsStart++;
 
                     dissimilarItemIndex = selectedIndex;
-                    while (++dissimilarItemIndex < itemsWithMatch.Length)
+                    while (++dissimilarItemIndex < itemsWithMatch.Count)
                     {
-                        var (_, itemMatch) = itemsWithMatch[dissimilarItemIndex];
+                        var itemMatch = itemsWithMatch[dissimilarItemIndex].PatternMatch;
                         if ((!itemMatch.HasValue) || itemMatch.Value.CompareTo(selectedItemMatch.Value) > 0)
                             break;
                     }
@@ -826,7 +831,7 @@ private static (int index, bool forceHardSelection) GetDefaultsMatch(
                     {
                         for (var itemIndex = similarItemsStart; (itemIndex < dissimilarItemIndex); ++itemIndex)
                         {
-                            if (itemsWithMatch[itemIndex].item.FilterText == defaultText)
+                            if (itemsWithMatch[itemIndex].RoslynCompletionItem.FilterText == defaultText)
                             {
                                 return (itemIndex, false);
                             }
diff --git a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_DefaultsSource.vb b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_DefaultsSource.vb
new file mode 100644
index 0000000000000..ef7fad95cdd57
--- /dev/null
+++ b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_DefaultsSource.vb
@@ -0,0 +1,128 @@
+' 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.
+
+Imports System.Collections.Immutable
+Imports Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.AsyncCompletion
+Imports Microsoft.CodeAnalysis.Host.Mef
+Imports Microsoft.VisualStudio.Language.Intellisense.AsyncCompletion
+Imports Microsoft.VisualStudio.Text.Editor
+
+Namespace Microsoft.CodeAnalysis.Editor.UnitTests.IntelliSense
+    <[UseExportProvider]>
+    Public Class CSharpCompletionCommandHandlerTests_DefaultsSource
+
+        <WpfFact, CombinatorialData>
+        <Trait(Traits.Feature, Traits.Features.Completion)>
+        Public Async Function Test1() As Task
+            Using state = CreateTestState(
+                              <Document>
+using NS1;
+class C
+{
+    void Method()
+    {
+        $$
+    }
+}
+                              </Document>)
+
+                state.SendInvokeCompletionList()
+                Await state.AssertSelectedCompletionItem("MyAB", isHardSelected:=False) ' Not hard-selected since filter text is empty
+            End Using
+        End Function
+
+        <WpfFact, CombinatorialData>
+        <Trait(Traits.Feature, Traits.Features.Completion)>
+        Public Async Function Test2() As Task
+            Using state = CreateTestState(
+                              <Document>
+using NS1;
+class C
+{
+    void Method()
+    {
+        My$$
+    }
+}
+                              </Document>)
+                state.SendInvokeCompletionList()
+                Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
+                Await state.AssertSelectedCompletionItem("MyAB", isHardSelected:=True)
+            End Using
+        End Function
+
+        <WpfTheory, CombinatorialData>
+        <Trait(Traits.Feature, Traits.Features.Completion)>
+        Public Async Function Test3(isAggressive As Boolean) As Task
+            Using state = CreateTestState(
+                              <Document>
+using NS1;
+class C
+{
+    void Method()
+    {
+        MyA$$
+    }
+}
+                              </Document>)
+                If isAggressive Then
+                    state.TextView.Options.SetOptionValue(ItemManager.AggressiveDefaultsMatchingOptionName, True)
+                End If
+
+                state.SendInvokeCompletionList()
+
+                If isAggressive Then
+                    Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
+                    Await state.AssertSelectedCompletionItem("MyAB", isHardSelected:=True)
+                Else
+                    Await state.AssertCompletionItemsContain("MyAB", displayTextSuffix:="")
+                    Await state.AssertSelectedCompletionItem("MyA", isHardSelected:=True)
+                End If
+            End Using
+        End Function
+
+        Private Shared Function CreateTestState(documentElement As XElement) As TestState
+            Return TestStateFactory.CreateTestStateFromWorkspace(
+                <Workspace>
+                    <Project Language="C#" LanguageVersion="Preview" CommonReferences="true">
+                        <ProjectReference>RefProj</ProjectReference>
+                        <Document FilePath="C.cs">
+                            <%= documentElement.Value %>
+                        </Document>
+                    </Project>
+                    <Project Language="C#" AssemblyName="RefProj" CommonReferences="true">
+                        <Document><![CDATA[
+namespace NS1
+{
+    public class MyA
+    {
+    }
+    public class MyAB
+    {
+    }
+}
+                        ]]></Document>
+                    </Project>
+                </Workspace>,
+                extraExportedTypes:={GetType(MockDefaultSource)}.ToList())
+        End Function
+
+        <ComponentModel.Composition.Export(GetType(IAsyncCompletionDefaultsSource))>
+        <VisualStudio.Utilities.Name(NameOf(MockDefaultSource))>
+        <VisualStudio.Utilities.ContentType(ContentTypeNames.RoslynContentType)>
+        <TextViewRole(PredefinedTextViewRoles.Document)>
+        Private Class MockDefaultSource
+            Implements IAsyncCompletionDefaultsSource
+
+            <ComponentModel.Composition.ImportingConstructor>
+            <Obsolete(MefConstruction.ImportingConstructorMessage, True)>
+            Public Sub New()
+            End Sub
+
+            Public Function GetSessionDefaultsAsync(session As IAsyncCompletionSession) As Task(Of ImmutableArray(Of String)) Implements IAsyncCompletionDefaultsSource.GetSessionDefaultsAsync
+                Return Task.FromResult(ImmutableArray.Create("MyAB"))
+            End Function
+        End Class
+    End Class
+End Namespace

From 87d52c6c7bb0e72573da8cf824bad9e74c1b925a Mon Sep 17 00:00:00 2001
From: Jon Fortescue <jofortes@microsoft.com>
Date: Tue, 9 Nov 2021 10:27:34 -0800
Subject: [PATCH 072/444] a

---
 eng/pipelines/build-unix-job.yml                  | 2 +-
 eng/pipelines/build-windows-job.yml               | 2 +-
 eng/pipelines/test-unix-job-single-machine.yml    | 2 +-
 eng/pipelines/test-windows-job-single-machine.yml | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/eng/pipelines/build-unix-job.yml b/eng/pipelines/build-unix-job.yml
index b2c892e2bdad7..f60f07aab725b 100644
--- a/eng/pipelines/build-unix-job.yml
+++ b/eng/pipelines/build-unix-job.yml
@@ -21,7 +21,7 @@ jobs:
   pool:
     ${{ if ne(parameters.queueName, '') }}:
       name: NetCore1ESPool-Svc-Public
-      demands ImageOverride -equals ${{ parameters.queueName }}
+      demands: ImageOverride -equals ${{ parameters.queueName }}
 
     ${{ if ne(parameters.vmImageName, '') }}:
       vmImage: ${{ parameters.vmImageName }}
diff --git a/eng/pipelines/build-windows-job.yml b/eng/pipelines/build-windows-job.yml
index 36238eddba0d4..f9e0c7df9ed77 100644
--- a/eng/pipelines/build-windows-job.yml
+++ b/eng/pipelines/build-windows-job.yml
@@ -24,7 +24,7 @@ jobs:
   pool:
     ${{ if ne(parameters.queueName, '') }}:
       name: NetCore1ESPool-Svc-Public
-      demands ImageOverride -equals ${{ parameters.queueName }}
+      demands: ImageOverride -equals ${{ parameters.queueName }}
 
     ${{ if ne(parameters.vmImageName, '') }}:
       vmImage: ${{ parameters.vmImageName }}
diff --git a/eng/pipelines/test-unix-job-single-machine.yml b/eng/pipelines/test-unix-job-single-machine.yml
index f0831e3c89258..27ff0ff5f47a4 100644
--- a/eng/pipelines/test-unix-job-single-machine.yml
+++ b/eng/pipelines/test-unix-job-single-machine.yml
@@ -31,7 +31,7 @@ jobs:
   pool:
     ${{ if ne(parameters.queueName, '') }}:
       name: NetCore1ESPool-Svc-Public
-      demands ImageOverride -equals ${{ parameters.queueName }}
+      demands: ImageOverride -equals ${{ parameters.queueName }}
 
     ${{ if ne(parameters.vmImageName, '') }}:
       vmImage: ${{ parameters.vmImageName }}
diff --git a/eng/pipelines/test-windows-job-single-machine.yml b/eng/pipelines/test-windows-job-single-machine.yml
index 4676dda470013..d59938258e7b8 100644
--- a/eng/pipelines/test-windows-job-single-machine.yml
+++ b/eng/pipelines/test-windows-job-single-machine.yml
@@ -27,7 +27,7 @@ jobs:
   dependsOn: ${{ parameters.buildJobName }}
   pool:
     name: NetCore1ESPool-Svc-Public
-    demands ImageOverride -equals ${{ parameters.queueName }}
+    demands: ImageOverride -equals ${{ parameters.queueName }}
   timeoutInMinutes: 120
   variables:
     DOTNET_ROLL_FORWARD: LatestMajor

From 908637462654c32756f3544246265f31c13e6168 Mon Sep 17 00:00:00 2001
From: Jon Fortescue <jofortes@microsoft.com>
Date: Tue, 9 Nov 2021 10:32:06 -0800
Subject: [PATCH 073/444] =?UTF-8?q?=CE=B1?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 eng/pipelines/build-unix-job.yml                  | 2 +-
 eng/pipelines/build-windows-job.yml               | 2 +-
 eng/pipelines/test-unix-job-single-machine.yml    | 2 +-
 eng/pipelines/test-windows-job-single-machine.yml | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/eng/pipelines/build-unix-job.yml b/eng/pipelines/build-unix-job.yml
index a4f754c22c787..f60f07aab725b 100644
--- a/eng/pipelines/build-unix-job.yml
+++ b/eng/pipelines/build-unix-job.yml
@@ -21,7 +21,7 @@ jobs:
   pool:
     ${{ if ne(parameters.queueName, '') }}:
       name: NetCore1ESPool-Svc-Public
-      demands: ImageOverride -demands ${{ parameters.queueName }}
+      demands: ImageOverride -equals ${{ parameters.queueName }}
 
     ${{ if ne(parameters.vmImageName, '') }}:
       vmImage: ${{ parameters.vmImageName }}
diff --git a/eng/pipelines/build-windows-job.yml b/eng/pipelines/build-windows-job.yml
index acfa11406c477..7787dc990bc6b 100644
--- a/eng/pipelines/build-windows-job.yml
+++ b/eng/pipelines/build-windows-job.yml
@@ -21,7 +21,7 @@ jobs:
   pool:
     ${{ if ne(parameters.queueName, '') }}:
       name: NetCore1ESPool-Svc-Public
-      demands: ImageOverride -demands ${{ parameters.queueName }}
+      demands: ImageOverride -equals ${{ parameters.queueName }}
 
     ${{ if ne(parameters.vmImageName, '') }}:
       vmImage: ${{ parameters.vmImageName }}
diff --git a/eng/pipelines/test-unix-job-single-machine.yml b/eng/pipelines/test-unix-job-single-machine.yml
index 7b225d63dc75e..01f7fdbfe13d6 100644
--- a/eng/pipelines/test-unix-job-single-machine.yml
+++ b/eng/pipelines/test-unix-job-single-machine.yml
@@ -31,7 +31,7 @@ jobs:
   pool:
     ${{ if ne(parameters.queueName, '') }}:
       name: NetCore1ESPool-Svc-Public
-      demands: ImageOverride -demands ${{ parameters.queueName }}
+      demands: ImageOverride -equals ${{ parameters.queueName }}
 
     ${{ if ne(parameters.vmImageName, '') }}:
       vmImage: ${{ parameters.vmImageName }}
diff --git a/eng/pipelines/test-windows-job-single-machine.yml b/eng/pipelines/test-windows-job-single-machine.yml
index 9c93de550eedb..a854081d7dc1b 100644
--- a/eng/pipelines/test-windows-job-single-machine.yml
+++ b/eng/pipelines/test-windows-job-single-machine.yml
@@ -27,7 +27,7 @@ jobs:
   dependsOn: ${{ parameters.buildJobName }}
   pool:
     name: NetCore1ESPool-Svc-Public
-    demands: ImageOverride -demands ${{ parameters.queueName }}
+    demands: ImageOverride -equals ${{ parameters.queueName }}
   timeoutInMinutes: 120
   steps:
     - checkout: none

From 34531ac28808be512c5371b0f00a4fb9108b56f9 Mon Sep 17 00:00:00 2001
From: Jon Fortescue <jofortes@microsoft.com>
Date: Tue, 9 Nov 2021 10:43:31 -0800
Subject: [PATCH 074/444] another adjustment

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

diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index a69864b8d451b..4662f1bf96336 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -21,7 +21,7 @@ jobs:
     jobName: Build_Windows_Debug
     testArtifactName: Transport_Artifacts_Windows_Debug
     configuration: Debug
-    queueName: BuildPool.Windows.10.Amd64.Open
+    queueName: Build.Windows.10.Amd64.Open
 
 - template: eng/pipelines/build-windows-job.yml
   parameters:
@@ -127,7 +127,7 @@ jobs:
     testArtifactName: Transport_Artifacts_Unix_Debug
     configuration: Debug
     testArguments: --testCoreClr
-    queueName: 'BuildPool.Ubuntu.1604.amd64.Open'
+    queueName: 'Build.Ubuntu.1604.amd64.Open'
 
 - template: eng/pipelines/test-unix-job.yml
   parameters:

From b7c1fd1d01603b56c2991976885e7914fb8a569f Mon Sep 17 00:00:00 2001
From: Jon Fortescue <jofortes@microsoft.com>
Date: Tue, 9 Nov 2021 11:13:00 -0800
Subject: [PATCH 075/444] Ubuntu 16.04 -> 18.04

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

diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index 4662f1bf96336..a078a1a1404c7 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -108,7 +108,7 @@ jobs:
     jobName: Build_Unix_Debug
     testArtifactName: Transport_Artifacts_Unix_Debug
     configuration: Debug
-    vmImageName: 'ubuntu-16.04'
+    vmImageName: 'ubuntu-18.04'
 
 - template: eng/pipelines/test-unix-job.yml
   parameters:
@@ -117,7 +117,7 @@ jobs:
     buildJobName: Build_Unix_Debug
     testArtifactName: Transport_Artifacts_Unix_Debug
     configuration: Debug
-    testArguments: --testCoreClr --helixQueueName Ubuntu.1604.Amd64.Open
+    testArguments: --testCoreClr --helixQueueName Ubuntu.1804.Amd64.Open
 
 - template: eng/pipelines/test-unix-job-single-machine.yml
   parameters:
@@ -127,7 +127,7 @@ jobs:
     testArtifactName: Transport_Artifacts_Unix_Debug
     configuration: Debug
     testArguments: --testCoreClr
-    queueName: 'Build.Ubuntu.1604.amd64.Open'
+    queueName: 'Build.Ubuntu.1804.amd64.Open'
 
 - template: eng/pipelines/test-unix-job.yml
   parameters:
@@ -191,7 +191,7 @@ jobs:
 - job: Correctness_SourceBuild
   pool:
    name: NetCore1ESPool-Svc-Public
-   demands: ImageOverride -equals Build.Ubuntu.1604.amd64.Open
+   demands: ImageOverride -equals Build.Ubuntu.1804.amd64.Open
   timeoutInMinutes: 90
   steps:
     - template: eng/pipelines/checkout-unix-task.yml

From 3d9f6aa9abb6794176eb0cdd50ed20d0bc1f0bce Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Wed, 10 Nov 2021 14:24:16 -0800
Subject: [PATCH 076/444] Fix

---
 .../AsyncCompletion/AsyncCompletionLogger.cs  |  23 ++-
 .../AsyncCompletion/ItemManager.cs            | 149 ++++++++++--------
 ...etionCommandHandlerTests_DefaultsSource.vb | 142 ++++++++++++++++-
 3 files changed, 238 insertions(+), 76 deletions(-)

diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/AsyncCompletionLogger.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/AsyncCompletionLogger.cs
index eaa5c5a5e08e6..ec597d38424ac 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/AsyncCompletionLogger.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/AsyncCompletionLogger.cs
@@ -6,9 +6,10 @@
 
 namespace Microsoft.CodeAnalysis
 {
-    internal class AsyncCompletionLogger
+    internal static class AsyncCompletionLogger
     {
         private static readonly LogAggregator s_logAggregator = new();
+        private static readonly StatisticLogAggregator s_statisticLogAggregator = new();
 
         internal enum ActionInfo
         {
@@ -29,6 +30,8 @@ internal enum ActionInfo
             // Completion Filter.
             CommitWithTargetTypeCompletionExperimentEnabled,
             CommitItemWithTargetTypeFilter,
+
+            GetDefaultsMatchTicks,
         }
 
         internal static void LogSessionWithTypeImportCompletionEnabled() =>
@@ -52,10 +55,25 @@ internal static void LogTargetTypeFilterChosenInSession() =>
         internal static void LogSessionHasTargetTypeFilterEnabled() =>
             s_logAggregator.IncreaseCount((int)ActionInfo.SessionHasTargetTypeFilterEnabled);
 
+        internal static void LogGetDefaultsMatchTicksDataPoint(int count) =>
+            s_statisticLogAggregator.AddDataPoint((int)ActionInfo.GetDefaultsMatchTicks, count);
+
         internal static void ReportTelemetry()
         {
             Logger.Log(FunctionId.Intellisense_AsyncCompletion_Data, KeyValueLogMessage.Create(m =>
             {
+                foreach (var kv in s_statisticLogAggregator)
+                {
+                    var info = ((ActionInfo)kv.Key).ToString("f");
+                    var statistics = kv.Value.GetStatisticResult();
+
+                    m[CreateProperty(info, nameof(StatisticResult.Maximum))] = statistics.Maximum;
+                    m[CreateProperty(info, nameof(StatisticResult.Minimum))] = statistics.Minimum;
+                    m[CreateProperty(info, nameof(StatisticResult.Mean))] = statistics.Mean;
+                    m[CreateProperty(info, nameof(StatisticResult.Range))] = statistics.Range;
+                    m[CreateProperty(info, nameof(StatisticResult.Count))] = statistics.Count;
+                }
+
                 foreach (var kv in s_logAggregator)
                 {
                     var mergeInfo = ((ActionInfo)kv.Key).ToString("f");
@@ -63,5 +81,8 @@ internal static void ReportTelemetry()
                 }
             }));
         }
+
+        private static string CreateProperty(string parent, string child)
+            => parent + "." + child;
     }
 }
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
index 81383e04a9d19..93e001d132f61 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
@@ -239,11 +239,39 @@ private static readonly ObjectPool<List<MatchResult<VSCompletionItem>>> s_listOf
                     return null;
 
                 var (selectedItemIndex, selectionHint, uniqueItem) = filteringResult.Value;
-                var useAggressiveDefaultsMatching = session.TextView.Options.GetOptionValue<bool>(AggressiveDefaultsMatchingOptionName);
 
-                (selectedItemIndex, var forchHardSelection) = GetDefaultsMatch(filterText, initialListOfItemsToBeIncluded, selectedItemIndex, data.Defaults, useAggressiveDefaultsMatching);
-                if (forchHardSelection)
-                    selectionHint = UpdateSelectionHint.Selected;
+                // Editor is providing us a list of "default" items to consider for selection.
+                if (!data.Defaults.IsDefaultOrEmpty)
+                {
+                    var tick = Environment.TickCount;
+
+                    var selectedItem = initialListOfItemsToBeIncluded[selectedItemIndex].RoslynCompletionItem;
+
+                    // "Preselect" is only used when we have high confidence with the selection, so don't override it.
+                    if (selectedItem.Rules.MatchPriority < MatchPriority.Preselect)
+                    {
+                        int defaultsMatchingIndex;
+                        var useAggressiveDefaultsMatching = session.TextView.Options.GetOptionValue<bool>(AggressiveDefaultsMatchingOptionName);
+
+                        if (useAggressiveDefaultsMatching)
+                        {
+                            defaultsMatchingIndex = GetAggressiveDefaultsMatch(initialListOfItemsToBeIncluded, data.Defaults);
+                            if (!hasSuggestedItemOptions && defaultsMatchingIndex >= 0)
+                                selectionHint = UpdateSelectionHint.Selected;
+                        }
+                        else
+                        {
+                            defaultsMatchingIndex = GetDefaultsMatch(filterText, initialListOfItemsToBeIncluded, selectedItemIndex, data.Defaults);
+                        }
+
+                        if (defaultsMatchingIndex >= 0)
+                        {
+                            selectedItemIndex = defaultsMatchingIndex;
+                        }
+                    }
+
+                    AsyncCompletionLogger.LogGetDefaultsMatchTicksDataPoint(Environment.TickCount - tick);
+                }
 
                 var showCompletionItemFilters = _globalOptions.GetOption(CompletionViewOptions.ShowCompletionItemFilters, document?.Project.Language);
                 var updatedFilters = showCompletionItemFilters
@@ -758,89 +786,74 @@ private static bool IsPotentialFilterCharacter(char c)
                 || c == '_';
         }
 
-        private static (int index, bool forceHardSelection) GetDefaultsMatch(
-            string filterText,
-            List<MatchResult<VSCompletionItem>> itemsWithMatch,
-            int selectedIndex,
-            ImmutableArray<string> defaults,
-            bool aggressive)
+        private static int GetAggressiveDefaultsMatch(List<MatchResult<VSCompletionItem>> itemsWithMatch, ImmutableArray<string> defaults)
         {
-            // We only preselect when we are very confident with the selection, so don't override it.
-            if (defaults.IsDefaultOrEmpty || itemsWithMatch[selectedIndex].RoslynCompletionItem.Rules.MatchPriority >= MatchPriority.Preselect)
-                return (selectedIndex, false);
+            Debug.Assert(!defaults.IsDefaultOrEmpty);
 
-            if (aggressive)
+            foreach (var defaultText in defaults)
             {
-                foreach (var defaultText in defaults)
+                for (var i = 0; (i < itemsWithMatch.Count); ++i)
                 {
-                    for (var itemIndex = 0; (itemIndex < itemsWithMatch.Count); ++itemIndex)
+                    var itemWithMatch = itemsWithMatch[i];
+                    if (itemWithMatch.RoslynCompletionItem.FilterText == defaultText)
                     {
-                        var itemWithMatch = itemsWithMatch[itemIndex];
-                        if (itemWithMatch.RoslynCompletionItem.FilterText == defaultText)
-                        {
-                            if (itemWithMatch.PatternMatch == null || itemWithMatch.PatternMatch.Value.Kind <= PatternMatchKind.Prefix)
-                                return (itemIndex, true);
+                        if (itemWithMatch.PatternMatch == null || itemWithMatch.PatternMatch.Value.Kind <= PatternMatchKind.Prefix)
+                            return i;
 
-                            break;
-                        }
+                        break;
                     }
                 }
             }
+
+            return -1;
+        }
+
+        private static int GetDefaultsMatch(
+            string filterText,
+            List<MatchResult<VSCompletionItem>> itemsWithMatch,
+            int selectedIndex,
+            ImmutableArray<string> defaults)
+        {
+            Debug.Assert(!defaults.IsDefaultOrEmpty);
+
+            int inferiorItemIndex;
+            if (filterText.Length == 0)
+            {
+                // Without filterText, all items are eually good match, so we have to consider all of them.
+                inferiorItemIndex = itemsWithMatch.Count;
+            }
             else
             {
-                int similarItemsStart;
-                int dissimilarItemIndex;
+                // Because the items are sorted based on pattern-matching score, the selectedIndex is in the middle of a range of
+                // -- as far as the pattern matcher is concerned -- equivalent items. Find the last items in the range and use that
+                // to limit the items searched for from the defaults list.          
+                var selectedItemMatch = itemsWithMatch[selectedIndex].PatternMatch;
 
-                if (filterText.Length == 0)
-                {
-                    // If there is no applicableToSpan, then all items are equally similar.
-                    similarItemsStart = 0;
-                    dissimilarItemIndex = itemsWithMatch.Count;
-                }
-                else
-                {
-                    // Assume that the selectedIndex is in the middle of a range of -- as far as the pattern matcher is concerned --
-                    // equivalent items. Find the first & last items in the range and use that to limit the items searched for from
-                    // the defaults list.          
-                    var selectedItemMatch = itemsWithMatch[selectedIndex].PatternMatch;
-                    if (!selectedItemMatch.HasValue)
-                        return (selectedIndex, false);
-
-                    similarItemsStart = selectedIndex;
-                    while (--similarItemsStart >= 0)
-                    {
-                        var itemMatch = itemsWithMatch[similarItemsStart].PatternMatch;
-                        if ((!itemMatch.HasValue) || itemMatch.Value.CompareTo(selectedItemMatch.Value) > 0)
-                            break;
-                    }
-
-                    similarItemsStart++;
+                if (!selectedItemMatch.HasValue)
+                    return -1;
 
-                    dissimilarItemIndex = selectedIndex;
-                    while (++dissimilarItemIndex < itemsWithMatch.Count)
-                    {
-                        var itemMatch = itemsWithMatch[dissimilarItemIndex].PatternMatch;
-                        if ((!itemMatch.HasValue) || itemMatch.Value.CompareTo(selectedItemMatch.Value) > 0)
-                            break;
-                    }
+                inferiorItemIndex = selectedIndex;
+                while (++inferiorItemIndex < itemsWithMatch.Count)
+                {
+                    // Ignore the case when trying to match the filter text with defaults.
+                    // e.g. a default "Console" would be a match for filter text "c" and therefore to be selected,
+                    // even if the CompletionService returns item "char" which is a case-sensitive prefix match.
+                    var itemMatch = itemsWithMatch[inferiorItemIndex].PatternMatch;
+                    if (!itemMatch.HasValue || itemMatch.Value.Kind != selectedItemMatch.Value.Kind)
+                        break;
                 }
+            }
 
-                if (dissimilarItemIndex > selectedIndex + 1)
+            foreach (var defaultText in defaults)
+            {
+                for (var i = 0; i < inferiorItemIndex; ++i)
                 {
-                    foreach (var defaultText in defaults)
-                    {
-                        for (var itemIndex = similarItemsStart; (itemIndex < dissimilarItemIndex); ++itemIndex)
-                        {
-                            if (itemsWithMatch[itemIndex].RoslynCompletionItem.FilterText == defaultText)
-                            {
-                                return (itemIndex, false);
-                            }
-                        }
-                    }
+                    if (itemsWithMatch[i].RoslynCompletionItem.FilterText == defaultText)
+                        return i;
                 }
             }
 
-            return (selectedIndex, false);
+            return -1;
         }
     }
 }
diff --git a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_DefaultsSource.vb b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_DefaultsSource.vb
index ef7fad95cdd57..0c35e1b22897a 100644
--- a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_DefaultsSource.vb
+++ b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_DefaultsSource.vb
@@ -12,9 +12,36 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.IntelliSense
     <[UseExportProvider]>
     Public Class CSharpCompletionCommandHandlerTests_DefaultsSource
 
+        <WpfTheory, CombinatorialData>
+        <Trait(Traits.Feature, Traits.Features.Completion)>
+        Public Async Function TestNoItemMatchesDefaults(isAggressive As Boolean) As Task
+            Using state = TestStateFactory.CreateCSharpTestState(
+                              <Document>
+class C
+{
+    void MyMethod()
+    {
+        My$$
+    }
+}
+                              </Document>,
+                              extraExportedTypes:={GetType(MockDefaultSource)}.ToList())
+
+                If isAggressive Then
+                    state.TextView.Options.SetOptionValue(ItemManager.AggressiveDefaultsMatchingOptionName, True)
+                End If
+
+                state.SendInvokeCompletionList()
+
+                Await state.AssertCompletionItemsDoNotContainAny("MyA", "MyB")
+                Await state.AssertSelectedCompletionItem("MyMethod", isHardSelected:=True)
+
+            End Using
+        End Function
+
         <WpfFact, CombinatorialData>
         <Trait(Traits.Feature, Traits.Features.Completion)>
-        Public Async Function Test1() As Task
+        Public Async Function SelectFirstMatchingDefaultIfNoFilterText() As Task
             Using state = CreateTestState(
                               <Document>
 using NS1;
@@ -34,7 +61,7 @@ class C
 
         <WpfFact, CombinatorialData>
         <Trait(Traits.Feature, Traits.Features.Completion)>
-        Public Async Function Test2() As Task
+        Public Async Function SelectFirstMatchingDefaultWithFilterText() As Task
             Using state = CreateTestState(
                               <Document>
 using NS1;
@@ -54,15 +81,15 @@ class C
 
         <WpfTheory, CombinatorialData>
         <Trait(Traits.Feature, Traits.Features.Completion)>
-        Public Async Function Test3(isAggressive As Boolean) As Task
+        Public Async Function TestAggressiveDefaultsMatching(isAggressive As Boolean) As Task
             Using state = CreateTestState(
                               <Document>
 using NS1;
-class C
+class My
 {
     void Method()
     {
-        MyA$$
+        My$$
     }
 }
                               </Document>)
@@ -73,12 +100,113 @@ class C
                 state.SendInvokeCompletionList()
 
                 If isAggressive Then
+                    Await state.AssertCompletionItemsContain("My", displayTextSuffix:="")
                     Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
                     Await state.AssertSelectedCompletionItem("MyAB", isHardSelected:=True)
                 Else
                     Await state.AssertCompletionItemsContain("MyAB", displayTextSuffix:="")
-                    Await state.AssertSelectedCompletionItem("MyA", isHardSelected:=True)
+                    Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
+                    Await state.AssertSelectedCompletionItem("My", isHardSelected:=True)
+                End If
+            End Using
+        End Function
+
+        <WpfFact, CombinatorialData>
+        <Trait(Traits.Feature, Traits.Features.Completion)>
+        Public Async Function SelectFirstMatchingDefaultOverCaseSensitiveEquallyGoodMatch1() As Task
+            Using state = CreateTestState(
+                              <Document>
+using NS1;
+class C
+{
+    void Method(int my)
+    {
+        m$$
+    }
+}
+                              </Document>)
+
+                state.SendInvokeCompletionList()
+
+                Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
+                Await state.AssertCompletionItemsContain("my", displayTextSuffix:="")
+                Await state.AssertSelectedCompletionItem("MyAB", isHardSelected:=True)
+
+            End Using
+        End Function
+
+        <WpfFact, CombinatorialData>
+        <Trait(Traits.Feature, Traits.Features.Completion)>
+        Public Async Function SelectFirstMatchingDefaultOverCaseSensitiveEquallyGoodMatch2() As Task
+            Using state = CreateTestState(
+                              <Document>
+using NS1;
+class C
+{
+    void Method(int myA)
+    {
+        myA$$
+    }
+}
+                              </Document>)
+
+                state.SendInvokeCompletionList()
+
+                Await state.AssertCompletionItemsContain("myA", displayTextSuffix:="")
+                Await state.AssertCompletionItemsContain("MyAB", displayTextSuffix:="")
+                Await state.AssertSelectedCompletionItem("MyA", isHardSelected:=True)
+
+            End Using
+        End Function
+
+        <WpfFact, CombinatorialData>
+        <Trait(Traits.Feature, Traits.Features.Completion)>
+        Public Async Function DoNotChangeSelectionIfBetterMatch() As Task
+            Using state = CreateTestState(
+                              <Document>
+using NS1;
+class C
+{
+    void Method(int my)
+    {
+        my$$
+    }
+}
+                              </Document>)
+
+                state.SendInvokeCompletionList()
+
+                Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
+                Await state.AssertCompletionItemsContain("MyAB", displayTextSuffix:="")
+                Await state.AssertSelectedCompletionItem("my", isHardSelected:=True)
+
+            End Using
+        End Function
+
+        <WpfTheory, CombinatorialData>
+        <Trait(Traits.Feature, Traits.Features.Completion)>
+        Public Async Function DoNotChangeIfPreselection(isAggressive As Boolean) As Task
+            Using state = CreateTestState(
+                              <Document>
+using NS1;
+class C
+{
+    void Method()
+    {
+        C x = new $$
+    }
+}
+                              </Document>)
+                If isAggressive Then
+                    state.TextView.Options.SetOptionValue(ItemManager.AggressiveDefaultsMatchingOptionName, True)
                 End If
+
+                state.SendInvokeCompletionList()
+
+                Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
+                Await state.AssertCompletionItemsContain("MyAB", displayTextSuffix:="")
+                ' "C" is an item with preselect priority
+                Await state.AssertSelectedCompletionItem("C", isHardSelected:=True)
             End Using
         End Function
 
@@ -121,7 +249,7 @@ namespace NS1
             End Sub
 
             Public Function GetSessionDefaultsAsync(session As IAsyncCompletionSession) As Task(Of ImmutableArray(Of String)) Implements IAsyncCompletionDefaultsSource.GetSessionDefaultsAsync
-                Return Task.FromResult(ImmutableArray.Create("MyAB"))
+                Return Task.FromResult(ImmutableArray.Create("MyAB", "MyA"))
             End Function
         End Class
     End Class

From bf734b3665c9a19072f8438a2455309d184fdf9a Mon Sep 17 00:00:00 2001
From: Allison Chou <allichou@microsoft.com>
Date: Thu, 11 Nov 2021 10:32:58 -0800
Subject: [PATCH 077/444] Modify timeout

---
 src/VisualStudio/IntegrationTest/TestUtilities/Helper.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/VisualStudio/IntegrationTest/TestUtilities/Helper.cs b/src/VisualStudio/IntegrationTest/TestUtilities/Helper.cs
index 711bb43059e8c..8d6473ffc2eef 100644
--- a/src/VisualStudio/IntegrationTest/TestUtilities/Helper.cs
+++ b/src/VisualStudio/IntegrationTest/TestUtilities/Helper.cs
@@ -15,7 +15,7 @@ public static class Helper
         /// <summary>
         /// A long timeout used to avoid hangs in tests, where a test failure manifests as an operation never occurring.
         /// </summary>
-        public static readonly TimeSpan HangMitigatingTimeout = TimeSpan.FromSeconds(15);
+        public static readonly TimeSpan HangMitigatingTimeout = TimeSpan.FromMinutes(1);
 
         private static IUIAutomation2? _automation;
 

From cccfc1be66675df1f159fb5e3a1fe2748dfb9be1 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Tue, 16 Nov 2021 12:31:06 -0800
Subject: [PATCH 078/444] Remove weakref that telemetry indicates has no impact
 at all.

---
 .../VisualStudioMetadataReferenceManager.cs               | 6 +-----
 .../Portable/Workspace/WorkspaceConfigurationOptions.cs   | 8 --------
 2 files changed, 1 insertion(+), 13 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/MetadataReferences/VisualStudioMetadataReferenceManager.cs b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/MetadataReferences/VisualStudioMetadataReferenceManager.cs
index ac9300f0146d8..06ac3f1f069e9 100644
--- a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/MetadataReferences/VisualStudioMetadataReferenceManager.cs
+++ b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/MetadataReferences/VisualStudioMetadataReferenceManager.cs
@@ -130,11 +130,7 @@ internal Metadata GetMetadata(string fullPath, DateTime snapshotTimestamp)
 
             if (VsSmartScopeCandidate(key.FullPath) && TryCreateAssemblyMetadataFromMetadataImporter(key, out var newMetadata))
             {
-                ValueSource<Optional<AssemblyMetadata>> metadataValueSource = _workspace.Options.GetOption(WorkspaceConfigurationOptions.DisableReferenceManagerWeakRuntimeReferences)
-                    ? new ConstantValueSource<Optional<AssemblyMetadata>>(newMetadata)
-                    : new WeakValueSource<AssemblyMetadata>(newMetadata);
-
-                if (!_metadataCache.GetOrAddMetadata(key, metadataValueSource, out metadata))
+                if (!_metadataCache.GetOrAddMetadata(key, new ConstantValueSource<Optional<AssemblyMetadata>>(newMetadata), out metadata))
                 {
                     newMetadata.Dispose();
                 }
diff --git a/src/Workspaces/Core/Portable/Workspace/WorkspaceConfigurationOptions.cs b/src/Workspaces/Core/Portable/Workspace/WorkspaceConfigurationOptions.cs
index 2192bd7abac94..a865ce4a4c85d 100644
--- a/src/Workspaces/Core/Portable/Workspace/WorkspaceConfigurationOptions.cs
+++ b/src/Workspaces/Core/Portable/Workspace/WorkspaceConfigurationOptions.cs
@@ -26,13 +26,6 @@ internal class WorkspaceConfigurationOptions : IOptionProvider
             nameof(WorkspaceConfigurationOptions), nameof(DisableProjectCacheService), defaultValue: false,
             new FeatureFlagStorageLocation("Roslyn.DisableProjectCacheService"));
 
-        /// <summary>
-        /// Disables holding onto the assembly references for runtime (not user/nuget/etc.) dlls weakly.
-        /// </summary>
-        public static readonly Option<bool> DisableReferenceManagerWeakRuntimeReferences = new(
-            nameof(WorkspaceConfigurationOptions), nameof(DisableReferenceManagerWeakRuntimeReferences), defaultValue: false,
-            new FeatureFlagStorageLocation("Roslyn.DisableReferenceManagerWeakRuntimeReferences"));
-
         /// <summary>
         /// Disables holding onto the assembly references for runtime (not user/nuget/etc.) dlls weakly.
         /// </summary>
@@ -43,7 +36,6 @@ internal class WorkspaceConfigurationOptions : IOptionProvider
         ImmutableArray<IOption> IOptionProvider.Options { get; } = ImmutableArray.Create<IOption>(
             DisableRecoverableTrees,
             DisableProjectCacheService,
-            DisableReferenceManagerWeakRuntimeReferences,
             DisableCompilationTrackerWeakCompilationReferences);
 
         [ImportingConstructor]

From 7dd619be5733e5983ffc630bc3000276941e55be Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Tue, 16 Nov 2021 19:14:18 -0800
Subject: [PATCH 079/444] Linting

---
 .../VisualStudioMetadataReferenceManager.Factory.cs            | 2 +-
 .../MetadataReferences/VisualStudioMetadataReferenceManager.cs | 3 ---
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/MetadataReferences/VisualStudioMetadataReferenceManager.Factory.cs b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/MetadataReferences/VisualStudioMetadataReferenceManager.Factory.cs
index aa4c65791d57f..c4fa85094c6a1 100644
--- a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/MetadataReferences/VisualStudioMetadataReferenceManager.Factory.cs
+++ b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/MetadataReferences/VisualStudioMetadataReferenceManager.Factory.cs
@@ -32,7 +32,7 @@ public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
             if (_singleton == null)
             {
                 var temporaryStorage = workspaceServices.GetService<ITemporaryStorageService>();
-                Interlocked.CompareExchange(ref _singleton, new VisualStudioMetadataReferenceManager(workspaceServices.Workspace, _serviceProvider, temporaryStorage), null);
+                Interlocked.CompareExchange(ref _singleton, new VisualStudioMetadataReferenceManager(_serviceProvider, temporaryStorage), null);
             }
 
             return _singleton;
diff --git a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/MetadataReferences/VisualStudioMetadataReferenceManager.cs b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/MetadataReferences/VisualStudioMetadataReferenceManager.cs
index 06ac3f1f069e9..02bbe5225917b 100644
--- a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/MetadataReferences/VisualStudioMetadataReferenceManager.cs
+++ b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/MetadataReferences/VisualStudioMetadataReferenceManager.cs
@@ -36,7 +36,6 @@ internal sealed partial class VisualStudioMetadataReferenceManager : IWorkspaceS
 
         private readonly MetadataCache _metadataCache;
         private readonly ImmutableArray<string> _runtimeDirectories;
-        private readonly Workspace _workspace;
         private readonly ITemporaryStorageService _temporaryStorageService;
 
         internal IVsXMLMemberIndexService XmlMemberIndexService { get; }
@@ -53,7 +52,6 @@ internal sealed partial class VisualStudioMetadataReferenceManager : IWorkspaceS
         private readonly ReaderWriterLockSlim _readerWriterLock = new();
 
         internal VisualStudioMetadataReferenceManager(
-            Workspace workspace,
             IServiceProvider serviceProvider,
             ITemporaryStorageService temporaryStorageService)
         {
@@ -68,7 +66,6 @@ internal VisualStudioMetadataReferenceManager(
 
             FileChangeService = (IVsFileChangeEx)serviceProvider.GetService(typeof(SVsFileChangeEx));
             Assumes.Present(FileChangeService);
-            _workspace = workspace;
             _temporaryStorageService = temporaryStorageService;
             Assumes.Present(_temporaryStorageService);
         }

From 7c09ca1292acf562ee872fff8b818d81bec509f4 Mon Sep 17 00:00:00 2001
From: dotnet bot <dotnet-bot@dotnetfoundation.org>
Date: Thu, 18 Nov 2021 15:54:11 -0800
Subject: [PATCH 080/444] Merge pull request #57824 from dibarbet/fix_lsp_rps
 (#57871)

[LSP] Use test accessor task instead of async operation to wait for LSP server shutdown in tests

Co-authored-by: David Barbet <dabarbet@microsoft.com>
---
 .../AbstractLanguageServerProtocolTests.cs    |  3 +--
 ...estExecutionQueue.DocumentChangeTracker.cs |  5 +++++
 .../Protocol/Handler/RequestExecutionQueue.cs | 12 ++++++-----
 .../Protocol/LanguageServerTarget.cs          |  1 -
 .../LanguageServerTargetTests.cs              | 20 +++++++++----------
 .../Ordering/RequestOrderingTests.cs          |  4 +---
 6 files changed, 24 insertions(+), 21 deletions(-)

diff --git a/src/EditorFeatures/TestUtilities/LanguageServer/AbstractLanguageServerProtocolTests.cs b/src/EditorFeatures/TestUtilities/LanguageServer/AbstractLanguageServerProtocolTests.cs
index c143150fb46fb..261b85d0d82b1 100644
--- a/src/EditorFeatures/TestUtilities/LanguageServer/AbstractLanguageServerProtocolTests.cs
+++ b/src/EditorFeatures/TestUtilities/LanguageServer/AbstractLanguageServerProtocolTests.cs
@@ -404,8 +404,7 @@ private static RequestExecutionQueue CreateRequestQueue(TestWorkspace workspace)
             var registrationService = workspace.GetService<LspWorkspaceRegistrationService>();
             var globalOptions = workspace.GetService<IGlobalOptionService>();
             var lspMiscFilesWorkspace = new LspMiscellaneousFilesWorkspace(NoOpLspLogger.Instance);
-            var listenerProvider = workspace.ExportProvider.GetExportedValue<IAsynchronousOperationListenerProvider>();
-            return new RequestExecutionQueue(NoOpLspLogger.Instance, registrationService, lspMiscFilesWorkspace, globalOptions, listenerProvider, ProtocolConstants.RoslynLspLanguages, serverName: "Tests", "TestClient");
+            return new RequestExecutionQueue(NoOpLspLogger.Instance, registrationService, lspMiscFilesWorkspace, globalOptions, ProtocolConstants.RoslynLspLanguages, serverName: "Tests", "TestClient");
         }
 
         private static string GetDocumentFilePathFromName(string documentName)
diff --git a/src/Features/LanguageServer/Protocol/Handler/RequestExecutionQueue.DocumentChangeTracker.cs b/src/Features/LanguageServer/Protocol/Handler/RequestExecutionQueue.DocumentChangeTracker.cs
index e3c654ecf5ac1..3d041a4608d6a 100644
--- a/src/Features/LanguageServer/Protocol/Handler/RequestExecutionQueue.DocumentChangeTracker.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/RequestExecutionQueue.DocumentChangeTracker.cs
@@ -61,6 +61,11 @@ public ImmutableArray<SourceText> GetTrackedTexts()
 
             public bool IsComplete() => _queue._queue.IsCompleted && _queue._queue.IsEmpty;
 
+            public async Task WaitForProcessingToStopAsync()
+            {
+                await _queue._queueProcessingTask.ConfigureAwait(false);
+            }
+
             /// <summary>
             /// Test only method to validate that remaining items in the queue are cancelled.
             /// This directly mutates the queue in an unsafe way, so ensure that all relevant queue operations
diff --git a/src/Features/LanguageServer/Protocol/Handler/RequestExecutionQueue.cs b/src/Features/LanguageServer/Protocol/Handler/RequestExecutionQueue.cs
index 3f7e10f21fac1..181b902e53b7d 100644
--- a/src/Features/LanguageServer/Protocol/Handler/RequestExecutionQueue.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/RequestExecutionQueue.cs
@@ -65,11 +65,16 @@ internal partial class RequestExecutionQueue
         private readonly CancellationTokenSource _cancelSource = new CancellationTokenSource();
         private readonly RequestTelemetryLogger _requestTelemetryLogger;
         private readonly IGlobalOptionService _globalOptions;
-        private readonly IAsynchronousOperationListener _asynchronousOperationListener;
 
         private readonly ILspLogger _logger;
         private readonly LspWorkspaceManager _lspWorkspaceManager;
 
+        /// <summary>
+        /// For test purposes only.
+        /// A task that completes when the queue processing stops.
+        /// </summary>
+        private readonly Task _queueProcessingTask;
+
         public CancellationToken CancellationToken => _cancelSource.Token;
 
         /// <summary>
@@ -87,7 +92,6 @@ public RequestExecutionQueue(
             LspWorkspaceRegistrationService lspWorkspaceRegistrationService,
             LspMiscellaneousFilesWorkspace? lspMiscellaneousFilesWorkspace,
             IGlobalOptionService globalOptions,
-            IAsynchronousOperationListenerProvider listenerProvider,
             ImmutableArray<string> supportedLanguages,
             string serverName,
             string serverTypeName)
@@ -106,9 +110,7 @@ public RequestExecutionQueue(
             _lspWorkspaceManager = new LspWorkspaceManager(logger, lspMiscellaneousFilesWorkspace, lspWorkspaceRegistrationService, _requestTelemetryLogger);
 
             // Start the queue processing
-            _asynchronousOperationListener = listenerProvider.GetListener(FeatureAttribute.LanguageServer);
-            var token = _asynchronousOperationListener.BeginAsyncOperation($"{nameof(ProcessQueueAsync)}_{serverTypeName}");
-            _ = ProcessQueueAsync().CompletesAsyncOperation(token);
+            _queueProcessingTask = ProcessQueueAsync();
         }
 
         /// <summary>
diff --git a/src/Features/LanguageServer/Protocol/LanguageServerTarget.cs b/src/Features/LanguageServer/Protocol/LanguageServerTarget.cs
index 634404aaea8ea..5474aa81f5c35 100644
--- a/src/Features/LanguageServer/Protocol/LanguageServerTarget.cs
+++ b/src/Features/LanguageServer/Protocol/LanguageServerTarget.cs
@@ -87,7 +87,6 @@ internal LanguageServerTarget(
                 workspaceRegistrationService,
                 lspMiscellaneousFilesWorkspace,
                 globalOptions,
-                listenerProvider,
                 supportedLanguages,
                 userVisibleServerName,
                 TelemetryServerName);
diff --git a/src/Features/LanguageServer/ProtocolUnitTests/LanguageServerTargetTests.cs b/src/Features/LanguageServer/ProtocolUnitTests/LanguageServerTargetTests.cs
index 8c47016ebf52f..b27ade5026b05 100644
--- a/src/Features/LanguageServer/ProtocolUnitTests/LanguageServerTargetTests.cs
+++ b/src/Features/LanguageServer/ProtocolUnitTests/LanguageServerTargetTests.cs
@@ -27,34 +27,34 @@ public class LanguageServerTargetTests : AbstractLanguageServerProtocolTests
         [Fact]
         public async Task LanguageServerQueueEmptyOnShutdownMessage()
         {
-            await using var languageServerTarget = CreateLanguageServer(out var jsonRpc, out var listenerProvider);
+            await using var languageServerTarget = CreateLanguageServer(out var jsonRpc);
             AssertServerAlive(languageServerTarget);
 
             await languageServerTarget.ShutdownAsync(CancellationToken.None).ConfigureAwait(false);
-            await AssertServerQueueClosed(languageServerTarget, listenerProvider).ConfigureAwait(false);
+            await AssertServerQueueClosed(languageServerTarget).ConfigureAwait(false);
             Assert.False(jsonRpc.IsDisposed);
         }
 
         [Fact]
         public async Task LanguageServerCleansUpOnExitMessage()
         {
-            await using var languageServerTarget = CreateLanguageServer(out var jsonRpc, out var listenerProvider);
+            await using var languageServerTarget = CreateLanguageServer(out var jsonRpc);
             AssertServerAlive(languageServerTarget);
 
             await languageServerTarget.ShutdownAsync(CancellationToken.None).ConfigureAwait(false);
             await languageServerTarget.ExitAsync(CancellationToken.None).ConfigureAwait(false);
-            await AssertServerQueueClosed(languageServerTarget, listenerProvider).ConfigureAwait(false);
+            await AssertServerQueueClosed(languageServerTarget).ConfigureAwait(false);
             Assert.True(jsonRpc.IsDisposed);
         }
 
         [Fact]
         public async Task LanguageServerCleansUpOnUnexpectedJsonRpcDisconnectAsync()
         {
-            await using var languageServerTarget = CreateLanguageServer(out var jsonRpc, out var listenerProvider);
+            await using var languageServerTarget = CreateLanguageServer(out var jsonRpc);
             AssertServerAlive(languageServerTarget);
 
             jsonRpc.Dispose();
-            await AssertServerQueueClosed(languageServerTarget, listenerProvider).ConfigureAwait(false);
+            await AssertServerQueueClosed(languageServerTarget).ConfigureAwait(false);
             Assert.True(jsonRpc.IsDisposed);
         }
 
@@ -64,14 +64,14 @@ private static void AssertServerAlive(LanguageServerTarget server)
             Assert.False(server.GetTestAccessor().GetQueueAccessor().IsComplete());
         }
 
-        private static async Task AssertServerQueueClosed(LanguageServerTarget server, IAsynchronousOperationListenerProvider listenerProvider)
+        private static async Task AssertServerQueueClosed(LanguageServerTarget server)
         {
-            await listenerProvider.GetWaiter(FeatureAttribute.LanguageServer).ExpeditedWaitAsync();
+            await server.GetTestAccessor().GetQueueAccessor().WaitForProcessingToStopAsync().ConfigureAwait(false);
             Assert.True(server.HasShutdownStarted);
             Assert.True(server.GetTestAccessor().GetQueueAccessor().IsComplete());
         }
 
-        private LanguageServerTarget CreateLanguageServer(out JsonRpc serverJsonRpc, out IAsynchronousOperationListenerProvider listenerProvider)
+        private LanguageServerTarget CreateLanguageServer(out JsonRpc serverJsonRpc)
         {
             using var workspace = TestWorkspace.CreateCSharp("", composition: Composition);
 
@@ -80,7 +80,7 @@ private LanguageServerTarget CreateLanguageServer(out JsonRpc serverJsonRpc, out
             var lspWorkspaceRegistrationService = workspace.GetService<LspWorkspaceRegistrationService>();
             var capabilitiesProvider = workspace.GetService<DefaultCapabilitiesProvider>();
             var globalOptions = workspace.GetService<IGlobalOptionService>();
-            listenerProvider = workspace.GetService<IAsynchronousOperationListenerProvider>();
+            var listenerProvider = workspace.GetService<IAsynchronousOperationListenerProvider>();
 
             serverJsonRpc = new JsonRpc(new HeaderDelimitedMessageHandler(serverStream, serverStream))
             {
diff --git a/src/Features/LanguageServer/ProtocolUnitTests/Ordering/RequestOrderingTests.cs b/src/Features/LanguageServer/ProtocolUnitTests/Ordering/RequestOrderingTests.cs
index fee4de5b4df78..30e66d9b0eddf 100644
--- a/src/Features/LanguageServer/ProtocolUnitTests/Ordering/RequestOrderingTests.cs
+++ b/src/Features/LanguageServer/ProtocolUnitTests/Ordering/RequestOrderingTests.cs
@@ -173,9 +173,7 @@ public async Task FailingMutableTaskShutsDownQueue()
 
             // The failed request returns to the client before the shutdown completes.
             // Wait for the queue to finish handling the failed request and shutdown.
-            var operations = testLspServer.TestWorkspace.ExportProvider.GetExportedValue<AsynchronousOperationListenerProvider>();
-            var waiter = operations.GetWaiter(FeatureAttribute.LanguageServer);
-            await waiter.ExpeditedWaitAsync();
+            await testLspServer.GetQueueAccessor().WaitForProcessingToStopAsync().ConfigureAwait(false);
 
             // remaining tasks should be canceled
             var areAllItemsCancelled = await testLspServer.GetQueueAccessor().AreAllItemsCancelledUnsafeAsync();

From 2579b6dfefeddcce0419d0ca95719de0a7c51d7f Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Mon, 22 Nov 2021 14:06:12 -0800
Subject: [PATCH 081/444] Move main ItemManager logic into a separate helper
 class

No change to the code other than extracting a helper class here.
---
 .../ItemManager.CompeltionListUpdater.cs      | 820 ++++++++++++++++++
 .../AsyncCompletion/ItemManager.cs            | 783 +----------------
 2 files changed, 823 insertions(+), 780 deletions(-)
 create mode 100644 src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs

diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs
new file mode 100644
index 0000000000000..32a798c6f9e02
--- /dev/null
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs
@@ -0,0 +1,820 @@
+// 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.Collections.Immutable;
+using System.Diagnostics;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using Microsoft.CodeAnalysis.Completion;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.PatternMatching;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Text;
+using Microsoft.CodeAnalysis.Text.Shared.Extensions;
+using Microsoft.VisualStudio.Language.Intellisense.AsyncCompletion;
+using Microsoft.VisualStudio.Language.Intellisense.AsyncCompletion.Data;
+using Microsoft.VisualStudio.Text;
+using Roslyn.Utilities;
+using RoslynCompletionItem = Microsoft.CodeAnalysis.Completion.CompletionItem;
+using VSCompletionItem = Microsoft.VisualStudio.Language.Intellisense.AsyncCompletion.Data.CompletionItem;
+
+namespace Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.AsyncCompletion
+{
+    internal partial class ItemManager
+    {
+        private sealed class CompletionListUpdater
+        {
+
+            public IAsyncCompletionSession Session { get; }
+            public AsyncCompletionSessionDataSnapshot Data { get; }
+            public RecentItemsManager RecentItemsManager { get; }
+            public IGlobalOptionService GlobalOptions { get; }
+            public CancellationToken CancellationToken { get; }
+            public CompletionHelper DefaultCompletionHelper { get; }
+
+            // We might need to handle large amount of items with import completion enabled,
+            // so use a dedicated pool to minimize/avoid array allocations (especially in LOH)
+            // Set the size of pool to 1 because we don't expect UpdateCompletionListAsync to be
+            // called concurrently, which essentially makes the pooled list a singleton,
+            // but we still use ObjectPool for concurrency handling just to be robust.
+            private static readonly ObjectPool<List<MatchResult<VSCompletionItem>>> s_listOfMatchResultPool
+                    = new(factory: () => new(), size: 1);
+
+            public const string AggressiveDefaultsMatchingOptionName = "AggressiveDefaultsMatchingOption";
+
+            /// <summary>
+            /// For telemetry.
+            /// </summary>
+            private readonly object _targetTypeCompletionFilterChosenMarker = new();
+
+            public CompletionListUpdater(
+                IAsyncCompletionSession session,
+                AsyncCompletionSessionDataSnapshot data,
+                RecentItemsManager recentItemsManager,
+                IGlobalOptionService globalOptions,
+                CancellationToken cancellationToken)
+            {
+                Session = session;
+                Data = data;
+                RecentItemsManager = recentItemsManager;
+                GlobalOptions = globalOptions;
+                CancellationToken = cancellationToken;
+
+                // Let us make the completion Helper used for non-Roslyn items case-sensitive.
+                // We can change this if get requests from partner teams.
+                DefaultCompletionHelper = new CompletionHelper(isCaseSensitive: true);
+            }
+
+            public FilteredCompletionModel? UpdateCompletionList()
+            {
+                if (!Session.Properties.TryGetProperty(CompletionSource.HasSuggestionItemOptions, out bool hasSuggestedItemOptions))
+                {
+                    // This is the scenario when the session is created out of Roslyn, in some other provider, e.g. in Debugger.
+                    // For now, the default hasSuggestedItemOptions is false.
+                    hasSuggestedItemOptions = false;
+                }
+
+                hasSuggestedItemOptions |= Data.DisplaySuggestionItem;
+
+                var filterText = Session.ApplicableToSpan.GetText(Data.Snapshot);
+                var reason = Data.Trigger.Reason;
+                var initialRoslynTriggerKind = Helpers.GetRoslynTriggerKind(Data.InitialTrigger);
+
+                // Check if the user is typing a number. If so, only proceed if it's a number
+                // directly after a <dot>. That's because it is actually reasonable for completion
+                // to be brought up after a <dot> and for the user to want to filter completion
+                // items based on a number that exists in the name of the item. However, when
+                // we are not after a dot (i.e. we're being brought up after <space> is typed)
+                // then we don't want to filter things. Consider the user writing:
+                //
+                //      dim i =<space>
+                //
+                // We'll bring up the completion list here (as VB has completion on <space>).
+                // If the user then types '3', we don't want to match against Int32.
+                if (filterText.Length > 0 && char.IsNumber(filterText[0]))
+                {
+                    if (!IsAfterDot(Data.Snapshot, Session.ApplicableToSpan))
+                    {
+                        // Dismiss the session.
+                        return null;
+                    }
+                }
+
+                // We need to filter if 
+                // 1. a non-empty strict subset of filters are selected
+                // 2. a non-empty set of expanders are unselected
+                var nonExpanderFilterStates = Data.SelectedFilters.WhereAsArray(f => f.Filter is not CompletionExpander);
+
+                var selectedNonExpanderFilters = nonExpanderFilterStates.SelectAsArray(f => f.IsSelected, f => f.Filter);
+                var needToFilter = selectedNonExpanderFilters.Length > 0 && selectedNonExpanderFilters.Length < nonExpanderFilterStates.Length;
+
+                var unselectedExpanders = Data.SelectedFilters.SelectAsArray(f => !f.IsSelected && f.Filter is CompletionExpander, f => f.Filter);
+                var needToFilterExpanded = unselectedExpanders.Length > 0;
+
+                if (Session.TextView.Properties.TryGetProperty(CompletionSource.TargetTypeFilterExperimentEnabled, out bool isExperimentEnabled) && isExperimentEnabled)
+                {
+                    // Telemetry: Want to know % of sessions with the "Target type matches" filter where that filter is actually enabled
+                    if (needToFilter &&
+                        !Session.Properties.ContainsProperty(_targetTypeCompletionFilterChosenMarker) &&
+                        selectedNonExpanderFilters.Any(f => f.DisplayText == FeaturesResources.Target_type_matches))
+                    {
+                        AsyncCompletionLogger.LogTargetTypeFilterChosenInSession();
+
+                        // Make sure we only record one enabling of the filter per session
+                        Session.Properties.AddProperty(_targetTypeCompletionFilterChosenMarker, _targetTypeCompletionFilterChosenMarker);
+                    }
+                }
+
+                var filterReason = Helpers.GetFilterReason(Data.Trigger);
+
+                // We prefer using the original snapshot, which should always be available from items provided by Roslyn's CompletionSource.
+                // Only use data.Snapshot in the theoretically possible but rare case when all items we are handling are from some non-Roslyn CompletionSource.
+                var snapshotForDocument = TryGetInitialTriggerLocation(Data, out var intialTriggerLocation)
+                    ? intialTriggerLocation.Snapshot
+                    : Data.Snapshot;
+
+                var document = snapshotForDocument?.TextBuffer.AsTextContainer().GetOpenDocumentInCurrentContext();
+                var completionService = document?.GetLanguageService<CompletionService>();
+                var completionRules = completionService?.GetRules(CompletionOptions.From(document!.Project)) ?? CompletionRules.Default;
+                var completionHelper = document != null ? CompletionHelper.GetHelper(document) : DefaultCompletionHelper;
+
+                // DismissIfLastCharacterDeleted should be applied only when started with Insertion, and then Deleted all characters typed.
+                // This conforms with the original VS 2010 behavior.
+                if (initialRoslynTriggerKind == CompletionTriggerKind.Insertion &&
+                    Data.Trigger.Reason == CompletionTriggerReason.Backspace &&
+                    completionRules.DismissIfLastCharacterDeleted &&
+                    Session.ApplicableToSpan.GetText(Data.Snapshot).Length == 0)
+                {
+                    // Dismiss the session
+                    return null;
+                }
+
+                var highlightMatchingPortions = GlobalOptions.GetOption(CompletionViewOptions.HighlightMatchingPortionsOfCompletionListItems, document?.Project.Language);
+                // Nothing to highlight if user hasn't typed anything yet.
+                highlightMatchingPortions = highlightMatchingPortions && filterText.Length > 0;
+
+                // Use a monotonically increasing integer to keep track the original alphabetical order of each item.
+                var currentIndex = 0;
+
+                var initialListOfItemsToBeIncluded = s_listOfMatchResultPool.Allocate();
+                try
+                {
+                    // Filter items based on the selected filters and matching.
+                    foreach (var item in Data.InitialSortedList)
+                    {
+                        CancellationToken.ThrowIfCancellationRequested();
+
+                        if (needToFilter && ShouldBeFilteredOutOfCompletionList(item, selectedNonExpanderFilters))
+                        {
+                            continue;
+                        }
+
+                        if (needToFilterExpanded && ShouldBeFilteredOutOfExpandedCompletionList(item, unselectedExpanders))
+                        {
+                            continue;
+                        }
+
+                        if (TryCreateMatchResult(
+                            completionHelper,
+                            item,
+                            filterText,
+                            initialRoslynTriggerKind,
+                            filterReason,
+                            RecentItemsManager.RecentItems,
+                            highlightMatchingPortions: highlightMatchingPortions,
+                            currentIndex,
+                            out var matchResult))
+                        {
+                            initialListOfItemsToBeIncluded.Add(matchResult);
+                            currentIndex++;
+                        }
+                    }
+
+                    if (initialListOfItemsToBeIncluded.Count == 0)
+                    {
+                        return HandleAllItemsFilteredOut(reason, Data.SelectedFilters, completionRules);
+                    }
+
+                    // Sort the items by pattern matching results.
+                    // Note that we want to preserve the original alphabetical order for items with same pattern match score,
+                    // but `List<T>.Sort` isn't stable. Therefore we have to add a monotonically increasing integer
+                    // to `MatchResult` to achieve this.
+                    initialListOfItemsToBeIncluded.Sort(MatchResult<VSCompletionItem>.SortingComparer);
+
+                    var filteringResult = initialRoslynTriggerKind == CompletionTriggerKind.Deletion
+                            ? HandleDeletionTrigger(reason, initialListOfItemsToBeIncluded, filterText, hasSuggestedItemOptions)
+                            : HandleNormalFiltering(GetFilterMethod(), filterText, filterReason, Data.Trigger.Character, initialListOfItemsToBeIncluded, hasSuggestedItemOptions);
+
+                    if (!filteringResult.HasValue)
+                        return null;
+
+                    var (selectedItemIndex, selectionHint, uniqueItem) = filteringResult.Value;
+
+                    // Editor is providing us a list of "default" items to consider for selection.
+                    if (!Data.Defaults.IsDefaultOrEmpty)
+                    {
+                        var tick = Environment.TickCount;
+
+                        var selectedItem = initialListOfItemsToBeIncluded[selectedItemIndex].RoslynCompletionItem;
+
+                        // "Preselect" is only used when we have high confidence with the selection, so don't override it.
+                        if (selectedItem.Rules.MatchPriority < MatchPriority.Preselect)
+                        {
+                            int defaultsMatchingIndex;
+                            var useAggressiveDefaultsMatching = Session.TextView.Options.GetOptionValue<bool>(AggressiveDefaultsMatchingOptionName);
+
+                            if (useAggressiveDefaultsMatching)
+                            {
+                                defaultsMatchingIndex = GetAggressiveDefaultsMatch(initialListOfItemsToBeIncluded, Data.Defaults);
+                                if (!hasSuggestedItemOptions && defaultsMatchingIndex >= 0)
+                                    selectionHint = UpdateSelectionHint.Selected;
+                            }
+                            else
+                            {
+                                defaultsMatchingIndex = GetDefaultsMatch(filterText, initialListOfItemsToBeIncluded, selectedItemIndex, Data.Defaults);
+                            }
+
+                            if (defaultsMatchingIndex >= 0)
+                            {
+                                selectedItemIndex = defaultsMatchingIndex;
+                            }
+                        }
+
+                        AsyncCompletionLogger.LogGetDefaultsMatchTicksDataPoint(Environment.TickCount - tick);
+                    }
+
+                    var showCompletionItemFilters = GlobalOptions.GetOption(CompletionViewOptions.ShowCompletionItemFilters, document?.Project.Language);
+                    var updatedFilters = showCompletionItemFilters
+                        ? GetUpdatedFilters(initialListOfItemsToBeIncluded, Data.SelectedFilters)
+                        : ImmutableArray<CompletionFilterWithState>.Empty;
+
+                    return new FilteredCompletionModel(
+                        items: GetHighlightedList(initialListOfItemsToBeIncluded, filterText, highlightMatchingPortions, completionHelper),
+                        selectedItemIndex,
+                        updatedFilters,
+                        selectionHint,
+                        centerSelection: true,
+                        uniqueItem);
+                }
+                finally
+                {
+                    // Don't call ClearAndFree, which resets the capacity to a default value.
+                    initialListOfItemsToBeIncluded.Clear();
+                    s_listOfMatchResultPool.Free(initialListOfItemsToBeIncluded);
+                }
+
+                Func<ImmutableArray<(RoslynCompletionItem, PatternMatch?)>, string, ImmutableArray<RoslynCompletionItem>> GetFilterMethod()
+                {
+                    if (completionService == null)
+                    {
+                        return (itemsWithPatternMatches, text) => CompletionService.FilterItems(completionHelper, itemsWithPatternMatches, text);
+                    }
+                    else
+                    {
+                        Contract.ThrowIfNull(document);
+                        return (itemsWithPatternMatches, text) => completionService.FilterItems(document, itemsWithPatternMatches, text);
+                    }
+                }
+
+                static bool TryGetInitialTriggerLocation(AsyncCompletionSessionDataSnapshot data, out SnapshotPoint intialTriggerLocation)
+                {
+                    var firstItem = data.InitialSortedList.FirstOrDefault(static item => item.Properties.ContainsProperty(CompletionSource.TriggerLocation));
+                    if (firstItem != null)
+                    {
+                        return firstItem.Properties.TryGetProperty(CompletionSource.TriggerLocation, out intialTriggerLocation);
+                    }
+
+                    intialTriggerLocation = default;
+                    return false;
+                }
+
+                static bool ShouldBeFilteredOutOfCompletionList(VSCompletionItem item, ImmutableArray<CompletionFilter> activeNonExpanderFilters)
+                {
+                    if (item.Filters.Any(filter => activeNonExpanderFilters.Contains(filter)))
+                    {
+                        return false;
+                    }
+
+                    return true;
+                }
+
+                static bool ShouldBeFilteredOutOfExpandedCompletionList(VSCompletionItem item, ImmutableArray<CompletionFilter> unselectedExpanders)
+                {
+                    var associatedWithUnselectedExpander = false;
+                    foreach (var itemFilter in item.Filters)
+                    {
+                        if (itemFilter is CompletionExpander)
+                        {
+                            if (!unselectedExpanders.Contains(itemFilter))
+                            {
+                                // If any of the associated expander is selected, the item should be included in the expanded list.
+                                return false;
+                            }
+
+                            associatedWithUnselectedExpander = true;
+                        }
+                    }
+
+                    // at this point, the item either:
+                    // 1. has no expander filter, therefore should be included
+                    // 2. or, all associated expanders are unselected, therefore should be excluded
+                    return associatedWithUnselectedExpander;
+                }
+            }
+
+            private static bool IsAfterDot(ITextSnapshot snapshot, ITrackingSpan applicableToSpan)
+            {
+                var position = applicableToSpan.GetStartPoint(snapshot).Position;
+                return position > 0 && snapshot[position - 1] == '.';
+            }
+
+            private (int selectedItemIndex, UpdateSelectionHint selectionHint, VSCompletionItem? uniqueItem)? HandleNormalFiltering(
+                Func<ImmutableArray<(RoslynCompletionItem, PatternMatch?)>, string, ImmutableArray<RoslynCompletionItem>> filterMethod,
+                string filterText,
+                CompletionFilterReason filterReason,
+                char typeChar,
+                List<MatchResult<VSCompletionItem>> itemsInList,
+                bool hasSuggestedItemOptions)
+            {
+                // Not deletion.  Defer to the language to decide which item it thinks best
+                // matches the text typed so far.
+
+                // Ask the language to determine which of the *matched* items it wants to select.
+                var matchingItems = itemsInList.Where(r => r.MatchedFilterText)
+                                               .SelectAsArray(t => (t.RoslynCompletionItem, t.PatternMatch));
+
+                var chosenItems = filterMethod(matchingItems, filterText);
+
+                int selectedItemIndex;
+                VSCompletionItem? uniqueItem = null;
+                MatchResult<VSCompletionItem> bestOrFirstMatchResult;
+
+                if (chosenItems.Length == 0)
+                {
+                    // We do not have matches: pick the one with longest common prefix or the first item from the list.
+                    selectedItemIndex = 0;
+                    bestOrFirstMatchResult = itemsInList[0];
+
+                    var longestCommonPrefixLength = bestOrFirstMatchResult.RoslynCompletionItem.FilterText.GetCaseInsensitivePrefixLength(filterText);
+
+                    for (var i = 1; i < itemsInList.Count; ++i)
+                    {
+                        var item = itemsInList[i];
+                        var commonPrefixLength = item.RoslynCompletionItem.FilterText.GetCaseInsensitivePrefixLength(filterText);
+
+                        if (commonPrefixLength > longestCommonPrefixLength)
+                        {
+                            selectedItemIndex = i;
+                            bestOrFirstMatchResult = item;
+                            longestCommonPrefixLength = commonPrefixLength;
+                        }
+                    }
+                }
+                else
+                {
+                    var recentItems = RecentItemsManager.RecentItems;
+
+                    // Of the items the service returned, pick the one most recently committed
+                    var bestItem = GetBestCompletionItemBasedOnMRU(chosenItems, recentItems);
+
+                    // Determine if we should consider this item 'unique' or not.  A unique item
+                    // will be automatically committed if the user hits the 'invoke completion' 
+                    // without bringing up the completion list.  An item is unique if it was the
+                    // only item to match the text typed so far, and there was at least some text
+                    // typed.  i.e.  if we have "Console.$$" we don't want to commit something
+                    // like "WriteLine" since no filter text has actually been provided.  However,
+                    // if "Console.WriteL$$" is typed, then we do want "WriteLine" to be committed.
+                    selectedItemIndex = itemsInList.IndexOf(i => Equals(i.RoslynCompletionItem, bestItem));
+                    bestOrFirstMatchResult = itemsInList[selectedItemIndex];
+                    var deduplicatedListCount = matchingItems.Count(r => !r.RoslynCompletionItem.IsPreferredItem());
+                    if (deduplicatedListCount == 1 &&
+                        filterText.Length > 0)
+                    {
+                        uniqueItem = itemsInList[selectedItemIndex].EditorCompletionItem;
+                    }
+                }
+
+                // Check that it is a filter symbol. We can be called for a non-filter symbol.
+                // If inserting a non-filter character (neither IsPotentialFilterCharacter, nor Helpers.IsFilterCharacter), we should dismiss completion  
+                // except cases where this is the first symbol typed for the completion session (string.IsNullOrEmpty(filterText) or string.Equals(filterText, typeChar.ToString(), StringComparison.OrdinalIgnoreCase)).
+                // In the latter case, we should keep the completion because it was confirmed just before in InitializeCompletion.
+                if (filterReason == CompletionFilterReason.Insertion &&
+                    !string.IsNullOrEmpty(filterText) &&
+                    !string.Equals(filterText, typeChar.ToString(), StringComparison.OrdinalIgnoreCase) &&
+                    !IsPotentialFilterCharacter(typeChar) &&
+                    !Helpers.IsFilterCharacter(bestOrFirstMatchResult.RoslynCompletionItem, typeChar, filterText))
+                {
+                    return null;
+                }
+
+                var isHardSelection = IsHardSelection(
+                    filterText, bestOrFirstMatchResult.RoslynCompletionItem, bestOrFirstMatchResult.MatchedFilterText, hasSuggestedItemOptions);
+
+                var updateSelectionHint = isHardSelection ? UpdateSelectionHint.Selected : UpdateSelectionHint.SoftSelected;
+
+                return (selectedItemIndex, updateSelectionHint, uniqueItem);
+            }
+
+            private static (int selectedItemIndex, UpdateSelectionHint selectionHint, VSCompletionItem? uniqueItem)? HandleDeletionTrigger(
+                CompletionTriggerReason filterTriggerKind,
+                List<MatchResult<VSCompletionItem>> matchResults,
+                string filterText,
+                bool hasSuggestedItemOptions)
+            {
+                var matchingItems = matchResults.Where(r => r.MatchedFilterText);
+                if (filterTriggerKind == CompletionTriggerReason.Insertion &&
+                    !matchingItems.Any())
+                {
+                    // The user has typed something, but nothing in the actual list matched what
+                    // they were typing.  In this case, we want to dismiss completion entirely.
+                    // The thought process is as follows: we aggressively brought up completion
+                    // to help them when they typed delete (in case they wanted to pick another
+                    // item).  However, they're typing something that doesn't seem to match at all
+                    // The completion list is just distracting at this point.
+                    return null;
+                }
+
+                MatchResult<VSCompletionItem>? bestMatchResult = null;
+                var moreThanOneMatchWithSamePriority = false;
+                foreach (var currentMatchResult in matchingItems)
+                {
+                    if (bestMatchResult == null)
+                    {
+                        // We had no best result yet, so this is now our best result.
+                        bestMatchResult = currentMatchResult;
+                    }
+                    else
+                    {
+                        var match = currentMatchResult.CompareTo(bestMatchResult.Value, filterText);
+                        if (match > 0)
+                        {
+                            moreThanOneMatchWithSamePriority = false;
+                            bestMatchResult = currentMatchResult;
+                        }
+                        else if (match == 0)
+                        {
+                            moreThanOneMatchWithSamePriority = true;
+                        }
+                    }
+                }
+
+                int index;
+                bool hardSelect;
+
+                // If we had a matching item, then pick the best of the matching items and
+                // choose that one to be hard selected.  If we had no actual matching items
+                // (which can happen if the user deletes down to a single character and we
+                // include everything), then we just soft select the first item.
+                if (bestMatchResult != null)
+                {
+                    // Only hard select this result if it's a prefix match
+                    // We need to do this so that
+                    // * deleting and retyping a dot in a member access does not change the
+                    //   text that originally appeared before the dot
+                    // * deleting through a word from the end keeps that word selected
+                    // This also preserves the behavior the VB had through Dev12.
+                    hardSelect = !hasSuggestedItemOptions && bestMatchResult.Value.EditorCompletionItem.FilterText.StartsWith(filterText, StringComparison.CurrentCultureIgnoreCase);
+                    index = matchResults.IndexOf(bestMatchResult.Value);
+                }
+                else
+                {
+                    index = 0;
+                    hardSelect = false;
+                }
+
+                return (index,
+                    hardSelect ? UpdateSelectionHint.Selected : UpdateSelectionHint.SoftSelected,
+                    moreThanOneMatchWithSamePriority ? null : bestMatchResult.GetValueOrDefault().EditorCompletionItem);
+            }
+
+            private static ImmutableArray<CompletionItemWithHighlight> GetHighlightedList(
+                List<MatchResult<VSCompletionItem>> matchResults,
+                string filterText,
+                bool highlightMatchingPortions,
+                CompletionHelper completionHelper)
+            {
+                return matchResults.SelectAsArray(matchResult =>
+                {
+                    var highlightedSpans = GetHighlightedSpans(matchResult, completionHelper, filterText, highlightMatchingPortions);
+                    return new CompletionItemWithHighlight(matchResult.EditorCompletionItem, highlightedSpans);
+                });
+
+                static ImmutableArray<Span> GetHighlightedSpans(
+                    MatchResult<VSCompletionItem> matchResult,
+                    CompletionHelper completionHelper,
+                    string filterText,
+                    bool highlightMatchingPortions)
+                {
+                    if (highlightMatchingPortions)
+                    {
+                        if (matchResult.RoslynCompletionItem.HasDifferentFilterText)
+                        {
+                            // The PatternMatch in MatchResult is calculated based on Roslyn item's FilterText, 
+                            // which can be used to calculate highlighted span for VSCompletion item's DisplayText w/o doing the matching again.
+                            // However, if the Roslyn item's FilterText is different from its DisplayText,
+                            // we need to do the match against the display text of the VS item directly to get the highlighted spans.
+                            return completionHelper.GetHighlightedSpans(
+                                matchResult.EditorCompletionItem.DisplayText, filterText, CultureInfo.CurrentCulture).SelectAsArray(s => s.ToSpan());
+                        }
+
+                        var patternMatch = matchResult.PatternMatch;
+                        if (patternMatch.HasValue)
+                        {
+                            // Since VS item's display text is created as Prefix + DisplayText + Suffix, 
+                            // we can calculate the highlighted span by adding an offset that is the length of the Prefix.
+                            return patternMatch.Value.MatchedSpans.SelectAsArray(s_highlightSpanGetter, matchResult.RoslynCompletionItem);
+                        }
+                    }
+
+                    // If there's no match for Roslyn item's filter text which is identical to its display text,
+                    // then we can safely assume there'd be no matching to VS item's display text.
+                    return ImmutableArray<Span>.Empty;
+                }
+            }
+
+            private static FilteredCompletionModel? HandleAllItemsFilteredOut(
+                CompletionTriggerReason triggerReason,
+                ImmutableArray<CompletionFilterWithState> filters,
+                CompletionRules completionRules)
+            {
+                if (triggerReason == CompletionTriggerReason.Insertion)
+                {
+                    // If the user was just typing, and the list went to empty *and* this is a 
+                    // language that wants to dismiss on empty, then just return a null model
+                    // to stop the completion session.
+                    if (completionRules.DismissIfEmpty)
+                    {
+                        return null;
+                    }
+                }
+
+                // If the user has turned on some filtering states, and we filtered down to
+                // nothing, then we do want the UI to show that to them.  That way the user
+                // can turn off filters they don't want and get the right set of items.
+
+                // If we are going to filter everything out, then just preserve the existing
+                // model (and all the previously filtered items), but switch over to soft
+                // selection.
+                var selection = UpdateSelectionHint.SoftSelected;
+
+                return new FilteredCompletionModel(
+                    ImmutableArray<CompletionItemWithHighlight>.Empty, selectedItemIndex: 0,
+                    filters, selection, centerSelection: true, uniqueItem: null);
+            }
+
+            private static ImmutableArray<CompletionFilterWithState> GetUpdatedFilters(
+                List<MatchResult<VSCompletionItem>> filteredList,
+                ImmutableArray<CompletionFilterWithState> filters)
+            {
+                // See which filters might be enabled based on the typed code
+                using var _ = PooledHashSet<CompletionFilter>.GetInstance(out var textFilteredFilters);
+                textFilteredFilters.AddRange(filteredList.SelectMany(n => n.EditorCompletionItem.Filters));
+
+                // When no items are available for a given filter, it becomes unavailable.
+                // Expanders always appear available as long as it's presented.
+                return filters.SelectAsArray(n => n.WithAvailability(n.Filter is CompletionExpander ? true : textFilteredFilters.Contains(n.Filter)));
+            }
+
+            /// <summary>
+            /// Given multiple possible chosen completion items, pick the one that has the
+            /// best MRU index, or the one with highest MatchPriority if none in MRU.
+            /// </summary>
+            private static RoslynCompletionItem GetBestCompletionItemBasedOnMRU(
+                ImmutableArray<RoslynCompletionItem> chosenItems, ImmutableArray<string> recentItems)
+            {
+                Debug.Assert(chosenItems.Length > 0);
+
+                // Try to find the chosen item has been most recently used.
+                var bestItem = chosenItems[0];
+                for (int i = 1, n = chosenItems.Length; i < n; i++)
+                {
+                    var chosenItem = chosenItems[i];
+                    var mruIndex1 = GetRecentItemIndex(recentItems, bestItem);
+                    var mruIndex2 = GetRecentItemIndex(recentItems, chosenItem);
+
+                    if ((mruIndex2 < mruIndex1) ||
+                        (mruIndex2 == mruIndex1 && !bestItem.IsPreferredItem() && chosenItem.IsPreferredItem()))
+                    {
+                        bestItem = chosenItem;
+                    }
+                }
+
+                // If our best item appeared in the MRU list, use it
+                if (GetRecentItemIndex(recentItems, bestItem) <= 0)
+                {
+                    return bestItem;
+                }
+
+                // Otherwise use the chosen item that has the highest
+                // matchPriority.
+                for (int i = 1, n = chosenItems.Length; i < n; i++)
+                {
+                    var chosenItem = chosenItems[i];
+                    var bestItemPriority = bestItem.Rules.MatchPriority;
+                    var currentItemPriority = chosenItem.Rules.MatchPriority;
+
+                    if ((currentItemPriority > bestItemPriority) ||
+                        ((currentItemPriority == bestItemPriority) && !bestItem.IsPreferredItem() && chosenItem.IsPreferredItem()))
+                    {
+                        bestItem = chosenItem;
+                    }
+                }
+
+                return bestItem;
+            }
+
+            private static int GetRecentItemIndex(ImmutableArray<string> recentItems, RoslynCompletionItem item)
+            {
+                var index = recentItems.IndexOf(item.FilterText);
+                return -index;
+            }
+
+            private static bool TryCreateMatchResult(
+                CompletionHelper completionHelper,
+                VSCompletionItem item,
+                string filterText,
+                CompletionTriggerKind initialTriggerKind,
+                CompletionFilterReason filterReason,
+                ImmutableArray<string> recentItems,
+                bool highlightMatchingPortions,
+                int currentIndex,
+                out MatchResult<VSCompletionItem> matchResult)
+            {
+                var roslynItem = GetOrAddRoslynCompletionItem(item);
+                return CompletionHelper.TryCreateMatchResult(completionHelper, roslynItem, item, filterText, initialTriggerKind, filterReason, recentItems, highlightMatchingPortions, currentIndex, out matchResult);
+            }
+
+            // PERF: Create a singleton to avoid lambda allocation on hot path
+            private static readonly Func<TextSpan, RoslynCompletionItem, Span> s_highlightSpanGetter
+                = (span, item) => span.MoveTo(item.DisplayTextPrefix?.Length ?? 0).ToSpan();
+
+            private static bool IsHardSelection(
+                string filterText,
+                RoslynCompletionItem item,
+                bool matchedFilterText,
+                bool useSuggestionMode)
+            {
+                if (item == null || useSuggestionMode)
+                {
+                    return false;
+                }
+
+                // We don't have a builder and we have a best match.  Normally this will be hard
+                // selected, except for a few cases.  Specifically, if no filter text has been
+                // provided, and this is not a preselect match then we will soft select it.  This
+                // happens when the completion list comes up implicitly and there is something in
+                // the MRU list.  In this case we do want to select it, but not with a hard
+                // selection.  Otherwise you can end up with the following problem:
+                //
+                //  dim i as integer =<space>
+                //
+                // Completion will comes up after = with 'integer' selected (Because of MRU).  We do
+                // not want 'space' to commit this.
+
+                // If all that has been typed is punctuation, then don't hard select anything.
+                // It's possible the user is just typing language punctuation and selecting
+                // anything in the list will interfere.  We only allow this if the filter text
+                // exactly matches something in the list already. 
+                if (filterText.Length > 0 && IsAllPunctuation(filterText) && filterText != item.DisplayText)
+                {
+                    return false;
+                }
+
+                // If the user hasn't actually typed anything, then don't hard select any item.
+                // The only exception to this is if the completion provider has requested the
+                // item be preselected.
+                if (filterText.Length == 0)
+                {
+                    // Item didn't want to be hard selected with no filter text.
+                    // So definitely soft select it.
+                    if (item.Rules.SelectionBehavior != CompletionItemSelectionBehavior.HardSelection)
+                    {
+                        return false;
+                    }
+
+                    // Item did not ask to be preselected.  So definitely soft select it.
+                    if (item.Rules.MatchPriority == MatchPriority.Default)
+                    {
+                        return false;
+                    }
+                }
+
+                // The user typed something, or the item asked to be preselected.  In 
+                // either case, don't soft select this.
+                Debug.Assert(filterText.Length > 0 || item.Rules.MatchPriority != MatchPriority.Default);
+
+                // If the user moved the caret left after they started typing, the 'best' match may not match at all
+                // against the full text span that this item would be replacing.
+                if (!matchedFilterText)
+                {
+                    return false;
+                }
+
+                // There was either filter text, or this was a preselect match.  In either case, we
+                // can hard select this.
+                return true;
+            }
+
+            private static bool IsAllPunctuation(string filterText)
+            {
+                foreach (var ch in filterText)
+                {
+                    if (!char.IsPunctuation(ch))
+                    {
+                        return false;
+                    }
+                }
+
+                return true;
+            }
+
+            /// <summary>
+            /// A potential filter character is something that can filter a completion lists and is
+            /// *guaranteed* to not be a commit character.
+            /// </summary>
+            private static bool IsPotentialFilterCharacter(char c)
+            {
+                // TODO(cyrusn): Actually use the right Unicode categories here.
+                return char.IsLetter(c)
+                    || char.IsNumber(c)
+                    || c == '_';
+            }
+
+            private static int GetAggressiveDefaultsMatch(List<MatchResult<VSCompletionItem>> itemsWithMatch, ImmutableArray<string> defaults)
+            {
+                Debug.Assert(!defaults.IsDefaultOrEmpty);
+
+                foreach (var defaultText in defaults)
+                {
+                    for (var i = 0; (i < itemsWithMatch.Count); ++i)
+                    {
+                        var itemWithMatch = itemsWithMatch[i];
+                        if (itemWithMatch.RoslynCompletionItem.FilterText == defaultText)
+                        {
+                            if (itemWithMatch.PatternMatch == null || itemWithMatch.PatternMatch.Value.Kind <= PatternMatchKind.Prefix)
+                                return i;
+
+                            break;
+                        }
+                    }
+                }
+
+                return -1;
+            }
+
+            private static int GetDefaultsMatch(
+                string filterText,
+                List<MatchResult<VSCompletionItem>> itemsWithMatch,
+                int selectedIndex,
+                ImmutableArray<string> defaults)
+            {
+                Debug.Assert(!defaults.IsDefaultOrEmpty);
+
+                int inferiorItemIndex;
+                if (filterText.Length == 0)
+                {
+                    // Without filterText, all items are eually good match, so we have to consider all of them.
+                    inferiorItemIndex = itemsWithMatch.Count;
+                }
+                else
+                {
+                    // Because the items are sorted based on pattern-matching score, the selectedIndex is in the middle of a range of
+                    // -- as far as the pattern matcher is concerned -- equivalent items. Find the last items in the range and use that
+                    // to limit the items searched for from the defaults list.          
+                    var selectedItemMatch = itemsWithMatch[selectedIndex].PatternMatch;
+
+                    if (!selectedItemMatch.HasValue)
+                        return -1;
+
+                    inferiorItemIndex = selectedIndex;
+                    while (++inferiorItemIndex < itemsWithMatch.Count)
+                    {
+                        // Ignore the case when trying to match the filter text with defaults.
+                        // e.g. a default "Console" would be a match for filter text "c" and therefore to be selected,
+                        // even if the CompletionService returns item "char" which is a case-sensitive prefix match.
+                        var itemMatch = itemsWithMatch[inferiorItemIndex].PatternMatch;
+                        if (!itemMatch.HasValue || itemMatch.Value.Kind != selectedItemMatch.Value.Kind)
+                            break;
+                    }
+                }
+
+                foreach (var defaultText in defaults)
+                {
+                    for (var i = 0; i < inferiorItemIndex; ++i)
+                    {
+                        if (itemsWithMatch[i].RoslynCompletionItem.FilterText == defaultText)
+                            return i;
+                    }
+                }
+
+                return -1;
+            }
+
+        }
+    }
+}
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
index 93e001d132f61..92755c576cf03 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
@@ -2,52 +2,28 @@
 // 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;
-using System.Globalization;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Completion;
 using Microsoft.CodeAnalysis.Options;
-using Microsoft.CodeAnalysis.PatternMatching;
-using Microsoft.CodeAnalysis.PooledObjects;
-using Microsoft.CodeAnalysis.Shared.Extensions;
-using Microsoft.CodeAnalysis.Text;
-using Microsoft.CodeAnalysis.Text.Shared.Extensions;
 using Microsoft.VisualStudio.Language.Intellisense.AsyncCompletion;
 using Microsoft.VisualStudio.Language.Intellisense.AsyncCompletion.Data;
-using Microsoft.VisualStudio.Text;
 using Roslyn.Utilities;
 using RoslynCompletionItem = Microsoft.CodeAnalysis.Completion.CompletionItem;
 using VSCompletionItem = Microsoft.VisualStudio.Language.Intellisense.AsyncCompletion.Data.CompletionItem;
 
 namespace Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.AsyncCompletion
 {
-    internal class ItemManager : IAsyncCompletionItemManager
+    internal partial class ItemManager : IAsyncCompletionItemManager
     {
-        /// <summary>
-        /// Used for filtering non-Roslyn data only. 
-        /// </summary>
-        private readonly CompletionHelper _defaultCompletionHelper;
-
         private readonly RecentItemsManager _recentItemsManager;
         private readonly IGlobalOptionService _globalOptions;
-
         public const string AggressiveDefaultsMatchingOptionName = "AggressiveDefaultsMatchingOption";
 
-        /// <summary>
-        /// For telemetry.
-        /// </summary>
-        private readonly object _targetTypeCompletionFilterChosenMarker = new();
-
         internal ItemManager(RecentItemsManager recentItemsManager, IGlobalOptionService globalOptions)
         {
-            // Let us make the completion Helper used for non-Roslyn items case-sensitive.
-            // We can change this if get requests from partner teams.
-            _defaultCompletionHelper = new CompletionHelper(isCaseSensitive: true);
             _recentItemsManager = recentItemsManager;
             _globalOptions = globalOptions;
         }
@@ -82,581 +58,9 @@ public Task<ImmutableArray<VSCompletionItem>> SortCompletionListAsync(
             IAsyncCompletionSession session,
             AsyncCompletionSessionDataSnapshot data,
             CancellationToken cancellationToken)
-            => Task.FromResult(UpdateCompletionList(session, data, cancellationToken));
-
-        // We might need to handle large amount of items with import completion enabled,
-        // so use a dedicated pool to minimize/avoid array allocations (especially in LOH)
-        // Set the size of pool to 1 because we don't expect UpdateCompletionListAsync to be
-        // called concurrently, which essentially makes the pooled list a singleton,
-        // but we still use ObjectPool for concurrency handling just to be robust.
-        private static readonly ObjectPool<List<MatchResult<VSCompletionItem>>> s_listOfMatchResultPool
-                = new(factory: () => new(), size: 1);
-
-        private FilteredCompletionModel? UpdateCompletionList(
-            IAsyncCompletionSession session,
-            AsyncCompletionSessionDataSnapshot data,
-            CancellationToken cancellationToken)
-        {
-            if (!session.Properties.TryGetProperty(CompletionSource.HasSuggestionItemOptions, out bool hasSuggestedItemOptions))
-            {
-                // This is the scenario when the session is created out of Roslyn, in some other provider, e.g. in Debugger.
-                // For now, the default hasSuggestedItemOptions is false.
-                hasSuggestedItemOptions = false;
-            }
-
-            hasSuggestedItemOptions |= data.DisplaySuggestionItem;
-
-            var filterText = session.ApplicableToSpan.GetText(data.Snapshot);
-            var reason = data.Trigger.Reason;
-            var initialRoslynTriggerKind = Helpers.GetRoslynTriggerKind(data.InitialTrigger);
-
-            // Check if the user is typing a number. If so, only proceed if it's a number
-            // directly after a <dot>. That's because it is actually reasonable for completion
-            // to be brought up after a <dot> and for the user to want to filter completion
-            // items based on a number that exists in the name of the item. However, when
-            // we are not after a dot (i.e. we're being brought up after <space> is typed)
-            // then we don't want to filter things. Consider the user writing:
-            //
-            //      dim i =<space>
-            //
-            // We'll bring up the completion list here (as VB has completion on <space>).
-            // If the user then types '3', we don't want to match against Int32.
-            if (filterText.Length > 0 && char.IsNumber(filterText[0]))
-            {
-                if (!IsAfterDot(data.Snapshot, session.ApplicableToSpan))
-                {
-                    // Dismiss the session.
-                    return null;
-                }
-            }
-
-            // We need to filter if 
-            // 1. a non-empty strict subset of filters are selected
-            // 2. a non-empty set of expanders are unselected
-            var nonExpanderFilterStates = data.SelectedFilters.WhereAsArray(f => f.Filter is not CompletionExpander);
-
-            var selectedNonExpanderFilters = nonExpanderFilterStates.SelectAsArray(f => f.IsSelected, f => f.Filter);
-            var needToFilter = selectedNonExpanderFilters.Length > 0 && selectedNonExpanderFilters.Length < nonExpanderFilterStates.Length;
-
-            var unselectedExpanders = data.SelectedFilters.SelectAsArray(f => !f.IsSelected && f.Filter is CompletionExpander, f => f.Filter);
-            var needToFilterExpanded = unselectedExpanders.Length > 0;
-
-            if (session.TextView.Properties.TryGetProperty(CompletionSource.TargetTypeFilterExperimentEnabled, out bool isExperimentEnabled) && isExperimentEnabled)
-            {
-                // Telemetry: Want to know % of sessions with the "Target type matches" filter where that filter is actually enabled
-                if (needToFilter &&
-                    !session.Properties.ContainsProperty(_targetTypeCompletionFilterChosenMarker) &&
-                    selectedNonExpanderFilters.Any(f => f.DisplayText == FeaturesResources.Target_type_matches))
-                {
-                    AsyncCompletionLogger.LogTargetTypeFilterChosenInSession();
-
-                    // Make sure we only record one enabling of the filter per session
-                    session.Properties.AddProperty(_targetTypeCompletionFilterChosenMarker, _targetTypeCompletionFilterChosenMarker);
-                }
-            }
-
-            var filterReason = Helpers.GetFilterReason(data.Trigger);
-
-            // We prefer using the original snapshot, which should always be available from items provided by Roslyn's CompletionSource.
-            // Only use data.Snapshot in the theoretically possible but rare case when all items we are handling are from some non-Roslyn CompletionSource.
-            var snapshotForDocument = TryGetInitialTriggerLocation(data, out var intialTriggerLocation)
-                ? intialTriggerLocation.Snapshot
-                : data.Snapshot;
-
-            var document = snapshotForDocument?.TextBuffer.AsTextContainer().GetOpenDocumentInCurrentContext();
-            var completionService = document?.GetLanguageService<CompletionService>();
-            var completionRules = completionService?.GetRules(CompletionOptions.From(document!.Project)) ?? CompletionRules.Default;
-            var completionHelper = document != null ? CompletionHelper.GetHelper(document) : _defaultCompletionHelper;
-
-            // DismissIfLastCharacterDeleted should be applied only when started with Insertion, and then Deleted all characters typed.
-            // This conforms with the original VS 2010 behavior.
-            if (initialRoslynTriggerKind == CompletionTriggerKind.Insertion &&
-                data.Trigger.Reason == CompletionTriggerReason.Backspace &&
-                completionRules.DismissIfLastCharacterDeleted &&
-                session.ApplicableToSpan.GetText(data.Snapshot).Length == 0)
-            {
-                // Dismiss the session
-                return null;
-            }
-
-            var highlightMatchingPortions = _globalOptions.GetOption(CompletionViewOptions.HighlightMatchingPortionsOfCompletionListItems, document?.Project.Language);
-            // Nothing to highlight if user hasn't typed anything yet.
-            highlightMatchingPortions = highlightMatchingPortions && filterText.Length > 0;
-
-            // Use a monotonically increasing integer to keep track the original alphabetical order of each item.
-            var currentIndex = 0;
-
-            var initialListOfItemsToBeIncluded = s_listOfMatchResultPool.Allocate();
-            try
-            {
-                // Filter items based on the selected filters and matching.
-                foreach (var item in data.InitialSortedList)
-                {
-                    cancellationToken.ThrowIfCancellationRequested();
-
-                    if (needToFilter && ShouldBeFilteredOutOfCompletionList(item, selectedNonExpanderFilters))
-                    {
-                        continue;
-                    }
-
-                    if (needToFilterExpanded && ShouldBeFilteredOutOfExpandedCompletionList(item, unselectedExpanders))
-                    {
-                        continue;
-                    }
-
-                    if (TryCreateMatchResult(
-                        completionHelper,
-                        item,
-                        filterText,
-                        initialRoslynTriggerKind,
-                        filterReason,
-                        _recentItemsManager.RecentItems,
-                        highlightMatchingPortions: highlightMatchingPortions,
-                        currentIndex,
-                        out var matchResult))
-                    {
-                        initialListOfItemsToBeIncluded.Add(matchResult);
-                        currentIndex++;
-                    }
-                }
-
-                if (initialListOfItemsToBeIncluded.Count == 0)
-                {
-                    return HandleAllItemsFilteredOut(reason, data.SelectedFilters, completionRules);
-                }
-
-                // Sort the items by pattern matching results.
-                // Note that we want to preserve the original alphabetical order for items with same pattern match score,
-                // but `List<T>.Sort` isn't stable. Therefore we have to add a monotonically increasing integer
-                // to `MatchResult` to achieve this.
-                initialListOfItemsToBeIncluded.Sort(MatchResult<VSCompletionItem>.SortingComparer);
-
-                var filteringResult = initialRoslynTriggerKind == CompletionTriggerKind.Deletion
-                        ? HandleDeletionTrigger(reason, initialListOfItemsToBeIncluded, filterText, hasSuggestedItemOptions)
-                        : HandleNormalFiltering(GetFilterMethod(), filterText, filterReason, data.Trigger.Character, initialListOfItemsToBeIncluded, hasSuggestedItemOptions);
-
-                if (!filteringResult.HasValue)
-                    return null;
-
-                var (selectedItemIndex, selectionHint, uniqueItem) = filteringResult.Value;
-
-                // Editor is providing us a list of "default" items to consider for selection.
-                if (!data.Defaults.IsDefaultOrEmpty)
-                {
-                    var tick = Environment.TickCount;
-
-                    var selectedItem = initialListOfItemsToBeIncluded[selectedItemIndex].RoslynCompletionItem;
-
-                    // "Preselect" is only used when we have high confidence with the selection, so don't override it.
-                    if (selectedItem.Rules.MatchPriority < MatchPriority.Preselect)
-                    {
-                        int defaultsMatchingIndex;
-                        var useAggressiveDefaultsMatching = session.TextView.Options.GetOptionValue<bool>(AggressiveDefaultsMatchingOptionName);
-
-                        if (useAggressiveDefaultsMatching)
-                        {
-                            defaultsMatchingIndex = GetAggressiveDefaultsMatch(initialListOfItemsToBeIncluded, data.Defaults);
-                            if (!hasSuggestedItemOptions && defaultsMatchingIndex >= 0)
-                                selectionHint = UpdateSelectionHint.Selected;
-                        }
-                        else
-                        {
-                            defaultsMatchingIndex = GetDefaultsMatch(filterText, initialListOfItemsToBeIncluded, selectedItemIndex, data.Defaults);
-                        }
-
-                        if (defaultsMatchingIndex >= 0)
-                        {
-                            selectedItemIndex = defaultsMatchingIndex;
-                        }
-                    }
-
-                    AsyncCompletionLogger.LogGetDefaultsMatchTicksDataPoint(Environment.TickCount - tick);
-                }
-
-                var showCompletionItemFilters = _globalOptions.GetOption(CompletionViewOptions.ShowCompletionItemFilters, document?.Project.Language);
-                var updatedFilters = showCompletionItemFilters
-                    ? GetUpdatedFilters(initialListOfItemsToBeIncluded, data.SelectedFilters)
-                    : ImmutableArray<CompletionFilterWithState>.Empty;
-
-                return new FilteredCompletionModel(
-                    items: GetHighlightedList(initialListOfItemsToBeIncluded, filterText, highlightMatchingPortions, completionHelper),
-                    selectedItemIndex,
-                    updatedFilters,
-                    selectionHint,
-                    centerSelection: true,
-                    uniqueItem);
-            }
-            finally
-            {
-                // Don't call ClearAndFree, which resets the capacity to a default value.
-                initialListOfItemsToBeIncluded.Clear();
-                s_listOfMatchResultPool.Free(initialListOfItemsToBeIncluded);
-            }
-
-            Func<ImmutableArray<(RoslynCompletionItem, PatternMatch?)>, string, ImmutableArray<RoslynCompletionItem>> GetFilterMethod()
-            {
-                if (completionService == null)
-                {
-                    return (itemsWithPatternMatches, text) => CompletionService.FilterItems(completionHelper, itemsWithPatternMatches, text);
-                }
-                else
-                {
-                    Contract.ThrowIfNull(document);
-                    return (itemsWithPatternMatches, text) => completionService.FilterItems(document, itemsWithPatternMatches, text);
-                }
-            }
-
-            static bool TryGetInitialTriggerLocation(AsyncCompletionSessionDataSnapshot data, out SnapshotPoint intialTriggerLocation)
-            {
-                var firstItem = data.InitialSortedList.FirstOrDefault(static item => item.Properties.ContainsProperty(CompletionSource.TriggerLocation));
-                if (firstItem != null)
-                {
-                    return firstItem.Properties.TryGetProperty(CompletionSource.TriggerLocation, out intialTriggerLocation);
-                }
-
-                intialTriggerLocation = default;
-                return false;
-            }
-
-            static bool ShouldBeFilteredOutOfCompletionList(VSCompletionItem item, ImmutableArray<CompletionFilter> activeNonExpanderFilters)
-            {
-                if (item.Filters.Any(filter => activeNonExpanderFilters.Contains(filter)))
-                {
-                    return false;
-                }
-
-                return true;
-            }
-
-            static bool ShouldBeFilteredOutOfExpandedCompletionList(VSCompletionItem item, ImmutableArray<CompletionFilter> unselectedExpanders)
-            {
-                var associatedWithUnselectedExpander = false;
-                foreach (var itemFilter in item.Filters)
-                {
-                    if (itemFilter is CompletionExpander)
-                    {
-                        if (!unselectedExpanders.Contains(itemFilter))
-                        {
-                            // If any of the associated expander is selected, the item should be included in the expanded list.
-                            return false;
-                        }
-
-                        associatedWithUnselectedExpander = true;
-                    }
-                }
-
-                // at this point, the item either:
-                // 1. has no expander filter, therefore should be included
-                // 2. or, all associated expanders are unselected, therefore should be excluded
-                return associatedWithUnselectedExpander;
-            }
-        }
-
-        private static bool IsAfterDot(ITextSnapshot snapshot, ITrackingSpan applicableToSpan)
-        {
-            var position = applicableToSpan.GetStartPoint(snapshot).Position;
-            return position > 0 && snapshot[position - 1] == '.';
-        }
-
-        private (int selectedItemIndex, UpdateSelectionHint selcetionHint, VSCompletionItem? uniqueItem)? HandleNormalFiltering(
-            Func<ImmutableArray<(RoslynCompletionItem, PatternMatch?)>, string, ImmutableArray<RoslynCompletionItem>> filterMethod,
-            string filterText,
-            CompletionFilterReason filterReason,
-            char typeChar,
-            List<MatchResult<VSCompletionItem>> itemsInList,
-            bool hasSuggestedItemOptions)
         {
-            // Not deletion.  Defer to the language to decide which item it thinks best
-            // matches the text typed so far.
-
-            // Ask the language to determine which of the *matched* items it wants to select.
-            var matchingItems = itemsInList.Where(r => r.MatchedFilterText)
-                                           .SelectAsArray(t => (t.RoslynCompletionItem, t.PatternMatch));
-
-            var chosenItems = filterMethod(matchingItems, filterText);
-
-            int selectedItemIndex;
-            VSCompletionItem? uniqueItem = null;
-            MatchResult<VSCompletionItem> bestOrFirstMatchResult;
-
-            if (chosenItems.Length == 0)
-            {
-                // We do not have matches: pick the one with longest common prefix or the first item from the list.
-                selectedItemIndex = 0;
-                bestOrFirstMatchResult = itemsInList[0];
-
-                var longestCommonPrefixLength = bestOrFirstMatchResult.RoslynCompletionItem.FilterText.GetCaseInsensitivePrefixLength(filterText);
-
-                for (var i = 1; i < itemsInList.Count; ++i)
-                {
-                    var item = itemsInList[i];
-                    var commonPrefixLength = item.RoslynCompletionItem.FilterText.GetCaseInsensitivePrefixLength(filterText);
-
-                    if (commonPrefixLength > longestCommonPrefixLength)
-                    {
-                        selectedItemIndex = i;
-                        bestOrFirstMatchResult = item;
-                        longestCommonPrefixLength = commonPrefixLength;
-                    }
-                }
-            }
-            else
-            {
-                var recentItems = _recentItemsManager.RecentItems;
-
-                // Of the items the service returned, pick the one most recently committed
-                var bestItem = GetBestCompletionItemBasedOnMRU(chosenItems, recentItems);
-
-                // Determine if we should consider this item 'unique' or not.  A unique item
-                // will be automatically committed if the user hits the 'invoke completion' 
-                // without bringing up the completion list.  An item is unique if it was the
-                // only item to match the text typed so far, and there was at least some text
-                // typed.  i.e.  if we have "Console.$$" we don't want to commit something
-                // like "WriteLine" since no filter text has actually been provided.  However,
-                // if "Console.WriteL$$" is typed, then we do want "WriteLine" to be committed.
-                selectedItemIndex = itemsInList.IndexOf(i => Equals(i.RoslynCompletionItem, bestItem));
-                bestOrFirstMatchResult = itemsInList[selectedItemIndex];
-                var deduplicatedListCount = matchingItems.Count(r => !r.RoslynCompletionItem.IsPreferredItem());
-                if (deduplicatedListCount == 1 &&
-                    filterText.Length > 0)
-                {
-                    uniqueItem = itemsInList[selectedItemIndex].EditorCompletionItem;
-                }
-            }
-
-            // Check that it is a filter symbol. We can be called for a non-filter symbol.
-            // If inserting a non-filter character (neither IsPotentialFilterCharacter, nor Helpers.IsFilterCharacter), we should dismiss completion  
-            // except cases where this is the first symbol typed for the completion session (string.IsNullOrEmpty(filterText) or string.Equals(filterText, typeChar.ToString(), StringComparison.OrdinalIgnoreCase)).
-            // In the latter case, we should keep the completion because it was confirmed just before in InitializeCompletion.
-            if (filterReason == CompletionFilterReason.Insertion &&
-                !string.IsNullOrEmpty(filterText) &&
-                !string.Equals(filterText, typeChar.ToString(), StringComparison.OrdinalIgnoreCase) &&
-                !IsPotentialFilterCharacter(typeChar) &&
-                !Helpers.IsFilterCharacter(bestOrFirstMatchResult.RoslynCompletionItem, typeChar, filterText))
-            {
-                return null;
-            }
-
-            var isHardSelection = IsHardSelection(
-                filterText, bestOrFirstMatchResult.RoslynCompletionItem, bestOrFirstMatchResult.MatchedFilterText, hasSuggestedItemOptions);
-
-            var updateSelectionHint = isHardSelection ? UpdateSelectionHint.Selected : UpdateSelectionHint.SoftSelected;
-
-            return (selectedItemIndex, updateSelectionHint, uniqueItem);
-        }
-
-        private static (int selectedItemIndex, UpdateSelectionHint selcetionHint, VSCompletionItem? uniqueItem)? HandleDeletionTrigger(
-            CompletionTriggerReason filterTriggerKind,
-            List<MatchResult<VSCompletionItem>> matchResults,
-            string filterText,
-            bool hasSuggestedItemOptions)
-        {
-            var matchingItems = matchResults.Where(r => r.MatchedFilterText);
-            if (filterTriggerKind == CompletionTriggerReason.Insertion &&
-                !matchingItems.Any())
-            {
-                // The user has typed something, but nothing in the actual list matched what
-                // they were typing.  In this case, we want to dismiss completion entirely.
-                // The thought process is as follows: we aggressively brought up completion
-                // to help them when they typed delete (in case they wanted to pick another
-                // item).  However, they're typing something that doesn't seem to match at all
-                // The completion list is just distracting at this point.
-                return null;
-            }
-
-            MatchResult<VSCompletionItem>? bestMatchResult = null;
-            var moreThanOneMatchWithSamePriority = false;
-            foreach (var currentMatchResult in matchingItems)
-            {
-                if (bestMatchResult == null)
-                {
-                    // We had no best result yet, so this is now our best result.
-                    bestMatchResult = currentMatchResult;
-                }
-                else
-                {
-                    var match = currentMatchResult.CompareTo(bestMatchResult.Value, filterText);
-                    if (match > 0)
-                    {
-                        moreThanOneMatchWithSamePriority = false;
-                        bestMatchResult = currentMatchResult;
-                    }
-                    else if (match == 0)
-                    {
-                        moreThanOneMatchWithSamePriority = true;
-                    }
-                }
-            }
-
-            int index;
-            bool hardSelect;
-
-            // If we had a matching item, then pick the best of the matching items and
-            // choose that one to be hard selected.  If we had no actual matching items
-            // (which can happen if the user deletes down to a single character and we
-            // include everything), then we just soft select the first item.
-            if (bestMatchResult != null)
-            {
-                // Only hard select this result if it's a prefix match
-                // We need to do this so that
-                // * deleting and retyping a dot in a member access does not change the
-                //   text that originally appeared before the dot
-                // * deleting through a word from the end keeps that word selected
-                // This also preserves the behavior the VB had through Dev12.
-                hardSelect = !hasSuggestedItemOptions && bestMatchResult.Value.EditorCompletionItem.FilterText.StartsWith(filterText, StringComparison.CurrentCultureIgnoreCase);
-                index = matchResults.IndexOf(bestMatchResult.Value);
-            }
-            else
-            {
-                index = 0;
-                hardSelect = false;
-            }
-
-            return (index,
-                hardSelect ? UpdateSelectionHint.Selected : UpdateSelectionHint.SoftSelected,
-                moreThanOneMatchWithSamePriority ? null : bestMatchResult.GetValueOrDefault().EditorCompletionItem);
-        }
-
-        private static ImmutableArray<CompletionItemWithHighlight> GetHighlightedList(
-            List<MatchResult<VSCompletionItem>> matchResults,
-            string filterText,
-            bool highlightMatchingPortions,
-            CompletionHelper completionHelper)
-        {
-            return matchResults.SelectAsArray(matchResult =>
-            {
-                var highlightedSpans = GetHighlightedSpans(matchResult, completionHelper, filterText, highlightMatchingPortions);
-                return new CompletionItemWithHighlight(matchResult.EditorCompletionItem, highlightedSpans);
-            });
-
-            static ImmutableArray<Span> GetHighlightedSpans(
-                MatchResult<VSCompletionItem> matchResult,
-                CompletionHelper completionHelper,
-                string filterText,
-                bool highlightMatchingPortions)
-            {
-                if (highlightMatchingPortions)
-                {
-                    if (matchResult.RoslynCompletionItem.HasDifferentFilterText)
-                    {
-                        // The PatternMatch in MatchResult is calculated based on Roslyn item's FilterText, 
-                        // which can be used to calculate highlighted span for VSCompletion item's DisplayText w/o doing the matching again.
-                        // However, if the Roslyn item's FilterText is different from its DisplayText,
-                        // we need to do the match against the display text of the VS item directly to get the highlighted spans.
-                        return completionHelper.GetHighlightedSpans(
-                            matchResult.EditorCompletionItem.DisplayText, filterText, CultureInfo.CurrentCulture).SelectAsArray(s => s.ToSpan());
-                    }
-
-                    var patternMatch = matchResult.PatternMatch;
-                    if (patternMatch.HasValue)
-                    {
-                        // Since VS item's display text is created as Prefix + DisplayText + Suffix, 
-                        // we can calculate the highlighted span by adding an offset that is the length of the Prefix.
-                        return patternMatch.Value.MatchedSpans.SelectAsArray(s_highlightSpanGetter, matchResult.RoslynCompletionItem);
-                    }
-                }
-
-                // If there's no match for Roslyn item's filter text which is identical to its display text,
-                // then we can safely assume there'd be no matching to VS item's display text.
-                return ImmutableArray<Span>.Empty;
-            }
-        }
-
-        private static FilteredCompletionModel? HandleAllItemsFilteredOut(
-            CompletionTriggerReason triggerReason,
-            ImmutableArray<CompletionFilterWithState> filters,
-            CompletionRules completionRules)
-        {
-            if (triggerReason == CompletionTriggerReason.Insertion)
-            {
-                // If the user was just typing, and the list went to empty *and* this is a 
-                // language that wants to dismiss on empty, then just return a null model
-                // to stop the completion session.
-                if (completionRules.DismissIfEmpty)
-                {
-                    return null;
-                }
-            }
-
-            // If the user has turned on some filtering states, and we filtered down to
-            // nothing, then we do want the UI to show that to them.  That way the user
-            // can turn off filters they don't want and get the right set of items.
-
-            // If we are going to filter everything out, then just preserve the existing
-            // model (and all the previously filtered items), but switch over to soft
-            // selection.
-            var selection = UpdateSelectionHint.SoftSelected;
-
-            return new FilteredCompletionModel(
-                ImmutableArray<CompletionItemWithHighlight>.Empty, selectedItemIndex: 0,
-                filters, selection, centerSelection: true, uniqueItem: null);
-        }
-
-        private static ImmutableArray<CompletionFilterWithState> GetUpdatedFilters(
-            List<MatchResult<VSCompletionItem>> filteredList,
-            ImmutableArray<CompletionFilterWithState> filters)
-        {
-            // See which filters might be enabled based on the typed code
-            using var _ = PooledHashSet<CompletionFilter>.GetInstance(out var textFilteredFilters);
-            textFilteredFilters.AddRange(filteredList.SelectMany(n => n.EditorCompletionItem.Filters));
-
-            // When no items are available for a given filter, it becomes unavailable.
-            // Expanders always appear available as long as it's presented.
-            return filters.SelectAsArray(n => n.WithAvailability(n.Filter is CompletionExpander ? true : textFilteredFilters.Contains(n.Filter)));
-        }
-
-        /// <summary>
-        /// Given multiple possible chosen completion items, pick the one that has the
-        /// best MRU index, or the one with highest MatchPriority if none in MRU.
-        /// </summary>
-        private static RoslynCompletionItem GetBestCompletionItemBasedOnMRU(
-            ImmutableArray<RoslynCompletionItem> chosenItems, ImmutableArray<string> recentItems)
-        {
-            Debug.Assert(chosenItems.Length > 0);
-
-            // Try to find the chosen item has been most recently used.
-            var bestItem = chosenItems[0];
-            for (int i = 1, n = chosenItems.Length; i < n; i++)
-            {
-                var chosenItem = chosenItems[i];
-                var mruIndex1 = GetRecentItemIndex(recentItems, bestItem);
-                var mruIndex2 = GetRecentItemIndex(recentItems, chosenItem);
-
-                if ((mruIndex2 < mruIndex1) ||
-                    (mruIndex2 == mruIndex1 && !bestItem.IsPreferredItem() && chosenItem.IsPreferredItem()))
-                {
-                    bestItem = chosenItem;
-                }
-            }
-
-            // If our best item appeared in the MRU list, use it
-            if (GetRecentItemIndex(recentItems, bestItem) <= 0)
-            {
-                return bestItem;
-            }
-
-            // Otherwise use the chosen item that has the highest
-            // matchPriority.
-            for (int i = 1, n = chosenItems.Length; i < n; i++)
-            {
-                var chosenItem = chosenItems[i];
-                var bestItemPriority = bestItem.Rules.MatchPriority;
-                var currentItemPriority = chosenItem.Rules.MatchPriority;
-
-                if ((currentItemPriority > bestItemPriority) ||
-                    ((currentItemPriority == bestItemPriority) && !bestItem.IsPreferredItem() && chosenItem.IsPreferredItem()))
-                {
-                    bestItem = chosenItem;
-                }
-            }
-
-            return bestItem;
-        }
-
-        private static int GetRecentItemIndex(ImmutableArray<string> recentItems, RoslynCompletionItem item)
-        {
-            var index = recentItems.IndexOf(item.FilterText);
-            return -index;
+            var updater = new CompletionListUpdater(session, data, _recentItemsManager, _globalOptions, cancellationToken);
+            return Task.FromResult(updater.UpdateCompletionList());
         }
 
         private static RoslynCompletionItem GetOrAddRoslynCompletionItem(VSCompletionItem vsItem)
@@ -674,186 +78,5 @@ private static RoslynCompletionItem GetOrAddRoslynCompletionItem(VSCompletionIte
 
             return roslynItem;
         }
-
-        private static bool TryCreateMatchResult(
-            CompletionHelper completionHelper,
-            VSCompletionItem item,
-            string filterText,
-            CompletionTriggerKind initialTriggerKind,
-            CompletionFilterReason filterReason,
-            ImmutableArray<string> recentItems,
-            bool highlightMatchingPortions,
-            int currentIndex,
-            out MatchResult<VSCompletionItem> matchResult)
-        {
-            var roslynItem = GetOrAddRoslynCompletionItem(item);
-            return CompletionHelper.TryCreateMatchResult(completionHelper, roslynItem, item, filterText, initialTriggerKind, filterReason, recentItems, highlightMatchingPortions, currentIndex, out matchResult);
-        }
-
-        // PERF: Create a singleton to avoid lambda allocation on hot path
-        private static readonly Func<TextSpan, RoslynCompletionItem, Span> s_highlightSpanGetter
-            = (span, item) => span.MoveTo(item.DisplayTextPrefix?.Length ?? 0).ToSpan();
-
-        private static bool IsHardSelection(
-            string filterText,
-            RoslynCompletionItem item,
-            bool matchedFilterText,
-            bool useSuggestionMode)
-        {
-            if (item == null || useSuggestionMode)
-            {
-                return false;
-            }
-
-            // We don't have a builder and we have a best match.  Normally this will be hard
-            // selected, except for a few cases.  Specifically, if no filter text has been
-            // provided, and this is not a preselect match then we will soft select it.  This
-            // happens when the completion list comes up implicitly and there is something in
-            // the MRU list.  In this case we do want to select it, but not with a hard
-            // selection.  Otherwise you can end up with the following problem:
-            //
-            //  dim i as integer =<space>
-            //
-            // Completion will comes up after = with 'integer' selected (Because of MRU).  We do
-            // not want 'space' to commit this.
-
-            // If all that has been typed is punctuation, then don't hard select anything.
-            // It's possible the user is just typing language punctuation and selecting
-            // anything in the list will interfere.  We only allow this if the filter text
-            // exactly matches something in the list already. 
-            if (filterText.Length > 0 && IsAllPunctuation(filterText) && filterText != item.DisplayText)
-            {
-                return false;
-            }
-
-            // If the user hasn't actually typed anything, then don't hard select any item.
-            // The only exception to this is if the completion provider has requested the
-            // item be preselected.
-            if (filterText.Length == 0)
-            {
-                // Item didn't want to be hard selected with no filter text.
-                // So definitely soft select it.
-                if (item.Rules.SelectionBehavior != CompletionItemSelectionBehavior.HardSelection)
-                {
-                    return false;
-                }
-
-                // Item did not ask to be preselected.  So definitely soft select it.
-                if (item.Rules.MatchPriority == MatchPriority.Default)
-                {
-                    return false;
-                }
-            }
-
-            // The user typed something, or the item asked to be preselected.  In 
-            // either case, don't soft select this.
-            Debug.Assert(filterText.Length > 0 || item.Rules.MatchPriority != MatchPriority.Default);
-
-            // If the user moved the caret left after they started typing, the 'best' match may not match at all
-            // against the full text span that this item would be replacing.
-            if (!matchedFilterText)
-            {
-                return false;
-            }
-
-            // There was either filter text, or this was a preselect match.  In either case, we
-            // can hard select this.
-            return true;
-        }
-
-        private static bool IsAllPunctuation(string filterText)
-        {
-            foreach (var ch in filterText)
-            {
-                if (!char.IsPunctuation(ch))
-                {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        /// <summary>
-        /// A potential filter character is something that can filter a completion lists and is
-        /// *guaranteed* to not be a commit character.
-        /// </summary>
-        private static bool IsPotentialFilterCharacter(char c)
-        {
-            // TODO(cyrusn): Actually use the right Unicode categories here.
-            return char.IsLetter(c)
-                || char.IsNumber(c)
-                || c == '_';
-        }
-
-        private static int GetAggressiveDefaultsMatch(List<MatchResult<VSCompletionItem>> itemsWithMatch, ImmutableArray<string> defaults)
-        {
-            Debug.Assert(!defaults.IsDefaultOrEmpty);
-
-            foreach (var defaultText in defaults)
-            {
-                for (var i = 0; (i < itemsWithMatch.Count); ++i)
-                {
-                    var itemWithMatch = itemsWithMatch[i];
-                    if (itemWithMatch.RoslynCompletionItem.FilterText == defaultText)
-                    {
-                        if (itemWithMatch.PatternMatch == null || itemWithMatch.PatternMatch.Value.Kind <= PatternMatchKind.Prefix)
-                            return i;
-
-                        break;
-                    }
-                }
-            }
-
-            return -1;
-        }
-
-        private static int GetDefaultsMatch(
-            string filterText,
-            List<MatchResult<VSCompletionItem>> itemsWithMatch,
-            int selectedIndex,
-            ImmutableArray<string> defaults)
-        {
-            Debug.Assert(!defaults.IsDefaultOrEmpty);
-
-            int inferiorItemIndex;
-            if (filterText.Length == 0)
-            {
-                // Without filterText, all items are eually good match, so we have to consider all of them.
-                inferiorItemIndex = itemsWithMatch.Count;
-            }
-            else
-            {
-                // Because the items are sorted based on pattern-matching score, the selectedIndex is in the middle of a range of
-                // -- as far as the pattern matcher is concerned -- equivalent items. Find the last items in the range and use that
-                // to limit the items searched for from the defaults list.          
-                var selectedItemMatch = itemsWithMatch[selectedIndex].PatternMatch;
-
-                if (!selectedItemMatch.HasValue)
-                    return -1;
-
-                inferiorItemIndex = selectedIndex;
-                while (++inferiorItemIndex < itemsWithMatch.Count)
-                {
-                    // Ignore the case when trying to match the filter text with defaults.
-                    // e.g. a default "Console" would be a match for filter text "c" and therefore to be selected,
-                    // even if the CompletionService returns item "char" which is a case-sensitive prefix match.
-                    var itemMatch = itemsWithMatch[inferiorItemIndex].PatternMatch;
-                    if (!itemMatch.HasValue || itemMatch.Value.Kind != selectedItemMatch.Value.Kind)
-                        break;
-                }
-            }
-
-            foreach (var defaultText in defaults)
-            {
-                for (var i = 0; i < inferiorItemIndex; ++i)
-                {
-                    if (itemsWithMatch[i].RoslynCompletionItem.FilterText == defaultText)
-                        return i;
-                }
-            }
-
-            return -1;
-        }
     }
 }

From 06e0f494df1f6545ad1540b69258afddd7ea2efe Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Tue, 23 Nov 2021 15:09:03 -0800
Subject: [PATCH 082/444] Refactor ItemManager

This is a refactoring only commit
---
 .../ItemManager.CompeltionListUpdater.cs      | 532 ++++++++----------
 .../AsyncCompletion/ItemManager.cs            |  15 +-
 2 files changed, 242 insertions(+), 305 deletions(-)

diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs
index 32a798c6f9e02..9e9a0451edaf7 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs
@@ -27,15 +27,35 @@ namespace Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.AsyncComplet
 {
     internal partial class ItemManager
     {
-        private sealed class CompletionListUpdater
+        private sealed class CompletionListUpdater : IDisposable
         {
-
-            public IAsyncCompletionSession Session { get; }
-            public AsyncCompletionSessionDataSnapshot Data { get; }
-            public RecentItemsManager RecentItemsManager { get; }
-            public IGlobalOptionService GlobalOptions { get; }
-            public CancellationToken CancellationToken { get; }
-            public CompletionHelper DefaultCompletionHelper { get; }
+            private IAsyncCompletionSession Session { get; }
+            private AsyncCompletionSessionDataSnapshot Data { get; }
+            private RecentItemsManager RecentItemsManager { get; }
+            private IGlobalOptionService GlobalOptions { get; }
+            private CancellationToken CancellationToken { get; }
+
+            private bool HasSuggestedItemOptions { get; }
+            private string FilterText { get; }
+            private CompletionTriggerKind InitialRoslynTriggerKind { get; }
+            private Document? Document { get; }
+            private CompletionService? CompletionService { get; }
+            private CompletionRules CompletionRules { get; }
+            private CompletionHelper CompletionHelper { get; }
+            private bool HighlightMatchingPortions { get; }
+
+            private List<MatchResult<VSCompletionItem>> ItemsToBeIncluded { get; }
+
+            private CompletionTriggerReason TriggerReason => Data.Trigger.Reason;
+            private CompletionFilterReason FilterReason => Helpers.GetFilterReason(Data.Trigger);
+
+            private Func<ImmutableArray<(RoslynCompletionItem, PatternMatch?)>, string, ImmutableArray<RoslynCompletionItem>> FilterMethod
+                => CompletionService == null
+                    ? ((itemsWithPatternMatches, text) => CompletionService.FilterItems(CompletionHelper, itemsWithPatternMatches, text))
+                    : ((itemsWithPatternMatches, text) => CompletionService.FilterItems(Document!, itemsWithPatternMatches, text));
+
+            // For telemetry
+            private readonly object _targetTypeCompletionFilterChosenMarker = new();
 
             // We might need to handle large amount of items with import completion enabled,
             // so use a dedicated pool to minimize/avoid array allocations (especially in LOH)
@@ -45,12 +65,9 @@ private sealed class CompletionListUpdater
             private static readonly ObjectPool<List<MatchResult<VSCompletionItem>>> s_listOfMatchResultPool
                     = new(factory: () => new(), size: 1);
 
-            public const string AggressiveDefaultsMatchingOptionName = "AggressiveDefaultsMatchingOption";
-
-            /// <summary>
-            /// For telemetry.
-            /// </summary>
-            private readonly object _targetTypeCompletionFilterChosenMarker = new();
+            // PERF: Create a singleton to avoid lambda allocation on hot path
+            private static readonly Func<TextSpan, RoslynCompletionItem, Span> s_highlightSpanGetter
+                = (span, item) => span.MoveTo(item.DisplayTextPrefix?.Length ?? 0).ToSpan();
 
             public CompletionListUpdater(
                 IAsyncCompletionSession session,
@@ -65,13 +82,9 @@ public CompletionListUpdater(
                 GlobalOptions = globalOptions;
                 CancellationToken = cancellationToken;
 
-                // Let us make the completion Helper used for non-Roslyn items case-sensitive.
-                // We can change this if get requests from partner teams.
-                DefaultCompletionHelper = new CompletionHelper(isCaseSensitive: true);
-            }
+                FilterText = Session.ApplicableToSpan.GetText(Data.Snapshot);
+                InitialRoslynTriggerKind = Helpers.GetRoslynTriggerKind(Data.InitialTrigger);
 
-            public FilteredCompletionModel? UpdateCompletionList()
-            {
                 if (!Session.Properties.TryGetProperty(CompletionSource.HasSuggestionItemOptions, out bool hasSuggestedItemOptions))
                 {
                     // This is the scenario when the session is created out of Roslyn, in some other provider, e.g. in Debugger.
@@ -79,12 +92,59 @@ public CompletionListUpdater(
                     hasSuggestedItemOptions = false;
                 }
 
-                hasSuggestedItemOptions |= Data.DisplaySuggestionItem;
+                HasSuggestedItemOptions = hasSuggestedItemOptions || Data.DisplaySuggestionItem;
+
+                // We prefer using the original snapshot, which should always be available from items provided by Roslyn's CompletionSource.
+                // Only use data.Snapshot in the theoretically possible but rare case when all items we are handling are from some non-Roslyn CompletionSource.
+                var snapshotForDocument = TryGetInitialTriggerLocation(Data, out var intialTriggerLocation)
+                    ? intialTriggerLocation.Snapshot
+                    : Data.Snapshot;
 
-                var filterText = Session.ApplicableToSpan.GetText(Data.Snapshot);
-                var reason = Data.Trigger.Reason;
-                var initialRoslynTriggerKind = Helpers.GetRoslynTriggerKind(Data.InitialTrigger);
+                Document = snapshotForDocument?.TextBuffer.AsTextContainer().GetOpenDocumentInCurrentContext();
+                CompletionService = Document?.GetLanguageService<CompletionService>();
+                CompletionRules = CompletionService?.GetRules(CompletionOptions.From(Document!.Project)) ?? CompletionRules.Default;
 
+                // Let us make the completion Helper used for non-Roslyn items case-sensitive.
+                // We can change this if get requests from partner teams.
+                CompletionHelper = Document != null ? CompletionHelper.GetHelper(Document) : new CompletionHelper(isCaseSensitive: true);
+
+                // Nothing to highlight if user hasn't typed anything yet.
+                HighlightMatchingPortions = FilterText.Length > 0
+                    && GlobalOptions.GetOption(CompletionViewOptions.HighlightMatchingPortionsOfCompletionListItems, Document?.Project.Language);
+
+                ItemsToBeIncluded = s_listOfMatchResultPool.Allocate();
+            }
+
+            public FilteredCompletionModel? UpdateCompletionList()
+            {
+                if (ShouldDismissCompletionListImmediately())
+                    return null;
+
+                ComputeItemsToBeIncluded();
+
+                if (ItemsToBeIncluded.Count == 0)
+                    return HandleAllItemsFilteredOut();
+
+                var initialSelection = InitialRoslynTriggerKind == CompletionTriggerKind.Deletion
+                    ? HandleDeletionTrigger()
+                    : HandleNormalFiltering();
+
+                if (!initialSelection.HasValue)
+                    return null;
+
+                var finalSelection = UpdateSelectionWithSuggestedDefaults(initialSelection.Value);
+
+                return new FilteredCompletionModel(
+                    items: GetHighlightedList(),
+                    finalSelection.SelectedItemIndex,
+                    filters: GetUpdatedFilters(),
+                    finalSelection.SelectionHint,
+                    centerSelection: true,
+                    finalSelection.UniqueItem);
+            }
+
+            private bool ShouldDismissCompletionListImmediately()
+            {
                 // Check if the user is typing a number. If so, only proceed if it's a number
                 // directly after a <dot>. That's because it is actually reasonable for completion
                 // to be brought up after a <dot> and for the user to want to filter completion
@@ -96,15 +156,34 @@ public CompletionListUpdater(
                 //
                 // We'll bring up the completion list here (as VB has completion on <space>).
                 // If the user then types '3', we don't want to match against Int32.
-                if (filterText.Length > 0 && char.IsNumber(filterText[0]))
+                if (FilterText.Length > 0 && char.IsNumber(FilterText[0]) && !IsAfterDot(Data.Snapshot, Session.ApplicableToSpan))
                 {
-                    if (!IsAfterDot(Data.Snapshot, Session.ApplicableToSpan))
-                    {
-                        // Dismiss the session.
-                        return null;
-                    }
+                    // Dismiss the session.
+                    return true;
+                }
+
+                // DismissIfLastCharacterDeleted should be applied only when started with Insertion, and then Deleted all characters typed.
+                // This conforms with the original VS 2010 behavior.
+                if (InitialRoslynTriggerKind == CompletionTriggerKind.Insertion &&
+                    Data.Trigger.Reason == CompletionTriggerReason.Backspace &&
+                    CompletionRules.DismissIfLastCharacterDeleted &&
+                    FilterText.Length == 0)
+                {
+                    // Dismiss the session
+                    return true;
+                }
+
+                return false;
+
+                static bool IsAfterDot(ITextSnapshot snapshot, ITrackingSpan applicableToSpan)
+                {
+                    var position = applicableToSpan.GetStartPoint(snapshot).Position;
+                    return position > 0 && snapshot[position - 1] == '.';
                 }
+            }
 
+            private void ComputeItemsToBeIncluded()
+            {
                 // We need to filter if 
                 // 1. a non-empty strict subset of filters are selected
                 // 2. a non-empty set of expanders are unselected
@@ -130,178 +209,42 @@ public CompletionListUpdater(
                     }
                 }
 
-                var filterReason = Helpers.GetFilterReason(Data.Trigger);
-
-                // We prefer using the original snapshot, which should always be available from items provided by Roslyn's CompletionSource.
-                // Only use data.Snapshot in the theoretically possible but rare case when all items we are handling are from some non-Roslyn CompletionSource.
-                var snapshotForDocument = TryGetInitialTriggerLocation(Data, out var intialTriggerLocation)
-                    ? intialTriggerLocation.Snapshot
-                    : Data.Snapshot;
-
-                var document = snapshotForDocument?.TextBuffer.AsTextContainer().GetOpenDocumentInCurrentContext();
-                var completionService = document?.GetLanguageService<CompletionService>();
-                var completionRules = completionService?.GetRules(CompletionOptions.From(document!.Project)) ?? CompletionRules.Default;
-                var completionHelper = document != null ? CompletionHelper.GetHelper(document) : DefaultCompletionHelper;
-
-                // DismissIfLastCharacterDeleted should be applied only when started with Insertion, and then Deleted all characters typed.
-                // This conforms with the original VS 2010 behavior.
-                if (initialRoslynTriggerKind == CompletionTriggerKind.Insertion &&
-                    Data.Trigger.Reason == CompletionTriggerReason.Backspace &&
-                    completionRules.DismissIfLastCharacterDeleted &&
-                    Session.ApplicableToSpan.GetText(Data.Snapshot).Length == 0)
-                {
-                    // Dismiss the session
-                    return null;
-                }
-
-                var highlightMatchingPortions = GlobalOptions.GetOption(CompletionViewOptions.HighlightMatchingPortionsOfCompletionListItems, document?.Project.Language);
-                // Nothing to highlight if user hasn't typed anything yet.
-                highlightMatchingPortions = highlightMatchingPortions && filterText.Length > 0;
-
                 // Use a monotonically increasing integer to keep track the original alphabetical order of each item.
                 var currentIndex = 0;
 
-                var initialListOfItemsToBeIncluded = s_listOfMatchResultPool.Allocate();
-                try
+                // Filter items based on the selected filters and matching.
+                foreach (var item in Data.InitialSortedList)
                 {
-                    // Filter items based on the selected filters and matching.
-                    foreach (var item in Data.InitialSortedList)
-                    {
-                        CancellationToken.ThrowIfCancellationRequested();
+                    CancellationToken.ThrowIfCancellationRequested();
 
-                        if (needToFilter && ShouldBeFilteredOutOfCompletionList(item, selectedNonExpanderFilters))
-                        {
-                            continue;
-                        }
-
-                        if (needToFilterExpanded && ShouldBeFilteredOutOfExpandedCompletionList(item, unselectedExpanders))
-                        {
-                            continue;
-                        }
-
-                        if (TryCreateMatchResult(
-                            completionHelper,
-                            item,
-                            filterText,
-                            initialRoslynTriggerKind,
-                            filterReason,
-                            RecentItemsManager.RecentItems,
-                            highlightMatchingPortions: highlightMatchingPortions,
-                            currentIndex,
-                            out var matchResult))
-                        {
-                            initialListOfItemsToBeIncluded.Add(matchResult);
-                            currentIndex++;
-                        }
-                    }
-
-                    if (initialListOfItemsToBeIncluded.Count == 0)
+                    if (needToFilter && ShouldBeFilteredOutOfCompletionList(item, selectedNonExpanderFilters))
                     {
-                        return HandleAllItemsFilteredOut(reason, Data.SelectedFilters, completionRules);
+                        continue;
                     }
 
-                    // Sort the items by pattern matching results.
-                    // Note that we want to preserve the original alphabetical order for items with same pattern match score,
-                    // but `List<T>.Sort` isn't stable. Therefore we have to add a monotonically increasing integer
-                    // to `MatchResult` to achieve this.
-                    initialListOfItemsToBeIncluded.Sort(MatchResult<VSCompletionItem>.SortingComparer);
-
-                    var filteringResult = initialRoslynTriggerKind == CompletionTriggerKind.Deletion
-                            ? HandleDeletionTrigger(reason, initialListOfItemsToBeIncluded, filterText, hasSuggestedItemOptions)
-                            : HandleNormalFiltering(GetFilterMethod(), filterText, filterReason, Data.Trigger.Character, initialListOfItemsToBeIncluded, hasSuggestedItemOptions);
-
-                    if (!filteringResult.HasValue)
-                        return null;
-
-                    var (selectedItemIndex, selectionHint, uniqueItem) = filteringResult.Value;
-
-                    // Editor is providing us a list of "default" items to consider for selection.
-                    if (!Data.Defaults.IsDefaultOrEmpty)
+                    if (needToFilterExpanded && ShouldBeFilteredOutOfExpandedCompletionList(item, unselectedExpanders))
                     {
-                        var tick = Environment.TickCount;
-
-                        var selectedItem = initialListOfItemsToBeIncluded[selectedItemIndex].RoslynCompletionItem;
-
-                        // "Preselect" is only used when we have high confidence with the selection, so don't override it.
-                        if (selectedItem.Rules.MatchPriority < MatchPriority.Preselect)
-                        {
-                            int defaultsMatchingIndex;
-                            var useAggressiveDefaultsMatching = Session.TextView.Options.GetOptionValue<bool>(AggressiveDefaultsMatchingOptionName);
-
-                            if (useAggressiveDefaultsMatching)
-                            {
-                                defaultsMatchingIndex = GetAggressiveDefaultsMatch(initialListOfItemsToBeIncluded, Data.Defaults);
-                                if (!hasSuggestedItemOptions && defaultsMatchingIndex >= 0)
-                                    selectionHint = UpdateSelectionHint.Selected;
-                            }
-                            else
-                            {
-                                defaultsMatchingIndex = GetDefaultsMatch(filterText, initialListOfItemsToBeIncluded, selectedItemIndex, Data.Defaults);
-                            }
-
-                            if (defaultsMatchingIndex >= 0)
-                            {
-                                selectedItemIndex = defaultsMatchingIndex;
-                            }
-                        }
-
-                        AsyncCompletionLogger.LogGetDefaultsMatchTicksDataPoint(Environment.TickCount - tick);
+                        continue;
                     }
 
-                    var showCompletionItemFilters = GlobalOptions.GetOption(CompletionViewOptions.ShowCompletionItemFilters, document?.Project.Language);
-                    var updatedFilters = showCompletionItemFilters
-                        ? GetUpdatedFilters(initialListOfItemsToBeIncluded, Data.SelectedFilters)
-                        : ImmutableArray<CompletionFilterWithState>.Empty;
-
-                    return new FilteredCompletionModel(
-                        items: GetHighlightedList(initialListOfItemsToBeIncluded, filterText, highlightMatchingPortions, completionHelper),
-                        selectedItemIndex,
-                        updatedFilters,
-                        selectionHint,
-                        centerSelection: true,
-                        uniqueItem);
-                }
-                finally
-                {
-                    // Don't call ClearAndFree, which resets the capacity to a default value.
-                    initialListOfItemsToBeIncluded.Clear();
-                    s_listOfMatchResultPool.Free(initialListOfItemsToBeIncluded);
-                }
-
-                Func<ImmutableArray<(RoslynCompletionItem, PatternMatch?)>, string, ImmutableArray<RoslynCompletionItem>> GetFilterMethod()
-                {
-                    if (completionService == null)
-                    {
-                        return (itemsWithPatternMatches, text) => CompletionService.FilterItems(completionHelper, itemsWithPatternMatches, text);
-                    }
-                    else
+                    var roslynItem = GetOrAddRoslynCompletionItem(item);
+                    if (CompletionHelper.TryCreateMatchResult(CompletionHelper, roslynItem, item, FilterText,
+                        InitialRoslynTriggerKind, FilterReason, RecentItemsManager.RecentItems, HighlightMatchingPortions, currentIndex,
+                        out var matchResult))
                     {
-                        Contract.ThrowIfNull(document);
-                        return (itemsWithPatternMatches, text) => completionService.FilterItems(document, itemsWithPatternMatches, text);
+                        ItemsToBeIncluded.Add(matchResult);
+                        currentIndex++;
                     }
                 }
 
-                static bool TryGetInitialTriggerLocation(AsyncCompletionSessionDataSnapshot data, out SnapshotPoint intialTriggerLocation)
-                {
-                    var firstItem = data.InitialSortedList.FirstOrDefault(static item => item.Properties.ContainsProperty(CompletionSource.TriggerLocation));
-                    if (firstItem != null)
-                    {
-                        return firstItem.Properties.TryGetProperty(CompletionSource.TriggerLocation, out intialTriggerLocation);
-                    }
-
-                    intialTriggerLocation = default;
-                    return false;
-                }
+                // Sort the items by pattern matching results.
+                // Note that we want to preserve the original alphabetical order for items with same pattern match score,
+                // but `List<T>.Sort` isn't stable. Therefore we have to add a monotonically increasing integer
+                // to `MatchResult` to achieve this.
+                ItemsToBeIncluded.Sort(MatchResult<VSCompletionItem>.SortingComparer);
 
                 static bool ShouldBeFilteredOutOfCompletionList(VSCompletionItem item, ImmutableArray<CompletionFilter> activeNonExpanderFilters)
-                {
-                    if (item.Filters.Any(filter => activeNonExpanderFilters.Contains(filter)))
-                    {
-                        return false;
-                    }
-
-                    return true;
-                }
+                    => !item.Filters.Any(filter => activeNonExpanderFilters.Contains(filter));
 
                 static bool ShouldBeFilteredOutOfExpandedCompletionList(VSCompletionItem item, ImmutableArray<CompletionFilter> unselectedExpanders)
                 {
@@ -327,28 +270,38 @@ static bool ShouldBeFilteredOutOfExpandedCompletionList(VSCompletionItem item, I
                 }
             }
 
-            private static bool IsAfterDot(ITextSnapshot snapshot, ITrackingSpan applicableToSpan)
+            private ItemSelection UpdateSelectionWithSuggestedDefaults(ItemSelection itemSelection)
             {
-                var position = applicableToSpan.GetStartPoint(snapshot).Position;
-                return position > 0 && snapshot[position - 1] == '.';
+                // Editor doesn't provide us a list of "default" items.
+                if (Data.Defaults.IsDefaultOrEmpty)
+                    return itemSelection;
+
+                // "Preselect" is only used when we have high confidence with the selection, so don't override it.
+                var selectedItem = ItemsToBeIncluded[itemSelection.SelectedItemIndex].RoslynCompletionItem;
+                if (selectedItem.Rules.MatchPriority >= MatchPriority.Preselect)
+                    return itemSelection;
+
+                var tick = Environment.TickCount;
+
+                var useAggressiveDefaultsMatching = Session.TextView.Options.GetOptionValue<bool>(AggressiveDefaultsMatchingOptionName);
+                var finalSelection = useAggressiveDefaultsMatching
+                    ? GetAggressiveDefaultsMatch(itemSelection)
+                    : GetDefaultsMatch(itemSelection);
+
+                AsyncCompletionLogger.LogGetDefaultsMatchTicksDataPoint(Environment.TickCount - tick);
+                return finalSelection;
             }
 
-            private (int selectedItemIndex, UpdateSelectionHint selectionHint, VSCompletionItem? uniqueItem)? HandleNormalFiltering(
-                Func<ImmutableArray<(RoslynCompletionItem, PatternMatch?)>, string, ImmutableArray<RoslynCompletionItem>> filterMethod,
-                string filterText,
-                CompletionFilterReason filterReason,
-                char typeChar,
-                List<MatchResult<VSCompletionItem>> itemsInList,
-                bool hasSuggestedItemOptions)
+            private ItemSelection? HandleNormalFiltering()
             {
                 // Not deletion.  Defer to the language to decide which item it thinks best
                 // matches the text typed so far.
 
                 // Ask the language to determine which of the *matched* items it wants to select.
-                var matchingItems = itemsInList.Where(r => r.MatchedFilterText)
+                var matchingItems = ItemsToBeIncluded.Where(r => r.MatchedFilterText)
                                                .SelectAsArray(t => (t.RoslynCompletionItem, t.PatternMatch));
 
-                var chosenItems = filterMethod(matchingItems, filterText);
+                var chosenItems = FilterMethod(matchingItems, FilterText);
 
                 int selectedItemIndex;
                 VSCompletionItem? uniqueItem = null;
@@ -358,14 +311,14 @@ private static bool IsAfterDot(ITextSnapshot snapshot, ITrackingSpan applicableT
                 {
                     // We do not have matches: pick the one with longest common prefix or the first item from the list.
                     selectedItemIndex = 0;
-                    bestOrFirstMatchResult = itemsInList[0];
+                    bestOrFirstMatchResult = ItemsToBeIncluded[0];
 
-                    var longestCommonPrefixLength = bestOrFirstMatchResult.RoslynCompletionItem.FilterText.GetCaseInsensitivePrefixLength(filterText);
+                    var longestCommonPrefixLength = bestOrFirstMatchResult.RoslynCompletionItem.FilterText.GetCaseInsensitivePrefixLength(FilterText);
 
-                    for (var i = 1; i < itemsInList.Count; ++i)
+                    for (var i = 1; i < ItemsToBeIncluded.Count; ++i)
                     {
-                        var item = itemsInList[i];
-                        var commonPrefixLength = item.RoslynCompletionItem.FilterText.GetCaseInsensitivePrefixLength(filterText);
+                        var item = ItemsToBeIncluded[i];
+                        var commonPrefixLength = item.RoslynCompletionItem.FilterText.GetCaseInsensitivePrefixLength(FilterText);
 
                         if (commonPrefixLength > longestCommonPrefixLength)
                         {
@@ -389,45 +342,44 @@ private static bool IsAfterDot(ITextSnapshot snapshot, ITrackingSpan applicableT
                     // typed.  i.e.  if we have "Console.$$" we don't want to commit something
                     // like "WriteLine" since no filter text has actually been provided.  However,
                     // if "Console.WriteL$$" is typed, then we do want "WriteLine" to be committed.
-                    selectedItemIndex = itemsInList.IndexOf(i => Equals(i.RoslynCompletionItem, bestItem));
-                    bestOrFirstMatchResult = itemsInList[selectedItemIndex];
+                    selectedItemIndex = ItemsToBeIncluded.IndexOf(i => Equals(i.RoslynCompletionItem, bestItem));
+                    bestOrFirstMatchResult = ItemsToBeIncluded[selectedItemIndex];
                     var deduplicatedListCount = matchingItems.Count(r => !r.RoslynCompletionItem.IsPreferredItem());
                     if (deduplicatedListCount == 1 &&
-                        filterText.Length > 0)
+                        FilterText.Length > 0)
                     {
-                        uniqueItem = itemsInList[selectedItemIndex].EditorCompletionItem;
+                        uniqueItem = ItemsToBeIncluded[selectedItemIndex].EditorCompletionItem;
                     }
                 }
 
+                var typedChar = Data.Trigger.Character;
+
                 // Check that it is a filter symbol. We can be called for a non-filter symbol.
-                // If inserting a non-filter character (neither IsPotentialFilterCharacter, nor Helpers.IsFilterCharacter), we should dismiss completion  
+                // If inserting a non-filter character (neither
+                // , nor Helpers.IsFilterCharacter), we should dismiss completion  
                 // except cases where this is the first symbol typed for the completion session (string.IsNullOrEmpty(filterText) or string.Equals(filterText, typeChar.ToString(), StringComparison.OrdinalIgnoreCase)).
                 // In the latter case, we should keep the completion because it was confirmed just before in InitializeCompletion.
-                if (filterReason == CompletionFilterReason.Insertion &&
-                    !string.IsNullOrEmpty(filterText) &&
-                    !string.Equals(filterText, typeChar.ToString(), StringComparison.OrdinalIgnoreCase) &&
-                    !IsPotentialFilterCharacter(typeChar) &&
-                    !Helpers.IsFilterCharacter(bestOrFirstMatchResult.RoslynCompletionItem, typeChar, filterText))
+                if (FilterReason == CompletionFilterReason.Insertion &&
+                    !string.IsNullOrEmpty(FilterText) &&
+                    !string.Equals(FilterText, typedChar.ToString(), StringComparison.OrdinalIgnoreCase) &&
+                    !IsPotentialFilterCharacter(typedChar) &&
+                    !Helpers.IsFilterCharacter(bestOrFirstMatchResult.RoslynCompletionItem, typedChar, FilterText))
                 {
                     return null;
                 }
 
                 var isHardSelection = IsHardSelection(
-                    filterText, bestOrFirstMatchResult.RoslynCompletionItem, bestOrFirstMatchResult.MatchedFilterText, hasSuggestedItemOptions);
+                    FilterText, bestOrFirstMatchResult.RoslynCompletionItem, bestOrFirstMatchResult.MatchedFilterText, HasSuggestedItemOptions);
 
                 var updateSelectionHint = isHardSelection ? UpdateSelectionHint.Selected : UpdateSelectionHint.SoftSelected;
 
-                return (selectedItemIndex, updateSelectionHint, uniqueItem);
+                return new(selectedItemIndex, updateSelectionHint, uniqueItem);
             }
 
-            private static (int selectedItemIndex, UpdateSelectionHint selectionHint, VSCompletionItem? uniqueItem)? HandleDeletionTrigger(
-                CompletionTriggerReason filterTriggerKind,
-                List<MatchResult<VSCompletionItem>> matchResults,
-                string filterText,
-                bool hasSuggestedItemOptions)
+            private ItemSelection? HandleDeletionTrigger()
             {
-                var matchingItems = matchResults.Where(r => r.MatchedFilterText);
-                if (filterTriggerKind == CompletionTriggerReason.Insertion &&
+                var matchingItems = ItemsToBeIncluded.Where(r => r.MatchedFilterText);
+                if (TriggerReason == CompletionTriggerReason.Insertion &&
                     !matchingItems.Any())
                 {
                     // The user has typed something, but nothing in the actual list matched what
@@ -450,7 +402,7 @@ private static (int selectedItemIndex, UpdateSelectionHint selectionHint, VSComp
                     }
                     else
                     {
-                        var match = currentMatchResult.CompareTo(bestMatchResult.Value, filterText);
+                        var match = currentMatchResult.CompareTo(bestMatchResult.Value, FilterText);
                         if (match > 0)
                         {
                             moreThanOneMatchWithSamePriority = false;
@@ -478,8 +430,8 @@ private static (int selectedItemIndex, UpdateSelectionHint selectionHint, VSComp
                     //   text that originally appeared before the dot
                     // * deleting through a word from the end keeps that word selected
                     // This also preserves the behavior the VB had through Dev12.
-                    hardSelect = !hasSuggestedItemOptions && bestMatchResult.Value.EditorCompletionItem.FilterText.StartsWith(filterText, StringComparison.CurrentCultureIgnoreCase);
-                    index = matchResults.IndexOf(bestMatchResult.Value);
+                    hardSelect = !HasSuggestedItemOptions && bestMatchResult.Value.EditorCompletionItem.FilterText.StartsWith(FilterText, StringComparison.CurrentCultureIgnoreCase);
+                    index = ItemsToBeIncluded.IndexOf(bestMatchResult.Value);
                 }
                 else
                 {
@@ -487,20 +439,16 @@ private static (int selectedItemIndex, UpdateSelectionHint selectionHint, VSComp
                     hardSelect = false;
                 }
 
-                return (index,
+                return new(index,
                     hardSelect ? UpdateSelectionHint.Selected : UpdateSelectionHint.SoftSelected,
                     moreThanOneMatchWithSamePriority ? null : bestMatchResult.GetValueOrDefault().EditorCompletionItem);
             }
 
-            private static ImmutableArray<CompletionItemWithHighlight> GetHighlightedList(
-                List<MatchResult<VSCompletionItem>> matchResults,
-                string filterText,
-                bool highlightMatchingPortions,
-                CompletionHelper completionHelper)
+            private ImmutableArray<CompletionItemWithHighlight> GetHighlightedList()
             {
-                return matchResults.SelectAsArray(matchResult =>
+                return ItemsToBeIncluded.SelectAsArray(matchResult =>
                 {
-                    var highlightedSpans = GetHighlightedSpans(matchResult, completionHelper, filterText, highlightMatchingPortions);
+                    var highlightedSpans = GetHighlightedSpans(matchResult, CompletionHelper, FilterText, HighlightMatchingPortions);
                     return new CompletionItemWithHighlight(matchResult.EditorCompletionItem, highlightedSpans);
                 });
 
@@ -537,17 +485,14 @@ static ImmutableArray<Span> GetHighlightedSpans(
                 }
             }
 
-            private static FilteredCompletionModel? HandleAllItemsFilteredOut(
-                CompletionTriggerReason triggerReason,
-                ImmutableArray<CompletionFilterWithState> filters,
-                CompletionRules completionRules)
+            private FilteredCompletionModel? HandleAllItemsFilteredOut()
             {
-                if (triggerReason == CompletionTriggerReason.Insertion)
+                if (TriggerReason == CompletionTriggerReason.Insertion)
                 {
                     // If the user was just typing, and the list went to empty *and* this is a 
                     // language that wants to dismiss on empty, then just return a null model
                     // to stop the completion session.
-                    if (completionRules.DismissIfEmpty)
+                    if (CompletionRules.DismissIfEmpty)
                     {
                         return null;
                     }
@@ -564,20 +509,22 @@ static ImmutableArray<Span> GetHighlightedSpans(
 
                 return new FilteredCompletionModel(
                     ImmutableArray<CompletionItemWithHighlight>.Empty, selectedItemIndex: 0,
-                    filters, selection, centerSelection: true, uniqueItem: null);
+                    Data.SelectedFilters, selection, centerSelection: true, uniqueItem: null);
             }
 
-            private static ImmutableArray<CompletionFilterWithState> GetUpdatedFilters(
-                List<MatchResult<VSCompletionItem>> filteredList,
-                ImmutableArray<CompletionFilterWithState> filters)
+            private ImmutableArray<CompletionFilterWithState> GetUpdatedFilters()
             {
+                var showCompletionItemFilters = GlobalOptions.GetOption(CompletionViewOptions.ShowCompletionItemFilters, Document?.Project.Language);
+                if (!showCompletionItemFilters)
+                    return ImmutableArray<CompletionFilterWithState>.Empty;
+
                 // See which filters might be enabled based on the typed code
                 using var _ = PooledHashSet<CompletionFilter>.GetInstance(out var textFilteredFilters);
-                textFilteredFilters.AddRange(filteredList.SelectMany(n => n.EditorCompletionItem.Filters));
+                textFilteredFilters.AddRange(ItemsToBeIncluded.SelectMany(n => n.EditorCompletionItem.Filters));
 
                 // When no items are available for a given filter, it becomes unavailable.
                 // Expanders always appear available as long as it's presented.
-                return filters.SelectAsArray(n => n.WithAvailability(n.Filter is CompletionExpander ? true : textFilteredFilters.Contains(n.Filter)));
+                return Data.SelectedFilters.SelectAsArray(n => n.WithAvailability(n.Filter is CompletionExpander || textFilteredFilters.Contains(n.Filter)));
             }
 
             /// <summary>
@@ -626,32 +573,25 @@ private static RoslynCompletionItem GetBestCompletionItemBasedOnMRU(
                 }
 
                 return bestItem;
-            }
 
-            private static int GetRecentItemIndex(ImmutableArray<string> recentItems, RoslynCompletionItem item)
-            {
-                var index = recentItems.IndexOf(item.FilterText);
-                return -index;
+                static int GetRecentItemIndex(ImmutableArray<string> recentItems, RoslynCompletionItem item)
+                {
+                    var index = recentItems.IndexOf(item.FilterText);
+                    return -index;
+                }
             }
 
-            private static bool TryCreateMatchResult(
-                CompletionHelper completionHelper,
-                VSCompletionItem item,
-                string filterText,
-                CompletionTriggerKind initialTriggerKind,
-                CompletionFilterReason filterReason,
-                ImmutableArray<string> recentItems,
-                bool highlightMatchingPortions,
-                int currentIndex,
-                out MatchResult<VSCompletionItem> matchResult)
+            private static bool TryGetInitialTriggerLocation(AsyncCompletionSessionDataSnapshot data, out SnapshotPoint intialTriggerLocation)
             {
-                var roslynItem = GetOrAddRoslynCompletionItem(item);
-                return CompletionHelper.TryCreateMatchResult(completionHelper, roslynItem, item, filterText, initialTriggerKind, filterReason, recentItems, highlightMatchingPortions, currentIndex, out matchResult);
-            }
+                var firstItem = data.InitialSortedList.FirstOrDefault(static item => item.Properties.ContainsProperty(CompletionSource.TriggerLocation));
+                if (firstItem != null)
+                {
+                    return firstItem.Properties.TryGetProperty(CompletionSource.TriggerLocation, out intialTriggerLocation);
+                }
 
-            // PERF: Create a singleton to avoid lambda allocation on hot path
-            private static readonly Func<TextSpan, RoslynCompletionItem, Span> s_highlightSpanGetter
-                = (span, item) => span.MoveTo(item.DisplayTextPrefix?.Length ?? 0).ToSpan();
+                intialTriggerLocation = default;
+                return false;
+            }
 
             private static bool IsHardSelection(
                 string filterText,
@@ -745,76 +685,78 @@ private static bool IsPotentialFilterCharacter(char c)
                     || c == '_';
             }
 
-            private static int GetAggressiveDefaultsMatch(List<MatchResult<VSCompletionItem>> itemsWithMatch, ImmutableArray<string> defaults)
+            private ItemSelection GetAggressiveDefaultsMatch(ItemSelection intialSelection)
             {
-                Debug.Assert(!defaults.IsDefaultOrEmpty);
-
-                foreach (var defaultText in defaults)
+                foreach (var defaultText in Data.Defaults)
                 {
-                    for (var i = 0; (i < itemsWithMatch.Count); ++i)
+                    for (var i = 0; (i < ItemsToBeIncluded.Count); ++i)
                     {
-                        var itemWithMatch = itemsWithMatch[i];
-                        if (itemWithMatch.RoslynCompletionItem.FilterText == defaultText)
-                        {
-                            if (itemWithMatch.PatternMatch == null || itemWithMatch.PatternMatch.Value.Kind <= PatternMatchKind.Prefix)
-                                return i;
+                        var itemWithMatch = ItemsToBeIncluded[i];
+                        if (itemWithMatch.RoslynCompletionItem.FilterText != defaultText)
+                            continue;
 
+                        if (itemWithMatch.PatternMatch != null && itemWithMatch.PatternMatch.Value.Kind > PatternMatchKind.Prefix)
                             break;
-                        }
+
+                        return HasSuggestedItemOptions
+                            ? intialSelection with { SelectedItemIndex = i }
+                            : intialSelection with { SelectedItemIndex = i, SelectionHint = UpdateSelectionHint.Selected };
                     }
                 }
 
-                return -1;
+                return intialSelection;
             }
 
-            private static int GetDefaultsMatch(
-                string filterText,
-                List<MatchResult<VSCompletionItem>> itemsWithMatch,
-                int selectedIndex,
-                ImmutableArray<string> defaults)
+            private ItemSelection GetDefaultsMatch(ItemSelection intialSelection)
             {
-                Debug.Assert(!defaults.IsDefaultOrEmpty);
-
                 int inferiorItemIndex;
-                if (filterText.Length == 0)
+                if (FilterText.Length == 0)
                 {
                     // Without filterText, all items are eually good match, so we have to consider all of them.
-                    inferiorItemIndex = itemsWithMatch.Count;
+                    inferiorItemIndex = ItemsToBeIncluded.Count;
                 }
                 else
                 {
                     // Because the items are sorted based on pattern-matching score, the selectedIndex is in the middle of a range of
                     // -- as far as the pattern matcher is concerned -- equivalent items. Find the last items in the range and use that
                     // to limit the items searched for from the defaults list.          
-                    var selectedItemMatch = itemsWithMatch[selectedIndex].PatternMatch;
+                    var selectedItemMatch = ItemsToBeIncluded[intialSelection.SelectedItemIndex].PatternMatch;
 
                     if (!selectedItemMatch.HasValue)
-                        return -1;
+                        return intialSelection;
 
-                    inferiorItemIndex = selectedIndex;
-                    while (++inferiorItemIndex < itemsWithMatch.Count)
+                    inferiorItemIndex = intialSelection.SelectedItemIndex;
+                    while (++inferiorItemIndex < ItemsToBeIncluded.Count)
                     {
                         // Ignore the case when trying to match the filter text with defaults.
                         // e.g. a default "Console" would be a match for filter text "c" and therefore to be selected,
                         // even if the CompletionService returns item "char" which is a case-sensitive prefix match.
-                        var itemMatch = itemsWithMatch[inferiorItemIndex].PatternMatch;
+                        var itemMatch = ItemsToBeIncluded[inferiorItemIndex].PatternMatch;
                         if (!itemMatch.HasValue || itemMatch.Value.Kind != selectedItemMatch.Value.Kind)
                             break;
                     }
                 }
 
-                foreach (var defaultText in defaults)
+                foreach (var defaultText in Data.Defaults)
                 {
                     for (var i = 0; i < inferiorItemIndex; ++i)
                     {
-                        if (itemsWithMatch[i].RoslynCompletionItem.FilterText == defaultText)
-                            return i;
+                        if (ItemsToBeIncluded[i].RoslynCompletionItem.FilterText == defaultText)
+                            return intialSelection with { SelectedItemIndex = i };
                     }
                 }
 
-                return -1;
+                return intialSelection;
+            }
+
+            public void Dispose()
+            {
+                // Don't call ClearAndFree, which resets the capacity to a default value.
+                ItemsToBeIncluded.Clear();
+                s_listOfMatchResultPool.Free(ItemsToBeIncluded);
             }
 
+            private readonly record struct ItemSelection(int SelectedItemIndex, UpdateSelectionHint SelectionHint, VSCompletionItem? UniqueItem);
         }
     }
 }
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
index 92755c576cf03..ae24a0e6ac062 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
@@ -6,7 +6,6 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.Completion;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.VisualStudio.Language.Intellisense.AsyncCompletion;
 using Microsoft.VisualStudio.Language.Intellisense.AsyncCompletion.Data;
@@ -16,11 +15,12 @@
 
 namespace Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.AsyncCompletion
 {
-    internal partial class ItemManager : IAsyncCompletionItemManager
+    internal sealed partial class ItemManager : IAsyncCompletionItemManager
     {
+        public const string AggressiveDefaultsMatchingOptionName = "AggressiveDefaultsMatchingOption";
+
         private readonly RecentItemsManager _recentItemsManager;
         private readonly IGlobalOptionService _globalOptions;
-        public const string AggressiveDefaultsMatchingOptionName = "AggressiveDefaultsMatchingOption";
 
         internal ItemManager(RecentItemsManager recentItemsManager, IGlobalOptionService globalOptions)
         {
@@ -33,21 +33,16 @@ public Task<ImmutableArray<VSCompletionItem>> SortCompletionListAsync(
             AsyncCompletionSessionInitialDataSnapshot data,
             CancellationToken cancellationToken)
         {
+            // This method is called exactly once, so use the opportunity to set a baseline for telemetry.
             if (session.TextView.Properties.TryGetProperty(CompletionSource.TargetTypeFilterExperimentEnabled, out bool isTargetTypeFilterEnabled) && isTargetTypeFilterEnabled)
             {
                 AsyncCompletionLogger.LogSessionHasTargetTypeFilterEnabled();
-
-                // This method is called exactly once, so use the opportunity to set a baseline for telemetry.
                 if (data.InitialList.Any(i => i.Filters.Any(f => f.DisplayText == FeaturesResources.Target_type_matches)))
-                {
                     AsyncCompletionLogger.LogSessionContainsTargetTypeFilter();
-                }
             }
 
             if (session.TextView.Properties.TryGetProperty(CompletionSource.TypeImportCompletionEnabled, out bool isTypeImportCompletionEnabled) && isTypeImportCompletionEnabled)
-            {
                 AsyncCompletionLogger.LogSessionWithTypeImportCompletionEnabled();
-            }
 
             // Sort by default comparer of Roslyn CompletionItem
             var sortedItems = data.InitialList.OrderBy(GetOrAddRoslynCompletionItem).ToImmutableArray();
@@ -59,7 +54,7 @@ public Task<ImmutableArray<VSCompletionItem>> SortCompletionListAsync(
             AsyncCompletionSessionDataSnapshot data,
             CancellationToken cancellationToken)
         {
-            var updater = new CompletionListUpdater(session, data, _recentItemsManager, _globalOptions, cancellationToken);
+            using var updater = new CompletionListUpdater(session, data, _recentItemsManager, _globalOptions, cancellationToken);
             return Task.FromResult(updater.UpdateCompletionList());
         }
 

From 6610099f0a7ee1184cfb04e8712fa58ef0263b7b Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Tue, 23 Nov 2021 17:11:21 -0800
Subject: [PATCH 083/444] Use a disposable wrapper for pooled object

---
 .../ItemManager.CompeltionListUpdater.cs      | 137 +++++++++++-------
 .../AsyncCompletion/ItemManager.cs            |   2 +-
 2 files changed, 84 insertions(+), 55 deletions(-)

diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs
index 9e9a0451edaf7..acd522ebe2878 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs
@@ -27,7 +27,7 @@ namespace Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.AsyncComplet
 {
     internal partial class ItemManager
     {
-        private sealed class CompletionListUpdater : IDisposable
+        private sealed class CompletionListUpdater
         {
             private IAsyncCompletionSession Session { get; }
             private AsyncCompletionSessionDataSnapshot Data { get; }
@@ -44,8 +44,6 @@ private sealed class CompletionListUpdater : IDisposable
             private CompletionHelper CompletionHelper { get; }
             private bool HighlightMatchingPortions { get; }
 
-            private List<MatchResult<VSCompletionItem>> ItemsToBeIncluded { get; }
-
             private CompletionTriggerReason TriggerReason => Data.Trigger.Reason;
             private CompletionFilterReason FilterReason => Helpers.GetFilterReason(Data.Trigger);
 
@@ -57,14 +55,6 @@ private sealed class CompletionListUpdater : IDisposable
             // For telemetry
             private readonly object _targetTypeCompletionFilterChosenMarker = new();
 
-            // We might need to handle large amount of items with import completion enabled,
-            // so use a dedicated pool to minimize/avoid array allocations (especially in LOH)
-            // Set the size of pool to 1 because we don't expect UpdateCompletionListAsync to be
-            // called concurrently, which essentially makes the pooled list a singleton,
-            // but we still use ObjectPool for concurrency handling just to be robust.
-            private static readonly ObjectPool<List<MatchResult<VSCompletionItem>>> s_listOfMatchResultPool
-                    = new(factory: () => new(), size: 1);
-
             // PERF: Create a singleton to avoid lambda allocation on hot path
             private static readonly Func<TextSpan, RoslynCompletionItem, Span> s_highlightSpanGetter
                 = (span, item) => span.MoveTo(item.DisplayTextPrefix?.Length ?? 0).ToSpan();
@@ -112,7 +102,6 @@ public CompletionListUpdater(
                 HighlightMatchingPortions = FilterText.Length > 0
                     && GlobalOptions.GetOption(CompletionViewOptions.HighlightMatchingPortionsOfCompletionListItems, Document?.Project.Language);
 
-                ItemsToBeIncluded = s_listOfMatchResultPool.Allocate();
             }
 
             public FilteredCompletionModel? UpdateCompletionList()
@@ -120,24 +109,24 @@ public CompletionListUpdater(
                 if (ShouldDismissCompletionListImmediately())
                     return null;
 
-                ComputeItemsToBeIncluded();
+                using var _ = ComputeItemsToBeIncluded(out var itemsToBeIncluded);
 
-                if (ItemsToBeIncluded.Count == 0)
+                if (itemsToBeIncluded.Count == 0)
                     return HandleAllItemsFilteredOut();
 
                 var initialSelection = InitialRoslynTriggerKind == CompletionTriggerKind.Deletion
-                    ? HandleDeletionTrigger()
-                    : HandleNormalFiltering();
+                    ? HandleDeletionTrigger(itemsToBeIncluded)
+                    : HandleNormalFiltering(itemsToBeIncluded);
 
                 if (!initialSelection.HasValue)
                     return null;
 
-                var finalSelection = UpdateSelectionWithSuggestedDefaults(initialSelection.Value);
+                var finalSelection = UpdateSelectionWithSuggestedDefaults(itemsToBeIncluded, initialSelection.Value);
 
                 return new FilteredCompletionModel(
-                    items: GetHighlightedList(),
+                    items: GetHighlightedList(itemsToBeIncluded),
                     finalSelection.SelectedItemIndex,
-                    filters: GetUpdatedFilters(),
+                    filters: GetUpdatedFilters(itemsToBeIncluded),
                     finalSelection.SelectionHint,
                     centerSelection: true,
                     finalSelection.UniqueItem);
@@ -182,8 +171,10 @@ static bool IsAfterDot(ITextSnapshot snapshot, ITrackingSpan applicableToSpan)
                 }
             }
 
-            private void ComputeItemsToBeIncluded()
+            private IDisposable ComputeItemsToBeIncluded(out IReadOnlyList<MatchResult<VSCompletionItem>> itemsToBeIncluded)
             {
+                var disposer = PooledListForMatchResult.CreateInstance(out var list);
+
                 // We need to filter if 
                 // 1. a non-empty strict subset of filters are selected
                 // 2. a non-empty set of expanders are unselected
@@ -232,7 +223,7 @@ private void ComputeItemsToBeIncluded()
                         InitialRoslynTriggerKind, FilterReason, RecentItemsManager.RecentItems, HighlightMatchingPortions, currentIndex,
                         out var matchResult))
                     {
-                        ItemsToBeIncluded.Add(matchResult);
+                        list.Add(matchResult);
                         currentIndex++;
                     }
                 }
@@ -241,7 +232,10 @@ private void ComputeItemsToBeIncluded()
                 // Note that we want to preserve the original alphabetical order for items with same pattern match score,
                 // but `List<T>.Sort` isn't stable. Therefore we have to add a monotonically increasing integer
                 // to `MatchResult` to achieve this.
-                ItemsToBeIncluded.Sort(MatchResult<VSCompletionItem>.SortingComparer);
+                list.Sort(MatchResult<VSCompletionItem>.SortingComparer);
+
+                itemsToBeIncluded = list;
+                return disposer;
 
                 static bool ShouldBeFilteredOutOfCompletionList(VSCompletionItem item, ImmutableArray<CompletionFilter> activeNonExpanderFilters)
                     => !item.Filters.Any(filter => activeNonExpanderFilters.Contains(filter));
@@ -270,14 +264,14 @@ static bool ShouldBeFilteredOutOfExpandedCompletionList(VSCompletionItem item, I
                 }
             }
 
-            private ItemSelection UpdateSelectionWithSuggestedDefaults(ItemSelection itemSelection)
+            private ItemSelection UpdateSelectionWithSuggestedDefaults(IReadOnlyList<MatchResult<VSCompletionItem>> items, ItemSelection itemSelection)
             {
                 // Editor doesn't provide us a list of "default" items.
                 if (Data.Defaults.IsDefaultOrEmpty)
                     return itemSelection;
 
                 // "Preselect" is only used when we have high confidence with the selection, so don't override it.
-                var selectedItem = ItemsToBeIncluded[itemSelection.SelectedItemIndex].RoslynCompletionItem;
+                var selectedItem = items[itemSelection.SelectedItemIndex].RoslynCompletionItem;
                 if (selectedItem.Rules.MatchPriority >= MatchPriority.Preselect)
                     return itemSelection;
 
@@ -285,20 +279,20 @@ private ItemSelection UpdateSelectionWithSuggestedDefaults(ItemSelection itemSel
 
                 var useAggressiveDefaultsMatching = Session.TextView.Options.GetOptionValue<bool>(AggressiveDefaultsMatchingOptionName);
                 var finalSelection = useAggressiveDefaultsMatching
-                    ? GetAggressiveDefaultsMatch(itemSelection)
-                    : GetDefaultsMatch(itemSelection);
+                    ? GetAggressiveDefaultsMatch(items, itemSelection)
+                    : GetDefaultsMatch(items, itemSelection);
 
                 AsyncCompletionLogger.LogGetDefaultsMatchTicksDataPoint(Environment.TickCount - tick);
                 return finalSelection;
             }
 
-            private ItemSelection? HandleNormalFiltering()
+            private ItemSelection? HandleNormalFiltering(IReadOnlyList<MatchResult<VSCompletionItem>> items)
             {
                 // Not deletion.  Defer to the language to decide which item it thinks best
                 // matches the text typed so far.
 
                 // Ask the language to determine which of the *matched* items it wants to select.
-                var matchingItems = ItemsToBeIncluded.Where(r => r.MatchedFilterText)
+                var matchingItems = items.Where(r => r.MatchedFilterText)
                                                .SelectAsArray(t => (t.RoslynCompletionItem, t.PatternMatch));
 
                 var chosenItems = FilterMethod(matchingItems, FilterText);
@@ -311,13 +305,13 @@ private ItemSelection UpdateSelectionWithSuggestedDefaults(ItemSelection itemSel
                 {
                     // We do not have matches: pick the one with longest common prefix or the first item from the list.
                     selectedItemIndex = 0;
-                    bestOrFirstMatchResult = ItemsToBeIncluded[0];
+                    bestOrFirstMatchResult = items[0];
 
                     var longestCommonPrefixLength = bestOrFirstMatchResult.RoslynCompletionItem.FilterText.GetCaseInsensitivePrefixLength(FilterText);
 
-                    for (var i = 1; i < ItemsToBeIncluded.Count; ++i)
+                    for (var i = 1; i < items.Count; ++i)
                     {
-                        var item = ItemsToBeIncluded[i];
+                        var item = items[i];
                         var commonPrefixLength = item.RoslynCompletionItem.FilterText.GetCaseInsensitivePrefixLength(FilterText);
 
                         if (commonPrefixLength > longestCommonPrefixLength)
@@ -342,13 +336,20 @@ private ItemSelection UpdateSelectionWithSuggestedDefaults(ItemSelection itemSel
                     // typed.  i.e.  if we have "Console.$$" we don't want to commit something
                     // like "WriteLine" since no filter text has actually been provided.  However,
                     // if "Console.WriteL$$" is typed, then we do want "WriteLine" to be committed.
-                    selectedItemIndex = ItemsToBeIncluded.IndexOf(i => Equals(i.RoslynCompletionItem, bestItem));
-                    bestOrFirstMatchResult = ItemsToBeIncluded[selectedItemIndex];
+                    for (selectedItemIndex = 0; selectedItemIndex < items.Count; ++selectedItemIndex)
+                    {
+                        if (Equals(items[selectedItemIndex].RoslynCompletionItem, bestItem))
+                            break;
+                    }
+
+                    Debug.Assert(selectedItemIndex < items.Count);
+
+                    bestOrFirstMatchResult = items[selectedItemIndex];
                     var deduplicatedListCount = matchingItems.Count(r => !r.RoslynCompletionItem.IsPreferredItem());
                     if (deduplicatedListCount == 1 &&
                         FilterText.Length > 0)
                     {
-                        uniqueItem = ItemsToBeIncluded[selectedItemIndex].EditorCompletionItem;
+                        uniqueItem = items[selectedItemIndex].EditorCompletionItem;
                     }
                 }
 
@@ -376,9 +377,9 @@ private ItemSelection UpdateSelectionWithSuggestedDefaults(ItemSelection itemSel
                 return new(selectedItemIndex, updateSelectionHint, uniqueItem);
             }
 
-            private ItemSelection? HandleDeletionTrigger()
+            private ItemSelection? HandleDeletionTrigger(IReadOnlyList<MatchResult<VSCompletionItem>> items)
             {
-                var matchingItems = ItemsToBeIncluded.Where(r => r.MatchedFilterText);
+                var matchingItems = items.Where(r => r.MatchedFilterText);
                 if (TriggerReason == CompletionTriggerReason.Insertion &&
                     !matchingItems.Any())
                 {
@@ -431,7 +432,7 @@ private ItemSelection UpdateSelectionWithSuggestedDefaults(ItemSelection itemSel
                     // * deleting through a word from the end keeps that word selected
                     // This also preserves the behavior the VB had through Dev12.
                     hardSelect = !HasSuggestedItemOptions && bestMatchResult.Value.EditorCompletionItem.FilterText.StartsWith(FilterText, StringComparison.CurrentCultureIgnoreCase);
-                    index = ItemsToBeIncluded.IndexOf(bestMatchResult.Value);
+                    index = items.IndexOf(bestMatchResult.Value);
                 }
                 else
                 {
@@ -444,9 +445,9 @@ private ItemSelection UpdateSelectionWithSuggestedDefaults(ItemSelection itemSel
                     moreThanOneMatchWithSamePriority ? null : bestMatchResult.GetValueOrDefault().EditorCompletionItem);
             }
 
-            private ImmutableArray<CompletionItemWithHighlight> GetHighlightedList()
+            private ImmutableArray<CompletionItemWithHighlight> GetHighlightedList(IReadOnlyList<MatchResult<VSCompletionItem>> items)
             {
-                return ItemsToBeIncluded.SelectAsArray(matchResult =>
+                return items.SelectAsArray(matchResult =>
                 {
                     var highlightedSpans = GetHighlightedSpans(matchResult, CompletionHelper, FilterText, HighlightMatchingPortions);
                     return new CompletionItemWithHighlight(matchResult.EditorCompletionItem, highlightedSpans);
@@ -512,7 +513,7 @@ static ImmutableArray<Span> GetHighlightedSpans(
                     Data.SelectedFilters, selection, centerSelection: true, uniqueItem: null);
             }
 
-            private ImmutableArray<CompletionFilterWithState> GetUpdatedFilters()
+            private ImmutableArray<CompletionFilterWithState> GetUpdatedFilters(IReadOnlyList<MatchResult<VSCompletionItem>> items)
             {
                 var showCompletionItemFilters = GlobalOptions.GetOption(CompletionViewOptions.ShowCompletionItemFilters, Document?.Project.Language);
                 if (!showCompletionItemFilters)
@@ -520,7 +521,7 @@ private ImmutableArray<CompletionFilterWithState> GetUpdatedFilters()
 
                 // See which filters might be enabled based on the typed code
                 using var _ = PooledHashSet<CompletionFilter>.GetInstance(out var textFilteredFilters);
-                textFilteredFilters.AddRange(ItemsToBeIncluded.SelectMany(n => n.EditorCompletionItem.Filters));
+                textFilteredFilters.AddRange(items.SelectMany(n => n.EditorCompletionItem.Filters));
 
                 // When no items are available for a given filter, it becomes unavailable.
                 // Expanders always appear available as long as it's presented.
@@ -685,13 +686,13 @@ private static bool IsPotentialFilterCharacter(char c)
                     || c == '_';
             }
 
-            private ItemSelection GetAggressiveDefaultsMatch(ItemSelection intialSelection)
+            private ItemSelection GetAggressiveDefaultsMatch(IReadOnlyList<MatchResult<VSCompletionItem>> items, ItemSelection intialSelection)
             {
                 foreach (var defaultText in Data.Defaults)
                 {
-                    for (var i = 0; (i < ItemsToBeIncluded.Count); ++i)
+                    for (var i = 0; i < items.Count; ++i)
                     {
-                        var itemWithMatch = ItemsToBeIncluded[i];
+                        var itemWithMatch = items[i];
                         if (itemWithMatch.RoslynCompletionItem.FilterText != defaultText)
                             continue;
 
@@ -707,31 +708,31 @@ private ItemSelection GetAggressiveDefaultsMatch(ItemSelection intialSelection)
                 return intialSelection;
             }
 
-            private ItemSelection GetDefaultsMatch(ItemSelection intialSelection)
+            private ItemSelection GetDefaultsMatch(IReadOnlyList<MatchResult<VSCompletionItem>> items, ItemSelection intialSelection)
             {
                 int inferiorItemIndex;
                 if (FilterText.Length == 0)
                 {
                     // Without filterText, all items are eually good match, so we have to consider all of them.
-                    inferiorItemIndex = ItemsToBeIncluded.Count;
+                    inferiorItemIndex = items.Count;
                 }
                 else
                 {
                     // Because the items are sorted based on pattern-matching score, the selectedIndex is in the middle of a range of
                     // -- as far as the pattern matcher is concerned -- equivalent items. Find the last items in the range and use that
                     // to limit the items searched for from the defaults list.          
-                    var selectedItemMatch = ItemsToBeIncluded[intialSelection.SelectedItemIndex].PatternMatch;
+                    var selectedItemMatch = items[intialSelection.SelectedItemIndex].PatternMatch;
 
                     if (!selectedItemMatch.HasValue)
                         return intialSelection;
 
                     inferiorItemIndex = intialSelection.SelectedItemIndex;
-                    while (++inferiorItemIndex < ItemsToBeIncluded.Count)
+                    while (++inferiorItemIndex < items.Count)
                     {
                         // Ignore the case when trying to match the filter text with defaults.
                         // e.g. a default "Console" would be a match for filter text "c" and therefore to be selected,
                         // even if the CompletionService returns item "char" which is a case-sensitive prefix match.
-                        var itemMatch = ItemsToBeIncluded[inferiorItemIndex].PatternMatch;
+                        var itemMatch = items[inferiorItemIndex].PatternMatch;
                         if (!itemMatch.HasValue || itemMatch.Value.Kind != selectedItemMatch.Value.Kind)
                             break;
                     }
@@ -741,7 +742,7 @@ private ItemSelection GetDefaultsMatch(ItemSelection intialSelection)
                 {
                     for (var i = 0; i < inferiorItemIndex; ++i)
                     {
-                        if (ItemsToBeIncluded[i].RoslynCompletionItem.FilterText == defaultText)
+                        if (items[i].RoslynCompletionItem.FilterText == defaultText)
                             return intialSelection with { SelectedItemIndex = i };
                     }
                 }
@@ -749,11 +750,39 @@ private ItemSelection GetDefaultsMatch(ItemSelection intialSelection)
                 return intialSelection;
             }
 
-            public void Dispose()
+            private sealed class PooledListForMatchResult : IDisposable
             {
-                // Don't call ClearAndFree, which resets the capacity to a default value.
-                ItemsToBeIncluded.Clear();
-                s_listOfMatchResultPool.Free(ItemsToBeIncluded);
+                // We might need to handle large amount of items with import completion enabled,
+                // so use a dedicated pool to minimize/avoid array allocations (especially in LOH)
+                // Set the size of pool to 1 because we don't expect UpdateCompletionListAsync to be
+                // called concurrently, which essentially makes the pooled list a singleton,
+                // but we still use ObjectPool for concurrency handling just to be robust.
+                private static readonly ObjectPool<List<MatchResult<VSCompletionItem>>> s_listOfMatchResultPool
+                        = new(factory: () => new(), size: 1);
+
+                private List<MatchResult<VSCompletionItem>>? _list;
+
+                public static IDisposable CreateInstance(out List<MatchResult<VSCompletionItem>> list)
+                {
+                    list = s_listOfMatchResultPool.Allocate();
+                    return new PooledListForMatchResult(list);
+                }
+
+                private PooledListForMatchResult(List<MatchResult<VSCompletionItem>> list)
+                {
+                    _list = list;
+                }
+
+                public void Dispose()
+                {
+                    if (_list is not null)
+                    {
+                        // Don't call ClearAndFree, which resets the capacity to a default value.
+                        _list.Clear();
+                        s_listOfMatchResultPool.Free(_list);
+                        _list = null;
+                    }
+                }
             }
 
             private readonly record struct ItemSelection(int SelectedItemIndex, UpdateSelectionHint SelectionHint, VSCompletionItem? UniqueItem);
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
index ae24a0e6ac062..20ce843140bbc 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
@@ -54,7 +54,7 @@ public Task<ImmutableArray<VSCompletionItem>> SortCompletionListAsync(
             AsyncCompletionSessionDataSnapshot data,
             CancellationToken cancellationToken)
         {
-            using var updater = new CompletionListUpdater(session, data, _recentItemsManager, _globalOptions, cancellationToken);
+            var updater = new CompletionListUpdater(session, data, _recentItemsManager, _globalOptions, cancellationToken);
             return Task.FromResult(updater.UpdateCompletionList());
         }
 

From 2f200fa8e1baff662b4978728709ad245d96b24b Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Tue, 23 Nov 2021 17:52:29 -0800
Subject: [PATCH 084/444] Use DisplayText to match defaults

---
 .../AsyncCompletion/ItemManager.CompeltionListUpdater.cs    | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs
index acd522ebe2878..8d6e8156c91f4 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
@@ -693,7 +693,7 @@ private ItemSelection GetAggressiveDefaultsMatch(IReadOnlyList<MatchResult<VSCom
                     for (var i = 0; i < items.Count; ++i)
                     {
                         var itemWithMatch = items[i];
-                        if (itemWithMatch.RoslynCompletionItem.FilterText != defaultText)
+                        if (itemWithMatch.RoslynCompletionItem.DisplayText != defaultText)
                             continue;
 
                         if (itemWithMatch.PatternMatch != null && itemWithMatch.PatternMatch.Value.Kind > PatternMatchKind.Prefix)
@@ -742,7 +742,7 @@ private ItemSelection GetDefaultsMatch(IReadOnlyList<MatchResult<VSCompletionIte
                 {
                     for (var i = 0; i < inferiorItemIndex; ++i)
                     {
-                        if (items[i].RoslynCompletionItem.FilterText == defaultText)
+                        if (items[i].RoslynCompletionItem.DisplayText == defaultText)
                             return intialSelection with { SelectedItemIndex = i };
                     }
                 }

From d7920b762d51871e45a5944e1b235bed73cce933 Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Tue, 23 Nov 2021 17:53:20 -0800
Subject: [PATCH 085/444] Use CaseInsensitive match for defaults

---
 .../ItemManager.CompeltionListUpdater.cs      | 17 +++++---
 ...etionCommandHandlerTests_DefaultsSource.vb | 40 +++++++++++++------
 2 files changed, 40 insertions(+), 17 deletions(-)

diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs
index 8d6e8156c91f4..9c02a4a3e7563 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
@@ -686,12 +686,18 @@ private static bool IsPotentialFilterCharacter(char c)
                     || c == '_';
             }
 
+            // The aggressive mode exist to make it easier for IntelliCode to experiment with default matching algorithm, so this is
+            // not the default matching behavior we'd use.
             private ItemSelection GetAggressiveDefaultsMatch(IReadOnlyList<MatchResult<VSCompletionItem>> items, ItemSelection intialSelection)
             {
                 foreach (var defaultText in Data.Defaults)
                 {
                     for (var i = 0; i < items.Count; ++i)
                     {
+                        // Currently in aggressive mode, the first item matches a default will be selected
+                        // as long as the filter text is its prefix (case-insensitive).
+                        // e.g. a default "Console" would be a match for filter text "c" and therefore to be selected,
+                        // even if the CompletionService returns item "char" which is a case-sensitive prefix match.
                         var itemWithMatch = items[i];
                         if (itemWithMatch.RoslynCompletionItem.DisplayText != defaultText)
                             continue;
@@ -729,12 +735,13 @@ private ItemSelection GetDefaultsMatch(IReadOnlyList<MatchResult<VSCompletionIte
                     inferiorItemIndex = intialSelection.SelectedItemIndex;
                     while (++inferiorItemIndex < items.Count)
                     {
-                        // Ignore the case when trying to match the filter text with defaults.
-                        // e.g. a default "Console" would be a match for filter text "c" and therefore to be selected,
-                        // even if the CompletionService returns item "char" which is a case-sensitive prefix match.
                         var itemMatch = items[inferiorItemIndex].PatternMatch;
-                        if (!itemMatch.HasValue || itemMatch.Value.Kind != selectedItemMatch.Value.Kind)
+                        if (!itemMatch.HasValue
+                            || itemMatch.Value.Kind != selectedItemMatch.Value.Kind
+                            || itemMatch.Value.IsCaseSensitive != selectedItemMatch.Value.IsCaseSensitive)
+                        {
                             break;
+                        }
                     }
                 }
 
diff --git a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_DefaultsSource.vb b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_DefaultsSource.vb
index 0c35e1b22897a..4c4de9578bb4a 100644
--- a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_DefaultsSource.vb
+++ b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_DefaultsSource.vb
@@ -111,9 +111,9 @@ class My
             End Using
         End Function
 
-        <WpfFact, CombinatorialData>
+        <WpfTheory, CombinatorialData>
         <Trait(Traits.Feature, Traits.Features.Completion)>
-        Public Async Function SelectFirstMatchingDefaultOverCaseSensitiveEquallyGoodMatch1() As Task
+        Public Async Function TestCaseInsensitiveMatchingDefault(isAggressive As Boolean) As Task
             Using state = CreateTestState(
                               <Document>
 using NS1;
@@ -125,19 +125,27 @@ class C
     }
 }
                               </Document>)
+                If isAggressive Then
+                    state.TextView.Options.SetOptionValue(ItemManager.AggressiveDefaultsMatchingOptionName, True)
+                End If
 
                 state.SendInvokeCompletionList()
 
-                Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
-                Await state.AssertCompletionItemsContain("my", displayTextSuffix:="")
-                Await state.AssertSelectedCompletionItem("MyAB", isHardSelected:=True)
-
+                If isAggressive Then
+                    Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
+                    Await state.AssertCompletionItemsContain("my", displayTextSuffix:="")
+                    Await state.AssertSelectedCompletionItem("MyAB", isHardSelected:=True)
+                Else
+                    Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
+                    Await state.AssertCompletionItemsContain("MyAB", displayTextSuffix:="")
+                    Await state.AssertSelectedCompletionItem("my", isHardSelected:=True)
+                End If
             End Using
         End Function
 
-        <WpfFact, CombinatorialData>
+        <WpfTheory, CombinatorialData>
         <Trait(Traits.Feature, Traits.Features.Completion)>
-        Public Async Function SelectFirstMatchingDefaultOverCaseSensitiveEquallyGoodMatch2() As Task
+        Public Async Function TestCaseInsensitiveMatchingDefault2(isAggressive As Boolean) As Task
             Using state = CreateTestState(
                               <Document>
 using NS1;
@@ -149,13 +157,21 @@ class C
     }
 }
                               </Document>)
+                If isAggressive Then
+                    state.TextView.Options.SetOptionValue(ItemManager.AggressiveDefaultsMatchingOptionName, True)
+                End If
 
                 state.SendInvokeCompletionList()
 
-                Await state.AssertCompletionItemsContain("myA", displayTextSuffix:="")
-                Await state.AssertCompletionItemsContain("MyAB", displayTextSuffix:="")
-                Await state.AssertSelectedCompletionItem("MyA", isHardSelected:=True)
-
+                If isAggressive Then
+                    Await state.AssertCompletionItemsContain("myA", displayTextSuffix:="")
+                    Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
+                    Await state.AssertSelectedCompletionItem("MyAB", isHardSelected:=True)
+                Else
+                    Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
+                    Await state.AssertCompletionItemsContain("MyAB", displayTextSuffix:="")
+                    Await state.AssertSelectedCompletionItem("myA", isHardSelected:=True)
+                End If
             End Using
         End Function
 

From 37d1c3a1e63d07fda7901db5111738cd237d26c9 Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Mon, 29 Nov 2021 12:09:24 -0800
Subject: [PATCH 086/444] Replace private properties with fields

---
 .../ItemManager.CompeltionListUpdater.cs      | 150 +++++++++---------
 1 file changed, 75 insertions(+), 75 deletions(-)

diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs
index 9c02a4a3e7563..901ab164e6242 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs
@@ -29,28 +29,28 @@ internal partial class ItemManager
     {
         private sealed class CompletionListUpdater
         {
-            private IAsyncCompletionSession Session { get; }
-            private AsyncCompletionSessionDataSnapshot Data { get; }
-            private RecentItemsManager RecentItemsManager { get; }
-            private IGlobalOptionService GlobalOptions { get; }
-            private CancellationToken CancellationToken { get; }
-
-            private bool HasSuggestedItemOptions { get; }
-            private string FilterText { get; }
-            private CompletionTriggerKind InitialRoslynTriggerKind { get; }
-            private Document? Document { get; }
-            private CompletionService? CompletionService { get; }
-            private CompletionRules CompletionRules { get; }
-            private CompletionHelper CompletionHelper { get; }
-            private bool HighlightMatchingPortions { get; }
-
-            private CompletionTriggerReason TriggerReason => Data.Trigger.Reason;
-            private CompletionFilterReason FilterReason => Helpers.GetFilterReason(Data.Trigger);
+            private readonly IAsyncCompletionSession _session;
+            private readonly AsyncCompletionSessionDataSnapshot _data;
+            private readonly RecentItemsManager _recentItemsManager;
+            private readonly IGlobalOptionService _globalOptions;
+            private readonly CancellationToken _cancellationToken;
+
+            private readonly bool _hasSuggestedItemOptions;
+            private readonly string _filterText;
+            private readonly CompletionTriggerKind _initialRoslynTriggerKind;
+            private readonly Document? _document;
+            private readonly CompletionService? _completionService;
+            private readonly CompletionRules _completionRules;
+            private readonly CompletionHelper _completionHelper;
+            private readonly bool _highlightMatchingPortions;
+
+            private CompletionTriggerReason TriggerReason => _data.Trigger.Reason;
+            private CompletionFilterReason FilterReason => Helpers.GetFilterReason(_data.Trigger);
 
             private Func<ImmutableArray<(RoslynCompletionItem, PatternMatch?)>, string, ImmutableArray<RoslynCompletionItem>> FilterMethod
-                => CompletionService == null
-                    ? ((itemsWithPatternMatches, text) => CompletionService.FilterItems(CompletionHelper, itemsWithPatternMatches, text))
-                    : ((itemsWithPatternMatches, text) => CompletionService.FilterItems(Document!, itemsWithPatternMatches, text));
+                => _completionService == null
+                    ? ((itemsWithPatternMatches, text) => CompletionService.FilterItems(_completionHelper, itemsWithPatternMatches, text))
+                    : ((itemsWithPatternMatches, text) => _completionService.FilterItems(_document!, itemsWithPatternMatches, text));
 
             // For telemetry
             private readonly object _targetTypeCompletionFilterChosenMarker = new();
@@ -66,41 +66,41 @@ public CompletionListUpdater(
                 IGlobalOptionService globalOptions,
                 CancellationToken cancellationToken)
             {
-                Session = session;
-                Data = data;
-                RecentItemsManager = recentItemsManager;
-                GlobalOptions = globalOptions;
-                CancellationToken = cancellationToken;
+                _session = session;
+                _data = data;
+                _recentItemsManager = recentItemsManager;
+                _globalOptions = globalOptions;
+                _cancellationToken = cancellationToken;
 
-                FilterText = Session.ApplicableToSpan.GetText(Data.Snapshot);
-                InitialRoslynTriggerKind = Helpers.GetRoslynTriggerKind(Data.InitialTrigger);
+                _filterText = _session.ApplicableToSpan.GetText(_data.Snapshot);
+                _initialRoslynTriggerKind = Helpers.GetRoslynTriggerKind(_data.InitialTrigger);
 
-                if (!Session.Properties.TryGetProperty(CompletionSource.HasSuggestionItemOptions, out bool hasSuggestedItemOptions))
+                if (!_session.Properties.TryGetProperty(CompletionSource.HasSuggestionItemOptions, out bool hasSuggestedItemOptions))
                 {
                     // This is the scenario when the session is created out of Roslyn, in some other provider, e.g. in Debugger.
                     // For now, the default hasSuggestedItemOptions is false.
                     hasSuggestedItemOptions = false;
                 }
 
-                HasSuggestedItemOptions = hasSuggestedItemOptions || Data.DisplaySuggestionItem;
+                _hasSuggestedItemOptions = hasSuggestedItemOptions || _data.DisplaySuggestionItem;
 
                 // We prefer using the original snapshot, which should always be available from items provided by Roslyn's CompletionSource.
                 // Only use data.Snapshot in the theoretically possible but rare case when all items we are handling are from some non-Roslyn CompletionSource.
-                var snapshotForDocument = TryGetInitialTriggerLocation(Data, out var intialTriggerLocation)
+                var snapshotForDocument = TryGetInitialTriggerLocation(_data, out var intialTriggerLocation)
                     ? intialTriggerLocation.Snapshot
-                    : Data.Snapshot;
+                    : _data.Snapshot;
 
-                Document = snapshotForDocument?.TextBuffer.AsTextContainer().GetOpenDocumentInCurrentContext();
-                CompletionService = Document?.GetLanguageService<CompletionService>();
-                CompletionRules = CompletionService?.GetRules(CompletionOptions.From(Document!.Project)) ?? CompletionRules.Default;
+                _document = snapshotForDocument?.TextBuffer.AsTextContainer().GetOpenDocumentInCurrentContext();
+                _completionService = _document?.GetLanguageService<CompletionService>();
+                _completionRules = _completionService?.GetRules(CompletionOptions.From(_document!.Project)) ?? CompletionRules.Default;
 
                 // Let us make the completion Helper used for non-Roslyn items case-sensitive.
                 // We can change this if get requests from partner teams.
-                CompletionHelper = Document != null ? CompletionHelper.GetHelper(Document) : new CompletionHelper(isCaseSensitive: true);
+                _completionHelper = _document != null ? CompletionHelper.GetHelper(_document) : new CompletionHelper(isCaseSensitive: true);
 
                 // Nothing to highlight if user hasn't typed anything yet.
-                HighlightMatchingPortions = FilterText.Length > 0
-                    && GlobalOptions.GetOption(CompletionViewOptions.HighlightMatchingPortionsOfCompletionListItems, Document?.Project.Language);
+                _highlightMatchingPortions = _filterText.Length > 0
+                    && _globalOptions.GetOption(CompletionViewOptions.HighlightMatchingPortionsOfCompletionListItems, _document?.Project.Language);
 
             }
 
@@ -114,7 +114,7 @@ public CompletionListUpdater(
                 if (itemsToBeIncluded.Count == 0)
                     return HandleAllItemsFilteredOut();
 
-                var initialSelection = InitialRoslynTriggerKind == CompletionTriggerKind.Deletion
+                var initialSelection = _initialRoslynTriggerKind == CompletionTriggerKind.Deletion
                     ? HandleDeletionTrigger(itemsToBeIncluded)
                     : HandleNormalFiltering(itemsToBeIncluded);
 
@@ -145,7 +145,7 @@ private bool ShouldDismissCompletionListImmediately()
                 //
                 // We'll bring up the completion list here (as VB has completion on <space>).
                 // If the user then types '3', we don't want to match against Int32.
-                if (FilterText.Length > 0 && char.IsNumber(FilterText[0]) && !IsAfterDot(Data.Snapshot, Session.ApplicableToSpan))
+                if (_filterText.Length > 0 && char.IsNumber(_filterText[0]) && !IsAfterDot(_data.Snapshot, _session.ApplicableToSpan))
                 {
                     // Dismiss the session.
                     return true;
@@ -153,10 +153,10 @@ private bool ShouldDismissCompletionListImmediately()
 
                 // DismissIfLastCharacterDeleted should be applied only when started with Insertion, and then Deleted all characters typed.
                 // This conforms with the original VS 2010 behavior.
-                if (InitialRoslynTriggerKind == CompletionTriggerKind.Insertion &&
-                    Data.Trigger.Reason == CompletionTriggerReason.Backspace &&
-                    CompletionRules.DismissIfLastCharacterDeleted &&
-                    FilterText.Length == 0)
+                if (_initialRoslynTriggerKind == CompletionTriggerKind.Insertion &&
+                    _data.Trigger.Reason == CompletionTriggerReason.Backspace &&
+                    _completionRules.DismissIfLastCharacterDeleted &&
+                    _filterText.Length == 0)
                 {
                     // Dismiss the session
                     return true;
@@ -178,25 +178,25 @@ private IDisposable ComputeItemsToBeIncluded(out IReadOnlyList<MatchResult<VSCom
                 // We need to filter if 
                 // 1. a non-empty strict subset of filters are selected
                 // 2. a non-empty set of expanders are unselected
-                var nonExpanderFilterStates = Data.SelectedFilters.WhereAsArray(f => f.Filter is not CompletionExpander);
+                var nonExpanderFilterStates = _data.SelectedFilters.WhereAsArray(f => f.Filter is not CompletionExpander);
 
                 var selectedNonExpanderFilters = nonExpanderFilterStates.SelectAsArray(f => f.IsSelected, f => f.Filter);
                 var needToFilter = selectedNonExpanderFilters.Length > 0 && selectedNonExpanderFilters.Length < nonExpanderFilterStates.Length;
 
-                var unselectedExpanders = Data.SelectedFilters.SelectAsArray(f => !f.IsSelected && f.Filter is CompletionExpander, f => f.Filter);
+                var unselectedExpanders = _data.SelectedFilters.SelectAsArray(f => !f.IsSelected && f.Filter is CompletionExpander, f => f.Filter);
                 var needToFilterExpanded = unselectedExpanders.Length > 0;
 
-                if (Session.TextView.Properties.TryGetProperty(CompletionSource.TargetTypeFilterExperimentEnabled, out bool isExperimentEnabled) && isExperimentEnabled)
+                if (_session.TextView.Properties.TryGetProperty(CompletionSource.TargetTypeFilterExperimentEnabled, out bool isExperimentEnabled) && isExperimentEnabled)
                 {
                     // Telemetry: Want to know % of sessions with the "Target type matches" filter where that filter is actually enabled
                     if (needToFilter &&
-                        !Session.Properties.ContainsProperty(_targetTypeCompletionFilterChosenMarker) &&
+                        !_session.Properties.ContainsProperty(_targetTypeCompletionFilterChosenMarker) &&
                         selectedNonExpanderFilters.Any(f => f.DisplayText == FeaturesResources.Target_type_matches))
                     {
                         AsyncCompletionLogger.LogTargetTypeFilterChosenInSession();
 
                         // Make sure we only record one enabling of the filter per session
-                        Session.Properties.AddProperty(_targetTypeCompletionFilterChosenMarker, _targetTypeCompletionFilterChosenMarker);
+                        _session.Properties.AddProperty(_targetTypeCompletionFilterChosenMarker, _targetTypeCompletionFilterChosenMarker);
                     }
                 }
 
@@ -204,9 +204,9 @@ private IDisposable ComputeItemsToBeIncluded(out IReadOnlyList<MatchResult<VSCom
                 var currentIndex = 0;
 
                 // Filter items based on the selected filters and matching.
-                foreach (var item in Data.InitialSortedList)
+                foreach (var item in _data.InitialSortedList)
                 {
-                    CancellationToken.ThrowIfCancellationRequested();
+                    _cancellationToken.ThrowIfCancellationRequested();
 
                     if (needToFilter && ShouldBeFilteredOutOfCompletionList(item, selectedNonExpanderFilters))
                     {
@@ -219,8 +219,8 @@ private IDisposable ComputeItemsToBeIncluded(out IReadOnlyList<MatchResult<VSCom
                     }
 
                     var roslynItem = GetOrAddRoslynCompletionItem(item);
-                    if (CompletionHelper.TryCreateMatchResult(CompletionHelper, roslynItem, item, FilterText,
-                        InitialRoslynTriggerKind, FilterReason, RecentItemsManager.RecentItems, HighlightMatchingPortions, currentIndex,
+                    if (CompletionHelper.TryCreateMatchResult(_completionHelper, roslynItem, item, _filterText,
+                        _initialRoslynTriggerKind, FilterReason, _recentItemsManager.RecentItems, _highlightMatchingPortions, currentIndex,
                         out var matchResult))
                     {
                         list.Add(matchResult);
@@ -267,7 +267,7 @@ static bool ShouldBeFilteredOutOfExpandedCompletionList(VSCompletionItem item, I
             private ItemSelection UpdateSelectionWithSuggestedDefaults(IReadOnlyList<MatchResult<VSCompletionItem>> items, ItemSelection itemSelection)
             {
                 // Editor doesn't provide us a list of "default" items.
-                if (Data.Defaults.IsDefaultOrEmpty)
+                if (_data.Defaults.IsDefaultOrEmpty)
                     return itemSelection;
 
                 // "Preselect" is only used when we have high confidence with the selection, so don't override it.
@@ -277,7 +277,7 @@ private ItemSelection UpdateSelectionWithSuggestedDefaults(IReadOnlyList<MatchRe
 
                 var tick = Environment.TickCount;
 
-                var useAggressiveDefaultsMatching = Session.TextView.Options.GetOptionValue<bool>(AggressiveDefaultsMatchingOptionName);
+                var useAggressiveDefaultsMatching = _session.TextView.Options.GetOptionValue<bool>(AggressiveDefaultsMatchingOptionName);
                 var finalSelection = useAggressiveDefaultsMatching
                     ? GetAggressiveDefaultsMatch(items, itemSelection)
                     : GetDefaultsMatch(items, itemSelection);
@@ -295,7 +295,7 @@ private ItemSelection UpdateSelectionWithSuggestedDefaults(IReadOnlyList<MatchRe
                 var matchingItems = items.Where(r => r.MatchedFilterText)
                                                .SelectAsArray(t => (t.RoslynCompletionItem, t.PatternMatch));
 
-                var chosenItems = FilterMethod(matchingItems, FilterText);
+                var chosenItems = FilterMethod(matchingItems, _filterText);
 
                 int selectedItemIndex;
                 VSCompletionItem? uniqueItem = null;
@@ -307,12 +307,12 @@ private ItemSelection UpdateSelectionWithSuggestedDefaults(IReadOnlyList<MatchRe
                     selectedItemIndex = 0;
                     bestOrFirstMatchResult = items[0];
 
-                    var longestCommonPrefixLength = bestOrFirstMatchResult.RoslynCompletionItem.FilterText.GetCaseInsensitivePrefixLength(FilterText);
+                    var longestCommonPrefixLength = bestOrFirstMatchResult.RoslynCompletionItem.FilterText.GetCaseInsensitivePrefixLength(_filterText);
 
                     for (var i = 1; i < items.Count; ++i)
                     {
                         var item = items[i];
-                        var commonPrefixLength = item.RoslynCompletionItem.FilterText.GetCaseInsensitivePrefixLength(FilterText);
+                        var commonPrefixLength = item.RoslynCompletionItem.FilterText.GetCaseInsensitivePrefixLength(_filterText);
 
                         if (commonPrefixLength > longestCommonPrefixLength)
                         {
@@ -324,7 +324,7 @@ private ItemSelection UpdateSelectionWithSuggestedDefaults(IReadOnlyList<MatchRe
                 }
                 else
                 {
-                    var recentItems = RecentItemsManager.RecentItems;
+                    var recentItems = _recentItemsManager.RecentItems;
 
                     // Of the items the service returned, pick the one most recently committed
                     var bestItem = GetBestCompletionItemBasedOnMRU(chosenItems, recentItems);
@@ -347,13 +347,13 @@ private ItemSelection UpdateSelectionWithSuggestedDefaults(IReadOnlyList<MatchRe
                     bestOrFirstMatchResult = items[selectedItemIndex];
                     var deduplicatedListCount = matchingItems.Count(r => !r.RoslynCompletionItem.IsPreferredItem());
                     if (deduplicatedListCount == 1 &&
-                        FilterText.Length > 0)
+                        _filterText.Length > 0)
                     {
                         uniqueItem = items[selectedItemIndex].EditorCompletionItem;
                     }
                 }
 
-                var typedChar = Data.Trigger.Character;
+                var typedChar = _data.Trigger.Character;
 
                 // Check that it is a filter symbol. We can be called for a non-filter symbol.
                 // If inserting a non-filter character (neither
@@ -361,16 +361,16 @@ private ItemSelection UpdateSelectionWithSuggestedDefaults(IReadOnlyList<MatchRe
                 // except cases where this is the first symbol typed for the completion session (string.IsNullOrEmpty(filterText) or string.Equals(filterText, typeChar.ToString(), StringComparison.OrdinalIgnoreCase)).
                 // In the latter case, we should keep the completion because it was confirmed just before in InitializeCompletion.
                 if (FilterReason == CompletionFilterReason.Insertion &&
-                    !string.IsNullOrEmpty(FilterText) &&
-                    !string.Equals(FilterText, typedChar.ToString(), StringComparison.OrdinalIgnoreCase) &&
+                    !string.IsNullOrEmpty(_filterText) &&
+                    !string.Equals(_filterText, typedChar.ToString(), StringComparison.OrdinalIgnoreCase) &&
                     !IsPotentialFilterCharacter(typedChar) &&
-                    !Helpers.IsFilterCharacter(bestOrFirstMatchResult.RoslynCompletionItem, typedChar, FilterText))
+                    !Helpers.IsFilterCharacter(bestOrFirstMatchResult.RoslynCompletionItem, typedChar, _filterText))
                 {
                     return null;
                 }
 
                 var isHardSelection = IsHardSelection(
-                    FilterText, bestOrFirstMatchResult.RoslynCompletionItem, bestOrFirstMatchResult.MatchedFilterText, HasSuggestedItemOptions);
+                    _filterText, bestOrFirstMatchResult.RoslynCompletionItem, bestOrFirstMatchResult.MatchedFilterText, _hasSuggestedItemOptions);
 
                 var updateSelectionHint = isHardSelection ? UpdateSelectionHint.Selected : UpdateSelectionHint.SoftSelected;
 
@@ -403,7 +403,7 @@ private ItemSelection UpdateSelectionWithSuggestedDefaults(IReadOnlyList<MatchRe
                     }
                     else
                     {
-                        var match = currentMatchResult.CompareTo(bestMatchResult.Value, FilterText);
+                        var match = currentMatchResult.CompareTo(bestMatchResult.Value, _filterText);
                         if (match > 0)
                         {
                             moreThanOneMatchWithSamePriority = false;
@@ -431,7 +431,7 @@ private ItemSelection UpdateSelectionWithSuggestedDefaults(IReadOnlyList<MatchRe
                     //   text that originally appeared before the dot
                     // * deleting through a word from the end keeps that word selected
                     // This also preserves the behavior the VB had through Dev12.
-                    hardSelect = !HasSuggestedItemOptions && bestMatchResult.Value.EditorCompletionItem.FilterText.StartsWith(FilterText, StringComparison.CurrentCultureIgnoreCase);
+                    hardSelect = !_hasSuggestedItemOptions && bestMatchResult.Value.EditorCompletionItem.FilterText.StartsWith(_filterText, StringComparison.CurrentCultureIgnoreCase);
                     index = items.IndexOf(bestMatchResult.Value);
                 }
                 else
@@ -449,7 +449,7 @@ private ImmutableArray<CompletionItemWithHighlight> GetHighlightedList(IReadOnly
             {
                 return items.SelectAsArray(matchResult =>
                 {
-                    var highlightedSpans = GetHighlightedSpans(matchResult, CompletionHelper, FilterText, HighlightMatchingPortions);
+                    var highlightedSpans = GetHighlightedSpans(matchResult, _completionHelper, _filterText, _highlightMatchingPortions);
                     return new CompletionItemWithHighlight(matchResult.EditorCompletionItem, highlightedSpans);
                 });
 
@@ -493,7 +493,7 @@ static ImmutableArray<Span> GetHighlightedSpans(
                     // If the user was just typing, and the list went to empty *and* this is a 
                     // language that wants to dismiss on empty, then just return a null model
                     // to stop the completion session.
-                    if (CompletionRules.DismissIfEmpty)
+                    if (_completionRules.DismissIfEmpty)
                     {
                         return null;
                     }
@@ -510,12 +510,12 @@ static ImmutableArray<Span> GetHighlightedSpans(
 
                 return new FilteredCompletionModel(
                     ImmutableArray<CompletionItemWithHighlight>.Empty, selectedItemIndex: 0,
-                    Data.SelectedFilters, selection, centerSelection: true, uniqueItem: null);
+                    _data.SelectedFilters, selection, centerSelection: true, uniqueItem: null);
             }
 
             private ImmutableArray<CompletionFilterWithState> GetUpdatedFilters(IReadOnlyList<MatchResult<VSCompletionItem>> items)
             {
-                var showCompletionItemFilters = GlobalOptions.GetOption(CompletionViewOptions.ShowCompletionItemFilters, Document?.Project.Language);
+                var showCompletionItemFilters = _globalOptions.GetOption(CompletionViewOptions.ShowCompletionItemFilters, _document?.Project.Language);
                 if (!showCompletionItemFilters)
                     return ImmutableArray<CompletionFilterWithState>.Empty;
 
@@ -525,7 +525,7 @@ private ImmutableArray<CompletionFilterWithState> GetUpdatedFilters(IReadOnlyLis
 
                 // When no items are available for a given filter, it becomes unavailable.
                 // Expanders always appear available as long as it's presented.
-                return Data.SelectedFilters.SelectAsArray(n => n.WithAvailability(n.Filter is CompletionExpander || textFilteredFilters.Contains(n.Filter)));
+                return _data.SelectedFilters.SelectAsArray(n => n.WithAvailability(n.Filter is CompletionExpander || textFilteredFilters.Contains(n.Filter)));
             }
 
             /// <summary>
@@ -690,7 +690,7 @@ private static bool IsPotentialFilterCharacter(char c)
             // not the default matching behavior we'd use.
             private ItemSelection GetAggressiveDefaultsMatch(IReadOnlyList<MatchResult<VSCompletionItem>> items, ItemSelection intialSelection)
             {
-                foreach (var defaultText in Data.Defaults)
+                foreach (var defaultText in _data.Defaults)
                 {
                     for (var i = 0; i < items.Count; ++i)
                     {
@@ -705,7 +705,7 @@ private ItemSelection GetAggressiveDefaultsMatch(IReadOnlyList<MatchResult<VSCom
                         if (itemWithMatch.PatternMatch != null && itemWithMatch.PatternMatch.Value.Kind > PatternMatchKind.Prefix)
                             break;
 
-                        return HasSuggestedItemOptions
+                        return _hasSuggestedItemOptions
                             ? intialSelection with { SelectedItemIndex = i }
                             : intialSelection with { SelectedItemIndex = i, SelectionHint = UpdateSelectionHint.Selected };
                     }
@@ -717,7 +717,7 @@ private ItemSelection GetAggressiveDefaultsMatch(IReadOnlyList<MatchResult<VSCom
             private ItemSelection GetDefaultsMatch(IReadOnlyList<MatchResult<VSCompletionItem>> items, ItemSelection intialSelection)
             {
                 int inferiorItemIndex;
-                if (FilterText.Length == 0)
+                if (_filterText.Length == 0)
                 {
                     // Without filterText, all items are eually good match, so we have to consider all of them.
                     inferiorItemIndex = items.Count;
@@ -745,7 +745,7 @@ private ItemSelection GetDefaultsMatch(IReadOnlyList<MatchResult<VSCompletionIte
                     }
                 }
 
-                foreach (var defaultText in Data.Defaults)
+                foreach (var defaultText in _data.Defaults)
                 {
                     for (var i = 0; i < inferiorItemIndex; ++i)
                     {

From 21be9d3c784258636837909e5e38df828f2ff6ce Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Mon, 29 Nov 2021 14:50:45 -0800
Subject: [PATCH 087/444] Add more comments

---
 .../ItemManager.CompeltionListUpdater.cs      | 126 +++++++++++-------
 1 file changed, 80 insertions(+), 46 deletions(-)

diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs
index 901ab164e6242..f4f2e4432ff4e 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs
@@ -27,6 +27,10 @@ namespace Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.AsyncComplet
 {
     internal partial class ItemManager
     {
+        /// <summary>
+        /// Handles the filtering, sorting and selection of the completion items based on user inputs 
+        /// (e.g. typed characters, selected filters, etc.)
+        /// </summary>
         private sealed class CompletionListUpdater
         {
             private readonly IAsyncCompletionSession _session;
@@ -109,11 +113,17 @@ public CompletionListUpdater(
                 if (ShouldDismissCompletionListImmediately())
                     return null;
 
+                // Determine the list of items to be included in the completion list.
+                // This is computed based on the filter text as well as the current
+                // selection of filters and expander.
                 using var _ = ComputeItemsToBeIncluded(out var itemsToBeIncluded);
 
                 if (itemsToBeIncluded.Count == 0)
                     return HandleAllItemsFilteredOut();
 
+                // Decide the item to be selection for this completion session.
+                // This is mostly based on how well the item matches with the filter text, but we also need to
+                // take into consideration for things like CompletionTrigger, MatchPriority, MRU, etc. 
                 var initialSelection = _initialRoslynTriggerKind == CompletionTriggerKind.Deletion
                     ? HandleDeletionTrigger(itemsToBeIncluded)
                     : HandleNormalFiltering(itemsToBeIncluded);
@@ -121,7 +131,12 @@ public CompletionListUpdater(
                 if (!initialSelection.HasValue)
                     return null;
 
-                var finalSelection = UpdateSelectionWithSuggestedDefaults(itemsToBeIncluded, initialSelection.Value);
+                // Editor might provide a list of items to us as a suggestion to what to select for this session
+                // (via IAsyncCompletionDefaultsSource), where the "default" means the "default selection".
+                // The main scenario for this is to keep the selected item in completion list in sync with the
+                // suggestion of "Whole-Line Completion" feature, where the default is usually set to the first token
+                // of the WLC suggetion.
+                var finalSelection = UpdateSelectionBasedOnSuggestedDefaults(itemsToBeIncluded, initialSelection.Value);
 
                 return new FilteredCompletionModel(
                     items: GetHighlightedList(itemsToBeIncluded),
@@ -186,19 +201,7 @@ private IDisposable ComputeItemsToBeIncluded(out IReadOnlyList<MatchResult<VSCom
                 var unselectedExpanders = _data.SelectedFilters.SelectAsArray(f => !f.IsSelected && f.Filter is CompletionExpander, f => f.Filter);
                 var needToFilterExpanded = unselectedExpanders.Length > 0;
 
-                if (_session.TextView.Properties.TryGetProperty(CompletionSource.TargetTypeFilterExperimentEnabled, out bool isExperimentEnabled) && isExperimentEnabled)
-                {
-                    // Telemetry: Want to know % of sessions with the "Target type matches" filter where that filter is actually enabled
-                    if (needToFilter &&
-                        !_session.Properties.ContainsProperty(_targetTypeCompletionFilterChosenMarker) &&
-                        selectedNonExpanderFilters.Any(f => f.DisplayText == FeaturesResources.Target_type_matches))
-                    {
-                        AsyncCompletionLogger.LogTargetTypeFilterChosenInSession();
-
-                        // Make sure we only record one enabling of the filter per session
-                        _session.Properties.AddProperty(_targetTypeCompletionFilterChosenMarker, _targetTypeCompletionFilterChosenMarker);
-                    }
-                }
+                LogTargetTypeFilterTelemetry(selectedNonExpanderFilters, needToFilter);
 
                 // Use a monotonically increasing integer to keep track the original alphabetical order of each item.
                 var currentIndex = 0;
@@ -262,28 +265,23 @@ static bool ShouldBeFilteredOutOfExpandedCompletionList(VSCompletionItem item, I
                     // 2. or, all associated expanders are unselected, therefore should be excluded
                     return associatedWithUnselectedExpander;
                 }
-            }
-
-            private ItemSelection UpdateSelectionWithSuggestedDefaults(IReadOnlyList<MatchResult<VSCompletionItem>> items, ItemSelection itemSelection)
-            {
-                // Editor doesn't provide us a list of "default" items.
-                if (_data.Defaults.IsDefaultOrEmpty)
-                    return itemSelection;
-
-                // "Preselect" is only used when we have high confidence with the selection, so don't override it.
-                var selectedItem = items[itemSelection.SelectedItemIndex].RoslynCompletionItem;
-                if (selectedItem.Rules.MatchPriority >= MatchPriority.Preselect)
-                    return itemSelection;
-
-                var tick = Environment.TickCount;
 
-                var useAggressiveDefaultsMatching = _session.TextView.Options.GetOptionValue<bool>(AggressiveDefaultsMatchingOptionName);
-                var finalSelection = useAggressiveDefaultsMatching
-                    ? GetAggressiveDefaultsMatch(items, itemSelection)
-                    : GetDefaultsMatch(items, itemSelection);
+                void LogTargetTypeFilterTelemetry(ImmutableArray<CompletionFilter> selectedNonExpanderFilters, bool needToFilter)
+                {
+                    if (_session.TextView.Properties.TryGetProperty(CompletionSource.TargetTypeFilterExperimentEnabled, out bool isExperimentEnabled) && isExperimentEnabled)
+                    {
+                        // Telemetry: Want to know % of sessions with the "Target type matches" filter where that filter is actually enabled
+                        if (needToFilter &&
+                            !_session.Properties.ContainsProperty(_targetTypeCompletionFilterChosenMarker) &&
+                            selectedNonExpanderFilters.Any(f => f.DisplayText == FeaturesResources.Target_type_matches))
+                        {
+                            AsyncCompletionLogger.LogTargetTypeFilterChosenInSession();
 
-                AsyncCompletionLogger.LogGetDefaultsMatchTicksDataPoint(Environment.TickCount - tick);
-                return finalSelection;
+                            // Make sure we only record one enabling of the filter per session
+                            _session.Properties.AddProperty(_targetTypeCompletionFilterChosenMarker, _targetTypeCompletionFilterChosenMarker);
+                        }
+                    }
+                }
             }
 
             private ItemSelection? HandleNormalFiltering(IReadOnlyList<MatchResult<VSCompletionItem>> items)
@@ -356,9 +354,9 @@ private ItemSelection UpdateSelectionWithSuggestedDefaults(IReadOnlyList<MatchRe
                 var typedChar = _data.Trigger.Character;
 
                 // Check that it is a filter symbol. We can be called for a non-filter symbol.
-                // If inserting a non-filter character (neither
-                // , nor Helpers.IsFilterCharacter), we should dismiss completion  
-                // except cases where this is the first symbol typed for the completion session (string.IsNullOrEmpty(filterText) or string.Equals(filterText, typeChar.ToString(), StringComparison.OrdinalIgnoreCase)).
+                // If inserting a non-filter character (neither IsPotentialFilterCharacter, nor Helpers.IsFilterCharacter),
+                // we should dismiss completion except cases where this is the first symbol typed for the completion session
+                // (string.IsNullOrEmpty(filterText) or string.Equals(filterText, typeChar.ToString(), StringComparison.OrdinalIgnoreCase)).
                 // In the latter case, we should keep the completion because it was confirmed just before in InitializeCompletion.
                 if (FilterReason == CompletionFilterReason.Insertion &&
                     !string.IsNullOrEmpty(_filterText) &&
@@ -686,8 +684,35 @@ private static bool IsPotentialFilterCharacter(char c)
                     || c == '_';
             }
 
-            // The aggressive mode exist to make it easier for IntelliCode to experiment with default matching algorithm, so this is
-            // not the default matching behavior we'd use.
+            private ItemSelection UpdateSelectionBasedOnSuggestedDefaults(IReadOnlyList<MatchResult<VSCompletionItem>> items, ItemSelection itemSelection)
+            {
+                // Editor doesn't provide us a list of "default" items.
+                if (_data.Defaults.IsDefaultOrEmpty)
+                    return itemSelection;
+
+                // "Preselect" is only used when we have high confidence with the selection, so don't override it.
+                var selectedItem = items[itemSelection.SelectedItemIndex].RoslynCompletionItem;
+                if (selectedItem.Rules.MatchPriority >= MatchPriority.Preselect)
+                    return itemSelection;
+
+                var tick = Environment.TickCount;
+
+                var useAggressiveDefaultsMatching = _session.TextView.Options.GetOptionValue<bool>(AggressiveDefaultsMatchingOptionName);
+
+                var finalSelection = useAggressiveDefaultsMatching
+                    ? GetAggressiveDefaultsMatch(items, itemSelection)
+                    : GetDefaultsMatch(items, itemSelection);
+
+                AsyncCompletionLogger.LogGetDefaultsMatchTicksDataPoint(Environment.TickCount - tick);
+                return finalSelection;
+            }
+
+            /// <summary>
+            /// With aggressive matching turned on, the default was use as long as what the user typed in the applicable to span
+            /// was a case-insensitive prefix of the item.
+            /// The aggressive mode exist to make it easier for IntelliCode to experiment with default matching algorithm, so this is
+            /// not the default matching behavior we'd use and subject to further adjustment.
+            /// </summary>
             private ItemSelection GetAggressiveDefaultsMatch(IReadOnlyList<MatchResult<VSCompletionItem>> items, ItemSelection intialSelection)
             {
                 foreach (var defaultText in _data.Defaults)
@@ -696,8 +721,8 @@ private ItemSelection GetAggressiveDefaultsMatch(IReadOnlyList<MatchResult<VSCom
                     {
                         // Currently in aggressive mode, the first item matches a default will be selected
                         // as long as the filter text is its prefix (case-insensitive).
-                        // e.g. a default "Console" would be a match for filter text "c" and therefore to be selected,
-                        // even if the CompletionService returns item "char" which is a case-sensitive prefix match.
+                        // e.g. a default "TaskCanceledException" would be a match for filter text "task" and therefore to be selected,
+                        // even if the CompletionService returns item for a local variable "task" which is an exact match.
                         var itemWithMatch = items[i];
                         if (itemWithMatch.RoslynCompletionItem.DisplayText != defaultText)
                             continue;
@@ -705,6 +730,7 @@ private ItemSelection GetAggressiveDefaultsMatch(IReadOnlyList<MatchResult<VSCom
                         if (itemWithMatch.PatternMatch != null && itemWithMatch.PatternMatch.Value.Kind > PatternMatchKind.Prefix)
                             break;
 
+                        // Always hard-select except in suggestion mode.
                         return _hasSuggestedItemOptions
                             ? intialSelection with { SelectedItemIndex = i }
                             : intialSelection with { SelectedItemIndex = i, SelectionHint = UpdateSelectionHint.Selected };
@@ -714,19 +740,26 @@ private ItemSelection GetAggressiveDefaultsMatch(IReadOnlyList<MatchResult<VSCom
                 return intialSelection;
             }
 
+            /// <summary>
+            /// Compare the pattern matching result of the current selection with the pattern matching result of the suggested defaults (both w.r.t. the filter text.)
+            /// If the suggested default is no worse than current selected item (in a case-sensitive manner,) use the suggested default. Otherwise use the original selection.
+            /// For example, if user typed "C", roslyn might select "CancellationToken", but with suggested default "Console" we will end up selecting "Console" instead.
+            /// </summary>
             private ItemSelection GetDefaultsMatch(IReadOnlyList<MatchResult<VSCompletionItem>> items, ItemSelection intialSelection)
             {
+                // Because the items are already sorted based on pattern-matching score, try to limit the range for the items we compare default with
+                // by searching for the first "inferior" item, so we can avoid always going through the entire list.
                 int inferiorItemIndex;
                 if (_filterText.Length == 0)
                 {
-                    // Without filterText, all items are eually good match, so we have to consider all of them.
+                    // Without filterText, all items are equally good match (w.r.t to the empty filterText), so we have to consider all of them.
                     inferiorItemIndex = items.Count;
                 }
                 else
                 {
                     // Because the items are sorted based on pattern-matching score, the selectedIndex is in the middle of a range of
-                    // -- as far as the pattern matcher is concerned -- equivalent items. Find the last items in the range and use that
-                    // to limit the items searched for from the defaults list.          
+                    // -- as far as the pattern matcher is concerned -- equivalent items (items with identical PatternMatch.Kind and IsCaseSensitive).
+                    // Find the last items in the range and use that to limit the items searched for from the defaults list.          
                     var selectedItemMatch = items[intialSelection.SelectedItemIndex].PatternMatch;
 
                     if (!selectedItemMatch.HasValue)
@@ -747,6 +780,8 @@ private ItemSelection GetDefaultsMatch(IReadOnlyList<MatchResult<VSCompletionIte
 
                 foreach (var defaultText in _data.Defaults)
                 {
+                    // The range includes all items that are as good of a match as what we intially selected (and in descending order of matching score)
+                    // so we just need to search for the first item that matches the suggested default.
                     for (var i = 0; i < inferiorItemIndex; ++i)
                     {
                         if (items[i].RoslynCompletionItem.DisplayText == defaultText)
@@ -764,8 +799,7 @@ private sealed class PooledListForMatchResult : IDisposable
                 // Set the size of pool to 1 because we don't expect UpdateCompletionListAsync to be
                 // called concurrently, which essentially makes the pooled list a singleton,
                 // but we still use ObjectPool for concurrency handling just to be robust.
-                private static readonly ObjectPool<List<MatchResult<VSCompletionItem>>> s_listOfMatchResultPool
-                        = new(factory: () => new(), size: 1);
+                private static readonly ObjectPool<List<MatchResult<VSCompletionItem>>> s_listOfMatchResultPool = new(factory: () => new(), size: 1);
 
                 private List<MatchResult<VSCompletionItem>>? _list;
 

From 8832f57d5e5399dd8b7959e2eb54ae387a8370a1 Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Mon, 29 Nov 2021 14:55:13 -0800
Subject: [PATCH 088/444] Fix file name

---
 ...peltionListUpdater.cs => ItemManager.CompletionListUpdater.cs} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/{ItemManager.CompeltionListUpdater.cs => ItemManager.CompletionListUpdater.cs} (100%)

diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
similarity index 100%
rename from src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompeltionListUpdater.cs
rename to src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs

From c8459afc174862f7e0c85595d9e330853cad44bd Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Mon, 29 Nov 2021 15:36:04 -0800
Subject: [PATCH 089/444] Extract helper class for filter items based on
 filter/expander buttons

---
 .../ItemManager.CompletionListUpdater.cs      | 148 ++++++++++--------
 1 file changed, 81 insertions(+), 67 deletions(-)

diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
index f4f2e4432ff4e..cca677864a96e 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
@@ -56,9 +56,6 @@ private sealed class CompletionListUpdater
                     ? ((itemsWithPatternMatches, text) => CompletionService.FilterItems(_completionHelper, itemsWithPatternMatches, text))
                     : ((itemsWithPatternMatches, text) => _completionService.FilterItems(_document!, itemsWithPatternMatches, text));
 
-            // For telemetry
-            private readonly object _targetTypeCompletionFilterChosenMarker = new();
-
             // PERF: Create a singleton to avoid lambda allocation on hot path
             private static readonly Func<TextSpan, RoslynCompletionItem, Span> s_highlightSpanGetter
                 = (span, item) => span.MoveTo(item.DisplayTextPrefix?.Length ?? 0).ToSpan();
@@ -121,8 +118,8 @@ public CompletionListUpdater(
                 if (itemsToBeIncluded.Count == 0)
                     return HandleAllItemsFilteredOut();
 
-                // Decide the item to be selection for this completion session.
-                // This is mostly based on how well the item matches with the filter text, but we also need to
+                // Decide the item to be selected for this completion session.
+                // The selection is mostly based on how well the item matches with the filter text, but we also need to
                 // take into consideration for things like CompletionTrigger, MatchPriority, MRU, etc. 
                 var initialSelection = _initialRoslynTriggerKind == CompletionTriggerKind.Deletion
                     ? HandleDeletionTrigger(itemsToBeIncluded)
@@ -190,18 +187,9 @@ private IDisposable ComputeItemsToBeIncluded(out IReadOnlyList<MatchResult<VSCom
             {
                 var disposer = PooledListForMatchResult.CreateInstance(out var list);
 
-                // We need to filter if 
-                // 1. a non-empty strict subset of filters are selected
-                // 2. a non-empty set of expanders are unselected
-                var nonExpanderFilterStates = _data.SelectedFilters.WhereAsArray(f => f.Filter is not CompletionExpander);
-
-                var selectedNonExpanderFilters = nonExpanderFilterStates.SelectAsArray(f => f.IsSelected, f => f.Filter);
-                var needToFilter = selectedNonExpanderFilters.Length > 0 && selectedNonExpanderFilters.Length < nonExpanderFilterStates.Length;
-
-                var unselectedExpanders = _data.SelectedFilters.SelectAsArray(f => !f.IsSelected && f.Filter is CompletionExpander, f => f.Filter);
-                var needToFilterExpanded = unselectedExpanders.Length > 0;
-
-                LogTargetTypeFilterTelemetry(selectedNonExpanderFilters, needToFilter);
+                // FilterStateHelper is used to decide wheter a given item should be included in the list based on the state of filter/expander buttons.
+                var filterHelper = new FilterStateHelper(_data.SelectedFilters);
+                filterHelper.LogTargetTypeFilterTelemetry(_session);
 
                 // Use a monotonically increasing integer to keep track the original alphabetical order of each item.
                 var currentIndex = 0;
@@ -211,15 +199,8 @@ private IDisposable ComputeItemsToBeIncluded(out IReadOnlyList<MatchResult<VSCom
                 {
                     _cancellationToken.ThrowIfCancellationRequested();
 
-                    if (needToFilter && ShouldBeFilteredOutOfCompletionList(item, selectedNonExpanderFilters))
-                    {
+                    if (filterHelper.ShouldBeFilteredOut(item))
                         continue;
-                    }
-
-                    if (needToFilterExpanded && ShouldBeFilteredOutOfExpandedCompletionList(item, unselectedExpanders))
-                    {
-                        continue;
-                    }
 
                     var roslynItem = GetOrAddRoslynCompletionItem(item);
                     if (CompletionHelper.TryCreateMatchResult(_completionHelper, roslynItem, item, _filterText,
@@ -240,48 +221,6 @@ private IDisposable ComputeItemsToBeIncluded(out IReadOnlyList<MatchResult<VSCom
                 itemsToBeIncluded = list;
                 return disposer;
 
-                static bool ShouldBeFilteredOutOfCompletionList(VSCompletionItem item, ImmutableArray<CompletionFilter> activeNonExpanderFilters)
-                    => !item.Filters.Any(filter => activeNonExpanderFilters.Contains(filter));
-
-                static bool ShouldBeFilteredOutOfExpandedCompletionList(VSCompletionItem item, ImmutableArray<CompletionFilter> unselectedExpanders)
-                {
-                    var associatedWithUnselectedExpander = false;
-                    foreach (var itemFilter in item.Filters)
-                    {
-                        if (itemFilter is CompletionExpander)
-                        {
-                            if (!unselectedExpanders.Contains(itemFilter))
-                            {
-                                // If any of the associated expander is selected, the item should be included in the expanded list.
-                                return false;
-                            }
-
-                            associatedWithUnselectedExpander = true;
-                        }
-                    }
-
-                    // at this point, the item either:
-                    // 1. has no expander filter, therefore should be included
-                    // 2. or, all associated expanders are unselected, therefore should be excluded
-                    return associatedWithUnselectedExpander;
-                }
-
-                void LogTargetTypeFilterTelemetry(ImmutableArray<CompletionFilter> selectedNonExpanderFilters, bool needToFilter)
-                {
-                    if (_session.TextView.Properties.TryGetProperty(CompletionSource.TargetTypeFilterExperimentEnabled, out bool isExperimentEnabled) && isExperimentEnabled)
-                    {
-                        // Telemetry: Want to know % of sessions with the "Target type matches" filter where that filter is actually enabled
-                        if (needToFilter &&
-                            !_session.Properties.ContainsProperty(_targetTypeCompletionFilterChosenMarker) &&
-                            selectedNonExpanderFilters.Any(f => f.DisplayText == FeaturesResources.Target_type_matches))
-                        {
-                            AsyncCompletionLogger.LogTargetTypeFilterChosenInSession();
-
-                            // Make sure we only record one enabling of the filter per session
-                            _session.Properties.AddProperty(_targetTypeCompletionFilterChosenMarker, _targetTypeCompletionFilterChosenMarker);
-                        }
-                    }
-                }
             }
 
             private ItemSelection? HandleNormalFiltering(IReadOnlyList<MatchResult<VSCompletionItem>> items)
@@ -826,6 +765,81 @@ public void Dispose()
                 }
             }
 
+            private sealed class FilterStateHelper
+            {
+                private readonly ImmutableArray<CompletionFilterWithState> _nonExpanderFilterStates;
+                private readonly ImmutableArray<CompletionFilter> _selectedNonExpanderFilters;
+                private readonly bool _needToFilter;
+                private readonly ImmutableArray<CompletionFilter> _unselectedExpanders;
+                private readonly bool _needToFilterExpanded;
+
+                // For telemetry
+                private readonly object _targetTypeCompletionFilterChosenMarker = new();
+
+                public FilterStateHelper(ImmutableArray<CompletionFilterWithState> filtersWithState)
+                {
+                    // We need to filter if 
+                    // 1. a non-empty strict subset of filters are selected
+                    // 2. a non-empty set of expanders are unselected
+                    _nonExpanderFilterStates = filtersWithState.WhereAsArray(f => f.Filter is not CompletionExpander);
+
+                    _selectedNonExpanderFilters = _nonExpanderFilterStates.SelectAsArray(f => f.IsSelected, f => f.Filter);
+                    _needToFilter = _selectedNonExpanderFilters.Length > 0 && _selectedNonExpanderFilters.Length < _nonExpanderFilterStates.Length;
+
+                    _unselectedExpanders = filtersWithState.SelectAsArray(f => !f.IsSelected && f.Filter is CompletionExpander, f => f.Filter);
+                    _needToFilterExpanded = _unselectedExpanders.Length > 0;
+                }
+
+                public bool ShouldBeFilteredOut(VSCompletionItem item)
+                    => ShouldBeFilteredOutOfCompletionList(item) && ShouldBeFilteredOutOfExpandedCompletionList(item);
+
+                private bool ShouldBeFilteredOutOfCompletionList(VSCompletionItem item)
+                    => _needToFilter && !item.Filters.Any(filter => _selectedNonExpanderFilters.Contains(filter));
+
+                private bool ShouldBeFilteredOutOfExpandedCompletionList(VSCompletionItem item)
+                {
+                    if (!_needToFilterExpanded)
+                        return false;
+
+                    var associatedWithUnselectedExpander = false;
+                    foreach (var itemFilter in item.Filters)
+                    {
+                        if (itemFilter is CompletionExpander)
+                        {
+                            if (!_unselectedExpanders.Contains(itemFilter))
+                            {
+                                // If any of the associated expander is selected, the item should be included in the expanded list.
+                                return false;
+                            }
+
+                            associatedWithUnselectedExpander = true;
+                        }
+                    }
+
+                    // at this point, the item either:
+                    // 1. has no expander filter, therefore should be included
+                    // 2. or, all associated expanders are unselected, therefore should be excluded
+                    return associatedWithUnselectedExpander;
+                }
+
+                public void LogTargetTypeFilterTelemetry(IAsyncCompletionSession session)
+                {
+                    if (session.TextView.Properties.TryGetProperty(CompletionSource.TargetTypeFilterExperimentEnabled, out bool isExperimentEnabled) && isExperimentEnabled)
+                    {
+                        // Telemetry: Want to know % of sessions with the "Target type matches" filter where that filter is actually enabled
+                        if (_needToFilter &&
+                            !session.Properties.ContainsProperty(_targetTypeCompletionFilterChosenMarker) &&
+                            _selectedNonExpanderFilters.Any(f => f.DisplayText == FeaturesResources.Target_type_matches))
+                        {
+                            AsyncCompletionLogger.LogTargetTypeFilterChosenInSession();
+
+                            // Make sure we only record one enabling of the filter per session
+                            session.Properties.AddProperty(_targetTypeCompletionFilterChosenMarker, _targetTypeCompletionFilterChosenMarker);
+                        }
+                    }
+                }
+            }
+
             private readonly record struct ItemSelection(int SelectedItemIndex, UpdateSelectionHint SelectionHint, VSCompletionItem? UniqueItem);
         }
     }

From 32f1726b0496356f7d3b68285dccd380bc70eda3 Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Mon, 29 Nov 2021 16:14:28 -0800
Subject: [PATCH 090/444] Cleanup tests

---
 ...etionCommandHandlerTests_DefaultsSource.vb | 131 ++++++------------
 1 file changed, 43 insertions(+), 88 deletions(-)

diff --git a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_DefaultsSource.vb b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_DefaultsSource.vb
index 4c4de9578bb4a..de692fbf24b5c 100644
--- a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_DefaultsSource.vb
+++ b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_DefaultsSource.vb
@@ -15,6 +15,8 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.IntelliSense
         <WpfTheory, CombinatorialData>
         <Trait(Traits.Feature, Traits.Features.Completion)>
         Public Async Function TestNoItemMatchesDefaults(isAggressive As Boolean) As Task
+            ' We are not adding the additional file which contains type MyAB and MyA
+            ' the the suggestion from default source doesn't match anything in the completion list.
             Using state = TestStateFactory.CreateCSharpTestState(
                               <Document>
 class C
@@ -33,7 +35,7 @@ class C
 
                 state.SendInvokeCompletionList()
 
-                Await state.AssertCompletionItemsDoNotContainAny("MyA", "MyB")
+                Await state.AssertCompletionItemsDoNotContainAny("MyAB", "MyA")
                 Await state.AssertSelectedCompletionItem("MyMethod", isHardSelected:=True)
 
             End Using
@@ -42,7 +44,7 @@ class C
         <WpfFact, CombinatorialData>
         <Trait(Traits.Feature, Traits.Features.Completion)>
         Public Async Function SelectFirstMatchingDefaultIfNoFilterText() As Task
-            Using state = CreateTestState(
+            Using state = CreateTestStateWithAdditionalDocument(
                               <Document>
 using NS1;
 class C
@@ -61,13 +63,13 @@ class C
 
         <WpfFact, CombinatorialData>
         <Trait(Traits.Feature, Traits.Features.Completion)>
-        Public Async Function SelectFirstMatchingDefaultWithFilterText() As Task
-            Using state = CreateTestState(
+        Public Async Function SelectFirstMatchingDefaultWithPrefixFilterText() As Task
+            Using state = CreateTestStateWithAdditionalDocument(
                               <Document>
 using NS1;
 class C
 {
-    void Method()
+    void MyMethod()
     {
         My$$
     }
@@ -75,85 +77,70 @@ class C
                               </Document>)
                 state.SendInvokeCompletionList()
                 Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
+                Await state.AssertCompletionItemsContain("MyMethod", displayTextSuffix:="")
                 Await state.AssertSelectedCompletionItem("MyAB", isHardSelected:=True)
             End Using
         End Function
 
-        <WpfTheory, CombinatorialData>
+        <WpfFact>
         <Trait(Traits.Feature, Traits.Features.Completion)>
-        Public Async Function TestAggressiveDefaultsMatching(isAggressive As Boolean) As Task
-            Using state = CreateTestState(
+        Public Async Function DoNotChangeSelectionIfBetterMatch_CaseSensivePrefix() As Task
+            Using state = CreateTestStateWithAdditionalDocument(
                               <Document>
 using NS1;
-class My
+class C
 {
-    void Method()
+    void Method(int my)
     {
-        My$$
+        m$$
     }
 }
                               </Document>)
-                If isAggressive Then
-                    state.TextView.Options.SetOptionValue(ItemManager.AggressiveDefaultsMatchingOptionName, True)
-                End If
 
                 state.SendInvokeCompletionList()
 
-                If isAggressive Then
-                    Await state.AssertCompletionItemsContain("My", displayTextSuffix:="")
-                    Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
-                    Await state.AssertSelectedCompletionItem("MyAB", isHardSelected:=True)
-                Else
-                    Await state.AssertCompletionItemsContain("MyAB", displayTextSuffix:="")
-                    Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
-                    Await state.AssertSelectedCompletionItem("My", isHardSelected:=True)
-                End If
+                Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
+                Await state.AssertCompletionItemsContain("MyAB", displayTextSuffix:="")
+                Await state.AssertSelectedCompletionItem("my", isHardSelected:=True)
+
             End Using
         End Function
 
-        <WpfTheory, CombinatorialData>
+        <WpfFact>
         <Trait(Traits.Feature, Traits.Features.Completion)>
-        Public Async Function TestCaseInsensitiveMatchingDefault(isAggressive As Boolean) As Task
-            Using state = CreateTestState(
+        Public Async Function DoNotChangeSelectionIfBetterMatch_ExactOverPrefix() As Task
+            Using state = CreateTestStateWithAdditionalDocument(
                               <Document>
 using NS1;
-class C
+class My
 {
-    void Method(int my)
+    void Method()
     {
-        m$$
+        My$$
     }
 }
                               </Document>)
-                If isAggressive Then
-                    state.TextView.Options.SetOptionValue(ItemManager.AggressiveDefaultsMatchingOptionName, True)
-                End If
 
                 state.SendInvokeCompletionList()
 
-                If isAggressive Then
-                    Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
-                    Await state.AssertCompletionItemsContain("my", displayTextSuffix:="")
-                    Await state.AssertSelectedCompletionItem("MyAB", isHardSelected:=True)
-                Else
-                    Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
-                    Await state.AssertCompletionItemsContain("MyAB", displayTextSuffix:="")
-                    Await state.AssertSelectedCompletionItem("my", isHardSelected:=True)
-                End If
+                Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
+                Await state.AssertCompletionItemsContain("MyAB", displayTextSuffix:="")
+                Await state.AssertSelectedCompletionItem("My", isHardSelected:=True)
+
             End Using
         End Function
 
         <WpfTheory, CombinatorialData>
         <Trait(Traits.Feature, Traits.Features.Completion)>
-        Public Async Function TestCaseInsensitiveMatchingDefault2(isAggressive As Boolean) As Task
-            Using state = CreateTestState(
+        Public Async Function DoNotChangeIfPreselection(isAggressive As Boolean) As Task
+            Using state = CreateTestStateWithAdditionalDocument(
                               <Document>
 using NS1;
 class C
 {
-    void Method(int myA)
+    void Method()
     {
-        myA$$
+        C x = new $$
     }
 }
                               </Document>)
@@ -163,70 +150,38 @@ class C
 
                 state.SendInvokeCompletionList()
 
-                If isAggressive Then
-                    Await state.AssertCompletionItemsContain("myA", displayTextSuffix:="")
-                    Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
-                    Await state.AssertSelectedCompletionItem("MyAB", isHardSelected:=True)
-                Else
-                    Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
-                    Await state.AssertCompletionItemsContain("MyAB", displayTextSuffix:="")
-                    Await state.AssertSelectedCompletionItem("myA", isHardSelected:=True)
-                End If
-            End Using
-        End Function
-
-        <WpfFact, CombinatorialData>
-        <Trait(Traits.Feature, Traits.Features.Completion)>
-        Public Async Function DoNotChangeSelectionIfBetterMatch() As Task
-            Using state = CreateTestState(
-                              <Document>
-using NS1;
-class C
-{
-    void Method(int my)
-    {
-        my$$
-    }
-}
-                              </Document>)
-
-                state.SendInvokeCompletionList()
-
                 Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
                 Await state.AssertCompletionItemsContain("MyAB", displayTextSuffix:="")
-                Await state.AssertSelectedCompletionItem("my", isHardSelected:=True)
-
+                ' "C" is an item with preselect priority
+                Await state.AssertSelectedCompletionItem("C", isHardSelected:=True)
             End Using
         End Function
 
-        <WpfTheory, CombinatorialData>
+        <WpfFact>
         <Trait(Traits.Feature, Traits.Features.Completion)>
-        Public Async Function DoNotChangeIfPreselection(isAggressive As Boolean) As Task
-            Using state = CreateTestState(
+        Public Async Function SelectAggressiveDefaultsWithPrefixMatchingOverExactMatch() As Task
+            Using state = CreateTestStateWithAdditionalDocument(
                               <Document>
 using NS1;
-class C
+class My
 {
     void Method()
     {
-        C x = new $$
+        My$$
     }
 }
                               </Document>)
-                If isAggressive Then
-                    state.TextView.Options.SetOptionValue(ItemManager.AggressiveDefaultsMatchingOptionName, True)
-                End If
 
+                state.TextView.Options.SetOptionValue(ItemManager.AggressiveDefaultsMatchingOptionName, True)
                 state.SendInvokeCompletionList()
 
+                Await state.AssertCompletionItemsContain("My", displayTextSuffix:="")
                 Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
-                Await state.AssertCompletionItemsContain("MyAB", displayTextSuffix:="")
-                ' "C" is an item with preselect priority
-                Await state.AssertSelectedCompletionItem("C", isHardSelected:=True)
+                Await state.AssertSelectedCompletionItem("MyAB", isHardSelected:=True)
             End Using
         End Function
 
-        Private Shared Function CreateTestState(documentElement As XElement) As TestState
+        Private Shared Function CreateTestStateWithAdditionalDocument(documentElement As XElement) As TestState
             Return TestStateFactory.CreateTestStateFromWorkspace(
                 <Workspace>
                     <Project Language="C#" LanguageVersion="Preview" CommonReferences="true">

From d53933d4600beeb8593226ebcfea3120f28b9ce1 Mon Sep 17 00:00:00 2001
From: Jinu <jinuj@microsoft.com>
Date: Thu, 11 Nov 2021 10:55:49 -0800
Subject: [PATCH 091/444] Fix merge conflicts

---
 ...ementalAnalyzer.StateManager.HostStates.cs | 20 ++++++++++--
 ...gnosticIncrementalAnalyzer.StateManager.cs | 32 ++++++++++++++++---
 .../EngineV2/DiagnosticIncrementalAnalyzer.cs |  2 +-
 3 files changed, 45 insertions(+), 9 deletions(-)

diff --git a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.HostStates.cs b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.HostStates.cs
index 763f80bc0cfc0..af1fe1edd92ab 100644
--- a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.HostStates.cs
+++ b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.HostStates.cs
@@ -15,15 +15,29 @@ internal partial class DiagnosticIncrementalAnalyzer
         private partial class StateManager
         {
             public IEnumerable<StateSet> GetAllHostStateSets()
-                => _hostAnalyzerStateMap.Values.SelectMany(v => v.OrderedStateSets);
+            {
+                var analyzerReferencesMap = _workspace.CurrentSolution.State.Analyzers.GetHostAnalyzerReferencesMap();
+                foreach (var (key, value) in _hostAnalyzerStateMap)
+                {
+                    if (key.AnalyzerReferences == analyzerReferencesMap)
+                    {
+                        foreach (var stateSet in value.OrderedStateSets)
+                        {
+                            yield return stateSet;
+                        }
+                    }
+                }
+            }
 
             private HostAnalyzerStateSets GetOrCreateHostStateSets(Project project, ProjectAnalyzerStateSets projectStateSets)
             {
-                var hostStateSets = ImmutableInterlocked.GetOrAdd(ref _hostAnalyzerStateMap, project.Language, CreateLanguageSpecificAnalyzerMap, project.Solution.State.Analyzers);
+                var key = new HostAnalyzerStateSetKey(project.Language, project.Solution.State.Analyzers.GetHostAnalyzerReferencesMap());
+                var hostStateSets = ImmutableInterlocked.GetOrAdd(ref _hostAnalyzerStateMap, key, CreateLanguageSpecificAnalyzerMap, project.Solution.State.Analyzers);
                 return hostStateSets.WithExcludedAnalyzers(projectStateSets.SkippedAnalyzersInfo.SkippedAnalyzers);
 
-                static HostAnalyzerStateSets CreateLanguageSpecificAnalyzerMap(string language, HostDiagnosticAnalyzers hostAnalyzers)
+                static HostAnalyzerStateSets CreateLanguageSpecificAnalyzerMap(HostAnalyzerStateSetKey arg, HostDiagnosticAnalyzers hostAnalyzers)
                 {
+                    var language = arg.Language;
                     var analyzersPerReference = hostAnalyzers.GetOrCreateHostDiagnosticAnalyzersPerReference(language);
 
                     var analyzerMap = CreateStateSetMap(language, analyzersPerReference.Values, includeFileContentLoadAnalyzer: true);
diff --git a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.cs b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.cs
index a20a81d9b4241..bf4720bef8668 100644
--- a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.cs
+++ b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.cs
@@ -7,6 +7,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
@@ -21,14 +22,14 @@ internal partial class DiagnosticIncrementalAnalyzer
         /// </summary>
         private partial class StateManager
         {
-            private readonly IPersistentStorageService _persistentStorageService;
+            private readonly Workspace _workspace;
             private readonly DiagnosticAnalyzerInfoCache _analyzerInfoCache;
 
             /// <summary>
             /// Analyzers supplied by the host (IDE). These are built-in to the IDE, the compiler, or from an installed IDE extension (VSIX). 
             /// Maps language name to the analyzers and their state.
             /// </summary>
-            private ImmutableDictionary<string, HostAnalyzerStateSets> _hostAnalyzerStateMap;
+            private ImmutableDictionary<HostAnalyzerStateSetKey, HostAnalyzerStateSets> _hostAnalyzerStateMap;
 
             /// <summary>
             /// Analyzers referenced by the project via a PackageReference.
@@ -40,12 +41,12 @@ private partial class StateManager
             /// </summary>
             public event EventHandler<ProjectAnalyzerReferenceChangedEventArgs>? ProjectAnalyzerReferenceChanged;
 
-            public StateManager(IPersistentStorageService persistentStorageService, DiagnosticAnalyzerInfoCache analyzerInfoCache)
+            public StateManager(Workspace workspace, DiagnosticAnalyzerInfoCache analyzerInfoCache)
             {
-                _persistentStorageService = persistentStorageService;
+                _workspace = workspace;
                 _analyzerInfoCache = analyzerInfoCache;
 
-                _hostAnalyzerStateMap = ImmutableDictionary<string, HostAnalyzerStateSets>.Empty;
+                _hostAnalyzerStateMap = ImmutableDictionary<HostAnalyzerStateSetKey, HostAnalyzerStateSets>.Empty;
                 _projectAnalyzerStateMap = new ConcurrentDictionary<ProjectId, ProjectAnalyzerStateSets>(concurrencyLevel: 2, capacity: 10);
             }
 
@@ -311,6 +312,27 @@ private void VerifyProjectDiagnosticStates(IEnumerable<StateSet> stateSets)
 
                 VerifyUniqueStateNames(hostStates.Concat(stateSets));
             }
+
+            private readonly struct HostAnalyzerStateSetKey : IEquatable<HostAnalyzerStateSetKey>
+            {
+                public HostAnalyzerStateSetKey(string language, ImmutableDictionary<object, AnalyzerReference> analyzerReferences)
+                {
+                    Language = language;
+                    AnalyzerReferences = analyzerReferences;
+                }
+
+                public string Language { get; }
+                public ImmutableDictionary<object, AnalyzerReference> AnalyzerReferences { get; }
+
+                public bool Equals(HostAnalyzerStateSetKey other)
+                    => Language == other.Language && AnalyzerReferences == other.AnalyzerReferences;
+
+                public override bool Equals(object? obj)
+                    => obj is HostAnalyzerStateSetKey key && Equals(key);
+
+                public override int GetHashCode()
+                    => Hash.Combine(Language.GetHashCode(), AnalyzerReferences.GetHashCode());
+            }
         }
     }
 }
diff --git a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.cs b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.cs
index 666167c6d3cfa..14eea29b7c6bc 100644
--- a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.cs
+++ b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.cs
@@ -56,7 +56,7 @@ public DiagnosticIncrementalAnalyzer(
 
             _correlationId = correlationId;
 
-            _stateManager = new StateManager(PersistentStorageService, analyzerInfoCache);
+            _stateManager = new StateManager(workspace, analyzerInfoCache);
             _stateManager.ProjectAnalyzerReferenceChanged += OnProjectAnalyzerReferenceChanged;
             _telemetry = new DiagnosticAnalyzerTelemetry();
 

From dd7dc6a63d5749f8da07c977f0e0cdafe291c660 Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Tue, 30 Nov 2021 10:59:40 -0800
Subject: [PATCH 092/444] Fix

---
 .../AsyncCompletion/ItemManager.CompletionListUpdater.cs        | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
index cca677864a96e..ef28a1c25879f 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
@@ -791,7 +791,7 @@ public FilterStateHelper(ImmutableArray<CompletionFilterWithState> filtersWithSt
                 }
 
                 public bool ShouldBeFilteredOut(VSCompletionItem item)
-                    => ShouldBeFilteredOutOfCompletionList(item) && ShouldBeFilteredOutOfExpandedCompletionList(item);
+                    => ShouldBeFilteredOutOfCompletionList(item) || ShouldBeFilteredOutOfExpandedCompletionList(item);
 
                 private bool ShouldBeFilteredOutOfCompletionList(VSCompletionItem item)
                     => _needToFilter && !item.Filters.Any(filter => _selectedNonExpanderFilters.Contains(filter));

From cd1121e5595b2196472e0242bd698c8dd349afbe Mon Sep 17 00:00:00 2001
From: Jon Fortescue <jofortes@microsoft.com>
Date: Tue, 30 Nov 2021 13:19:18 -0800
Subject: [PATCH 093/444] Get the last buildpool

---
 eng/pipelines/test-windows-job-single-machine.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/eng/pipelines/test-windows-job-single-machine.yml b/eng/pipelines/test-windows-job-single-machine.yml
index a854081d7dc1b..0c10f6cdc84ca 100644
--- a/eng/pipelines/test-windows-job-single-machine.yml
+++ b/eng/pipelines/test-windows-job-single-machine.yml
@@ -20,7 +20,7 @@ parameters:
   default: ''
 - name: queueName
   type: string
-  default: 'BuildPool.Windows.10.Amd64.Open'
+  default: 'Build.Windows.10.Amd64.Open'
 
 jobs:
 - job: ${{ parameters.jobName }}

From 9e66c4f19a611be18c3a5d61e1c95b24a30e115b Mon Sep 17 00:00:00 2001
From: Allison Chou <allichou@microsoft.com>
Date: Tue, 30 Nov 2021 15:51:19 -0800
Subject: [PATCH 094/444] Add parameter

---
 .../EngineV2/DiagnosticIncrementalAnalyzer.StateManager.cs    | 4 +++-
 .../Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.cs     | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.cs b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.cs
index bf4720bef8668..542056f712f55 100644
--- a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.cs
+++ b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.cs
@@ -23,6 +23,7 @@ internal partial class DiagnosticIncrementalAnalyzer
         private partial class StateManager
         {
             private readonly Workspace _workspace;
+            private readonly IPersistentStorageService _persistentStorageService;
             private readonly DiagnosticAnalyzerInfoCache _analyzerInfoCache;
 
             /// <summary>
@@ -41,8 +42,9 @@ private partial class StateManager
             /// </summary>
             public event EventHandler<ProjectAnalyzerReferenceChangedEventArgs>? ProjectAnalyzerReferenceChanged;
 
-            public StateManager(Workspace workspace, DiagnosticAnalyzerInfoCache analyzerInfoCache)
+            public StateManager(Workspace workspace, IPersistentStorageService persistentStorageService, DiagnosticAnalyzerInfoCache analyzerInfoCache)
             {
+                _persistentStorageService = persistentStorageService;
                 _workspace = workspace;
                 _analyzerInfoCache = analyzerInfoCache;
 
diff --git a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.cs b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.cs
index 14eea29b7c6bc..81853b0541728 100644
--- a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.cs
+++ b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.cs
@@ -56,7 +56,7 @@ public DiagnosticIncrementalAnalyzer(
 
             _correlationId = correlationId;
 
-            _stateManager = new StateManager(workspace, analyzerInfoCache);
+            _stateManager = new StateManager(workspace, PersistentStorageService, analyzerInfoCache);
             _stateManager.ProjectAnalyzerReferenceChanged += OnProjectAnalyzerReferenceChanged;
             _telemetry = new DiagnosticAnalyzerTelemetry();
 

From 24aa30264078006b32fa44af4f1cc458a2f6dd06 Mon Sep 17 00:00:00 2001
From: Jon Fortescue <jonfortescue@protonmail.com>
Date: Thu, 2 Dec 2021 10:38:22 -0800
Subject: [PATCH 095/444] Update azure-pipelines-integration-lsp.yml

Co-authored-by: Joey Robichaud <joseph.robichaud@microsoft.com>
---
 azure-pipelines-integration-lsp.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/azure-pipelines-integration-lsp.yml b/azure-pipelines-integration-lsp.yml
index 05d4db8879b5f..6428123c7d3ea 100644
--- a/azure-pipelines-integration-lsp.yml
+++ b/azure-pipelines-integration-lsp.yml
@@ -20,7 +20,7 @@ jobs:
 - job: VS_Integration_LSP
   pool:
     name: NetCore1ESPool-Svc-Public
-    demands: ImageOverride -equals Build.Windows.Amd64.VS2022.Pre.Open
+    demands: ImageOverride -equals Build.Windows.10.Amd64.VS2019.Open
   timeoutInMinutes: 135
 
   steps:

From 9af4b1ea76dcec1549c24f6f27758f9f703f29ab Mon Sep 17 00:00:00 2001
From: David Wengier <david.wengier@microsoft.com>
Date: Fri, 3 Dec 2021 08:43:42 +1100
Subject: [PATCH 096/444] Reference new debugger bits (#58051)

---
 eng/Versions.props                            |  2 +-
 .../PdbFileLocatorServiceTests.cs             |  4 +-
 .../PdbFileLocatorService.cs                  |  2 +-
 .../VisualStudioSymbolNavigationService.cs    |  2 +-
 .../PdbSourceDocument/SourceLinkService.cs    | 97 +++++++++++++++++++
 5 files changed, 103 insertions(+), 4 deletions(-)
 create mode 100644 src/VisualStudio/Core/Def/PdbSourceDocument/SourceLinkService.cs

diff --git a/eng/Versions.props b/eng/Versions.props
index 30018a673bb07..0cce79844368b 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -133,7 +133,7 @@
     <MicrosoftVisualStudioCompositionVersion>16.9.20</MicrosoftVisualStudioCompositionVersion>
     <MicrosoftVisualStudioCoreUtilityVersion>$(VisualStudioEditorNewPackagesVersion)</MicrosoftVisualStudioCoreUtilityVersion>
     <MicrosoftVisualStudioDebuggerUIInterfacesVersion>17.2.0-beta.21477.1</MicrosoftVisualStudioDebuggerUIInterfacesVersion>
-    <MicrosoftVisualStudioDebuggerContractsVersion>17.2.0-beta.21477.1</MicrosoftVisualStudioDebuggerContractsVersion>
+    <MicrosoftVisualStudioDebuggerContractsVersion>17.2.0-beta.21580.1</MicrosoftVisualStudioDebuggerContractsVersion>
     <MicrosoftVisualStudioDebuggerEngineimplementationVersion>17.0.1042805-preview</MicrosoftVisualStudioDebuggerEngineimplementationVersion>
     <MicrosoftVisualStudioDebuggerMetadataimplementationVersion>17.0.1042805-preview</MicrosoftVisualStudioDebuggerMetadataimplementationVersion>
     <MicrosoftVisualStudioDesignerInterfacesVersion>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftVisualStudioDesignerInterfacesVersion>
diff --git a/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbFileLocatorServiceTests.cs b/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbFileLocatorServiceTests.cs
index 872a5f14cbd59..f7e9cf1d44843 100644
--- a/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbFileLocatorServiceTests.cs
+++ b/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbFileLocatorServiceTests.cs
@@ -55,7 +55,9 @@ await RunTestAsync(async path =>
             {
                 MarkupTestFile.GetSpan(source, out var metadataSource, out var expectedSpan);
 
-                var (project, symbol) = await CompileAndFindSymbolAsync(path, Location.OnDisk, Location.OnDisk, metadataSource, c => c.GetMember("C.E"));
+                // Ideally we don't want to pass in true for windowsPdb here, and this is supposed to test that the service ignores non-portable PDBs when the debugger
+                // tells us they're not portable, but the debugger has a bug at the moment.
+                var (project, symbol) = await CompileAndFindSymbolAsync(path, Location.OnDisk, Location.OnDisk, metadataSource, c => c.GetMember("C.E"), windowsPdb: true);
 
                 // Move the PDB to a path that only our fake debugger service knows about
                 var pdbFilePath = Path.Combine(path, "SourceLink.pdb");
diff --git a/src/Features/Core/Portable/PdbSourceDocument/PdbFileLocatorService.cs b/src/Features/Core/Portable/PdbSourceDocument/PdbFileLocatorService.cs
index 2552ebc435811..e9e0f09816e61 100644
--- a/src/Features/Core/Portable/PdbSourceDocument/PdbFileLocatorService.cs
+++ b/src/Features/Core/Portable/PdbSourceDocument/PdbFileLocatorService.cs
@@ -63,7 +63,7 @@ public PdbFileLocatorService([Import(AllowDefault = true)] ISourceLinkService? s
 
                         // TODO: Support windows PDBs: https://github.com/dotnet/roslyn/issues/55834
                         // TODO: Log results from pdbResult.Log: https://github.com/dotnet/roslyn/issues/57352
-                        if (pdbResult is not null && pdbResult.IsPortablePdb)
+                        if (pdbResult is not null)
                         {
                             pdbStream = IOUtilities.PerformIO(() => File.OpenRead(pdbResult.PdbFilePath));
                             if (pdbStream is not null)
diff --git a/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioSymbolNavigationService.cs b/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioSymbolNavigationService.cs
index 9944ea1467559..f8d7f677a9ba0 100644
--- a/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioSymbolNavigationService.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioSymbolNavigationService.cs
@@ -116,7 +116,7 @@ public bool TryNavigateToSymbol(ISymbol symbol, Project project, OptionSet? opti
 
             // Generate new source or retrieve existing source for the symbol in question
             var allowDecompilation = _globalOptions.GetOption(FeatureOnOffOptions.NavigateToDecompiledSources);
-            var result = _metadataAsSourceFileService.GetGeneratedFileAsync(project, symbol, signaturesOnly: false, allowDecompilation, cancellationToken).WaitAndGetResult(cancellationToken);
+            var result = ThreadingContext.JoinableTaskFactory.Run(() => _metadataAsSourceFileService.GetGeneratedFileAsync(project, symbol, signaturesOnly: false, allowDecompilation, cancellationToken));
 
             var vsRunningDocumentTable4 = IServiceProviderExtensions.GetService<SVsRunningDocumentTable, IVsRunningDocumentTable4>(_serviceProvider);
             var fileAlreadyOpen = vsRunningDocumentTable4.IsMonikerValid(result.FilePath);
diff --git a/src/VisualStudio/Core/Def/PdbSourceDocument/SourceLinkService.cs b/src/VisualStudio/Core/Def/PdbSourceDocument/SourceLinkService.cs
new file mode 100644
index 0000000000000..3ee480ca0f0b8
--- /dev/null
+++ b/src/VisualStudio/Core/Def/PdbSourceDocument/SourceLinkService.cs
@@ -0,0 +1,97 @@
+// 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.Composition;
+using System.IO;
+using System.Reflection.PortableExecutable;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.PdbSourceDocument;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.VisualStudio.Debugger.Contracts.SourceLink;
+using Microsoft.VisualStudio.Debugger.Contracts.SymbolLocator;
+
+namespace Microsoft.VisualStudio.LanguageServices.PdbSourceDocument
+{
+    [Export(typeof(ISourceLinkService)), Shared]
+    internal class SourceLinkService : ISourceLinkService
+    {
+        private readonly IDebuggerSymbolLocatorService _debuggerSymbolLocatorService;
+        private readonly IDebuggerSourceLinkService _debuggerSourceLinkService;
+
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public SourceLinkService(IDebuggerSymbolLocatorService debuggerSymbolLocatorService, IDebuggerSourceLinkService debuggerSourceLinkService)
+        {
+            _debuggerSymbolLocatorService = debuggerSymbolLocatorService;
+            _debuggerSourceLinkService = debuggerSourceLinkService;
+        }
+
+        public async Task<PdbFilePathResult?> GetPdbFilePathAsync(string dllPath, PEReader peReader, IPdbSourceDocumentLogger? logger, CancellationToken cancellationToken)
+        {
+            var hasCodeViewEntry = false;
+            uint timeStamp = 0;
+            CodeViewDebugDirectoryData codeViewEntry = default;
+            using var _ = ArrayBuilder<PdbChecksum>.GetInstance(out var checksums);
+            foreach (var entry in peReader.ReadDebugDirectory())
+            {
+                if (entry.Type == DebugDirectoryEntryType.PdbChecksum)
+                {
+                    var checksum = peReader.ReadPdbChecksumDebugDirectoryData(entry);
+                    checksums.Add(new PdbChecksum(checksum.AlgorithmName, checksum.Checksum));
+                }
+                else if (entry.Type == DebugDirectoryEntryType.CodeView && entry.IsPortableCodeView)
+                {
+                    hasCodeViewEntry = true;
+                    timeStamp = entry.Stamp;
+                    codeViewEntry = peReader.ReadCodeViewDebugDirectoryData(entry);
+                }
+            }
+
+            if (!hasCodeViewEntry)
+                return null;
+
+            var pdbInfo = new SymbolLocatorPdbInfo(
+                Path.GetFileName(codeViewEntry.Path),
+                codeViewEntry.Guid,
+                (uint)codeViewEntry.Age,
+                timeStamp,
+                checksums.ToImmutable(),
+                dllPath,
+                codeViewEntry.Path);
+
+            var flags = SymbolLocatorSearchFlags.None; // TODO: Add option to specify ForceMsftSymbolServer and ForceNuGetSymbolServer: https://github.com/dotnet/roslyn/issues/55834
+            var result = await _debuggerSymbolLocatorService.LocateSymbolFileAsync(pdbInfo, flags, progress: null, cancellationToken).ConfigureAwait(false);
+
+            // TODO: Logging: https://github.com/dotnet/roslyn/issues/57352
+            if (result.Found && result.SymbolFilePath is not null)
+            {
+                return new PdbFilePathResult(
+                    result.SymbolFilePath,
+                    result.Status,
+                    result.Log,
+                    result.IsPortablePdb);
+            }
+
+            return null;
+        }
+
+        public async Task<SourceFilePathResult?> GetSourceFilePathAsync(string url, string relativePath, IPdbSourceDocumentLogger? logger, CancellationToken cancellationToken)
+        {
+            var result = await _debuggerSourceLinkService.GetSourceLinkAsync(url, relativePath, allowInteractiveLogin: false, cancellationToken).ConfigureAwait(false);
+
+            // TODO: Logging: https://github.com/dotnet/roslyn/issues/57352
+            if (result.Status == SourceLinkResultStatus.Succeeded && result.Path is not null)
+            {
+                return new SourceFilePathResult(
+                    result.Path,
+                    result.Log);
+            }
+
+            return null;
+        }
+    }
+}

From 327c5781161afe5952ab9b0feee9b5a1588f8bbe Mon Sep 17 00:00:00 2001
From: Allison Chou <allichou@microsoft.com>
Date: Thu, 2 Dec 2021 15:01:58 -0800
Subject: [PATCH 097/444] Update OneOffInsertion.ps1 file path

---
 azure-pipelines-official.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/azure-pipelines-official.yml b/azure-pipelines-official.yml
index 9a2e689f5cd40..e05646782b48f 100644
--- a/azure-pipelines-official.yml
+++ b/azure-pipelines-official.yml
@@ -334,7 +334,7 @@ stages:
 
     - powershell: |
         mv RoslynTools.VisualStudioInsertionTool.* RIT
-        .\RIT\tools\OneOffInsertion.ps1 `
+        .\RIT\tools\net46\OneOffInsertion.ps1 `
           -autoComplete "$(Insertion.AutoComplete)" `
           -buildQueueName "$(Build.DefinitionName)" `
           -cherryPick "(default)" `

From 97d0dd2a0955e3657c5b24b00a2f915cb97243b1 Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Mon, 6 Dec 2021 18:15:31 -0800
Subject: [PATCH 098/444] Address review comments

---
 .../IntelliSense/AsyncCompletion/Helpers.cs   |  42 +--
 .../ItemManager.CompletionListUpdater.cs      | 333 +++++++++---------
 .../AsyncCompletion/ItemManager.cs            |   4 +-
 3 files changed, 176 insertions(+), 203 deletions(-)

diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/Helpers.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/Helpers.cs
index eec784aa0a879..2f6adf686cdfe 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/Helpers.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/Helpers.cs
@@ -3,10 +3,8 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
-using System.Collections.Generic;
 using Microsoft.CodeAnalysis.Completion;
 using Microsoft.VisualStudio.Text;
-using EditorAsyncCompletion = Microsoft.VisualStudio.Language.Intellisense.AsyncCompletion;
 using EditorAsyncCompletionData = Microsoft.VisualStudio.Language.Intellisense.AsyncCompletion.Data;
 using RoslynCompletionItem = Microsoft.CodeAnalysis.Completion.CompletionItem;
 using RoslynTrigger = Microsoft.CodeAnalysis.Completion.CompletionTrigger;
@@ -28,7 +26,7 @@ internal static class Helpers
         /// <returns>Roslyn completion trigger</returns>
         internal static RoslynTrigger GetRoslynTrigger(EditorAsyncCompletionData.CompletionTrigger trigger, SnapshotPoint triggerLocation)
         {
-            var completionTriggerKind = GetRoslynTriggerKind(trigger);
+            var completionTriggerKind = GetRoslynTriggerKind(trigger.Reason);
             if (completionTriggerKind == CompletionTriggerKind.Deletion)
             {
                 var snapshotBeforeEdit = trigger.ViewSnapshotBeforeTrigger;
@@ -51,36 +49,26 @@ internal static RoslynTrigger GetRoslynTrigger(EditorAsyncCompletionData.Complet
             }
         }
 
-        internal static CompletionTriggerKind GetRoslynTriggerKind(EditorAsyncCompletionData.CompletionTrigger trigger)
+        internal static CompletionTriggerKind GetRoslynTriggerKind(EditorAsyncCompletionData.CompletionTriggerReason triggerReason)
         {
-            switch (trigger.Reason)
+            return triggerReason switch
             {
-                case EditorAsyncCompletionData.CompletionTriggerReason.InvokeAndCommitIfUnique:
-                    return CompletionTriggerKind.InvokeAndCommitIfUnique;
-                case EditorAsyncCompletionData.CompletionTriggerReason.Insertion:
-                    return CompletionTriggerKind.Insertion;
-                case EditorAsyncCompletionData.CompletionTriggerReason.Deletion:
-                case EditorAsyncCompletionData.CompletionTriggerReason.Backspace:
-                    return CompletionTriggerKind.Deletion;
-                case EditorAsyncCompletionData.CompletionTriggerReason.SnippetsMode:
-                    return CompletionTriggerKind.Snippets;
-                default:
-                    return CompletionTriggerKind.Invoke;
-            }
+                EditorAsyncCompletionData.CompletionTriggerReason.InvokeAndCommitIfUnique => CompletionTriggerKind.InvokeAndCommitIfUnique,
+                EditorAsyncCompletionData.CompletionTriggerReason.Insertion => CompletionTriggerKind.Insertion,
+                EditorAsyncCompletionData.CompletionTriggerReason.Deletion or EditorAsyncCompletionData.CompletionTriggerReason.Backspace => CompletionTriggerKind.Deletion,
+                EditorAsyncCompletionData.CompletionTriggerReason.SnippetsMode => CompletionTriggerKind.Snippets,
+                _ => CompletionTriggerKind.Invoke,
+            };
         }
 
-        internal static CompletionFilterReason GetFilterReason(EditorAsyncCompletionData.CompletionTrigger trigger)
+        internal static CompletionFilterReason GetFilterReason(EditorAsyncCompletionData.CompletionTriggerReason triggerReason)
         {
-            switch (trigger.Reason)
+            return triggerReason switch
             {
-                case EditorAsyncCompletionData.CompletionTriggerReason.Insertion:
-                    return CompletionFilterReason.Insertion;
-                case EditorAsyncCompletionData.CompletionTriggerReason.Deletion:
-                case EditorAsyncCompletionData.CompletionTriggerReason.Backspace:
-                    return CompletionFilterReason.Deletion;
-                default:
-                    return CompletionFilterReason.Other;
-            }
+                EditorAsyncCompletionData.CompletionTriggerReason.Insertion => CompletionFilterReason.Insertion,
+                EditorAsyncCompletionData.CompletionTriggerReason.Deletion or EditorAsyncCompletionData.CompletionTriggerReason.Backspace => CompletionFilterReason.Deletion,
+                _ => CompletionFilterReason.Other,
+            };
         }
 
         internal static bool IsFilterCharacter(RoslynCompletionItem item, char ch, string textTypedSoFar)
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
index ef28a1c25879f..a01229be95f3a 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
@@ -36,45 +36,44 @@ private sealed class CompletionListUpdater
             private readonly IAsyncCompletionSession _session;
             private readonly AsyncCompletionSessionDataSnapshot _data;
             private readonly RecentItemsManager _recentItemsManager;
-            private readonly IGlobalOptionService _globalOptions;
-            private readonly CancellationToken _cancellationToken;
 
             private readonly bool _hasSuggestedItemOptions;
             private readonly string _filterText;
-            private readonly CompletionTriggerKind _initialRoslynTriggerKind;
             private readonly Document? _document;
             private readonly CompletionService? _completionService;
             private readonly CompletionRules _completionRules;
             private readonly CompletionHelper _completionHelper;
             private readonly bool _highlightMatchingPortions;
+            private readonly bool _showCompletionItemFilters;
+            private readonly bool _useAggressiveDefaultsMatching;
 
-            private CompletionTriggerReason TriggerReason => _data.Trigger.Reason;
-            private CompletionFilterReason FilterReason => Helpers.GetFilterReason(_data.Trigger);
+            private readonly Func<ImmutableArray<(RoslynCompletionItem, PatternMatch?)>, string, ImmutableArray<RoslynCompletionItem>> _filterMethod;
 
-            private Func<ImmutableArray<(RoslynCompletionItem, PatternMatch?)>, string, ImmutableArray<RoslynCompletionItem>> FilterMethod
-                => _completionService == null
-                    ? ((itemsWithPatternMatches, text) => CompletionService.FilterItems(_completionHelper, itemsWithPatternMatches, text))
-                    : ((itemsWithPatternMatches, text) => _completionService.FilterItems(_document!, itemsWithPatternMatches, text));
+            private CompletionTriggerReason InitialTriggerReason => _data.InitialTrigger.Reason;
+            private CompletionTriggerReason UpdateTriggerReason => _data.Trigger.Reason;
 
             // PERF: Create a singleton to avoid lambda allocation on hot path
             private static readonly Func<TextSpan, RoslynCompletionItem, Span> s_highlightSpanGetter
                 = (span, item) => span.MoveTo(item.DisplayTextPrefix?.Length ?? 0).ToSpan();
 
+            // We might need to handle large amount of items with import completion enabled,
+            // so use a dedicated pool to minimize/avoid array allocations (especially in LOH)
+            // Set the size of pool to 1 because we don't expect UpdateCompletionListAsync to be
+            // called concurrently, which essentially makes the pooled list a singleton,
+            // but we still use ObjectPool for concurrency handling just to be robust.
+            private static readonly ObjectPool<List<MatchResult<VSCompletionItem>>> s_listOfMatchResultPool = new(factory: () => new(), size: 1);
+
             public CompletionListUpdater(
                 IAsyncCompletionSession session,
                 AsyncCompletionSessionDataSnapshot data,
                 RecentItemsManager recentItemsManager,
-                IGlobalOptionService globalOptions,
-                CancellationToken cancellationToken)
+                IGlobalOptionService globalOptions)
             {
                 _session = session;
                 _data = data;
                 _recentItemsManager = recentItemsManager;
-                _globalOptions = globalOptions;
-                _cancellationToken = cancellationToken;
 
                 _filterText = _session.ApplicableToSpan.GetText(_data.Snapshot);
-                _initialRoslynTriggerKind = Helpers.GetRoslynTriggerKind(_data.InitialTrigger);
 
                 if (!_session.Properties.TryGetProperty(CompletionSource.HasSuggestionItemOptions, out bool hasSuggestedItemOptions))
                 {
@@ -98,50 +97,68 @@ public CompletionListUpdater(
                 // Let us make the completion Helper used for non-Roslyn items case-sensitive.
                 // We can change this if get requests from partner teams.
                 _completionHelper = _document != null ? CompletionHelper.GetHelper(_document) : new CompletionHelper(isCaseSensitive: true);
+                _filterMethod = _completionService == null
+                    ? ((itemsWithPatternMatches, text) => CompletionService.FilterItems(_completionHelper, itemsWithPatternMatches, text))
+                    : ((itemsWithPatternMatches, text) => _completionService.FilterItems(_document!, itemsWithPatternMatches, text));
 
                 // Nothing to highlight if user hasn't typed anything yet.
                 _highlightMatchingPortions = _filterText.Length > 0
-                    && _globalOptions.GetOption(CompletionViewOptions.HighlightMatchingPortionsOfCompletionListItems, _document?.Project.Language);
+                        && globalOptions.GetOption(CompletionViewOptions.HighlightMatchingPortionsOfCompletionListItems, _document?.Project.Language);
 
+                _showCompletionItemFilters = globalOptions.GetOption(CompletionViewOptions.ShowCompletionItemFilters, _document?.Project.Language);
+                _useAggressiveDefaultsMatching = _session.TextView.Options.GetOptionValue<bool>(AggressiveDefaultsMatchingOptionName);
             }
 
-            public FilteredCompletionModel? UpdateCompletionList()
+            public FilteredCompletionModel? UpdateCompletionList(CancellationToken cancellationToken)
             {
                 if (ShouldDismissCompletionListImmediately())
                     return null;
 
-                // Determine the list of items to be included in the completion list.
-                // This is computed based on the filter text as well as the current
-                // selection of filters and expander.
-                using var _ = ComputeItemsToBeIncluded(out var itemsToBeIncluded);
+                // Use a dedicated pool to minimize potentially repeated large allocations,
+                // since the completion list could be long with import completion enabled.
+                var itemsToBeIncluded = s_listOfMatchResultPool.Allocate();
+                try
+                {
+                    // Determine the list of items to be included in the completion list.
+                    // This is computed based on the filter text as well as the current
+                    // selection of filters and expander.
+                    AddCompletionItems(itemsToBeIncluded, cancellationToken);
 
-                if (itemsToBeIncluded.Count == 0)
-                    return HandleAllItemsFilteredOut();
+                    // Decide if we want to dismiss an empty completion list based on CompletionRules and filter usage.
+                    if (itemsToBeIncluded.Count == 0)
+                        return HandleAllItemsFilteredOut();
 
-                // Decide the item to be selected for this completion session.
-                // The selection is mostly based on how well the item matches with the filter text, but we also need to
-                // take into consideration for things like CompletionTrigger, MatchPriority, MRU, etc. 
-                var initialSelection = _initialRoslynTriggerKind == CompletionTriggerKind.Deletion
-                    ? HandleDeletionTrigger(itemsToBeIncluded)
-                    : HandleNormalFiltering(itemsToBeIncluded);
+                    // Decide the item to be selected for this completion session.
+                    // The selection is mostly based on how well the item matches with the filter text, but we also need to
+                    // take into consideration for things like CompletionTrigger, MatchPriority, MRU, etc. 
+                    var initialSelection = InitialTriggerReason == CompletionTriggerReason.Backspace || InitialTriggerReason == CompletionTriggerReason.Deletion
+                        ? HandleDeletionTrigger(itemsToBeIncluded)
+                        : HandleNormalFiltering(itemsToBeIncluded);
 
-                if (!initialSelection.HasValue)
-                    return null;
+                    if (!initialSelection.HasValue)
+                        return null;
 
-                // Editor might provide a list of items to us as a suggestion to what to select for this session
-                // (via IAsyncCompletionDefaultsSource), where the "default" means the "default selection".
-                // The main scenario for this is to keep the selected item in completion list in sync with the
-                // suggestion of "Whole-Line Completion" feature, where the default is usually set to the first token
-                // of the WLC suggetion.
-                var finalSelection = UpdateSelectionBasedOnSuggestedDefaults(itemsToBeIncluded, initialSelection.Value);
+                    // Editor might provide a list of items to us as a suggestion to what to select for this session
+                    // (via IAsyncCompletionDefaultsSource), where the "default" means the "default selection".
+                    // The main scenario for this is to keep the selected item in completion list in sync with the
+                    // suggestion of "Whole-Line Completion" feature, where the default is usually set to the first token
+                    // of the WLC suggetion.
+                    var finalSelection = UpdateSelectionBasedOnSuggestedDefaults(itemsToBeIncluded, initialSelection.Value, cancellationToken);
 
-                return new FilteredCompletionModel(
-                    items: GetHighlightedList(itemsToBeIncluded),
-                    finalSelection.SelectedItemIndex,
-                    filters: GetUpdatedFilters(itemsToBeIncluded),
-                    finalSelection.SelectionHint,
-                    centerSelection: true,
-                    finalSelection.UniqueItem);
+                    return new FilteredCompletionModel(
+                        items: GetHighlightedList(itemsToBeIncluded, cancellationToken),
+                        finalSelection.SelectedItemIndex,
+                        filters: GetUpdatedFilters(itemsToBeIncluded, cancellationToken),
+                        finalSelection.SelectionHint,
+                        centerSelection: true,
+                        finalSelection.UniqueItem);
+                }
+                finally
+                {
+                    // Don't call ClearAndFree, which resets the capacity to a default value.
+                    itemsToBeIncluded.Clear();
+                    s_listOfMatchResultPool.Free(itemsToBeIncluded);
+                }
             }
 
             private bool ShouldDismissCompletionListImmediately()
@@ -165,8 +182,8 @@ private bool ShouldDismissCompletionListImmediately()
 
                 // DismissIfLastCharacterDeleted should be applied only when started with Insertion, and then Deleted all characters typed.
                 // This conforms with the original VS 2010 behavior.
-                if (_initialRoslynTriggerKind == CompletionTriggerKind.Insertion &&
-                    _data.Trigger.Reason == CompletionTriggerReason.Backspace &&
+                if (InitialTriggerReason == CompletionTriggerReason.Insertion &&
+                    UpdateTriggerReason == CompletionTriggerReason.Backspace &&
                     _completionRules.DismissIfLastCharacterDeleted &&
                     _filterText.Length == 0)
                 {
@@ -183,44 +200,41 @@ static bool IsAfterDot(ITextSnapshot snapshot, ITrackingSpan applicableToSpan)
                 }
             }
 
-            private IDisposable ComputeItemsToBeIncluded(out IReadOnlyList<MatchResult<VSCompletionItem>> itemsToBeIncluded)
+            private void AddCompletionItems(List<MatchResult<VSCompletionItem>> list, CancellationToken cancellationToken)
             {
-                var disposer = PooledListForMatchResult.CreateInstance(out var list);
-
                 // FilterStateHelper is used to decide wheter a given item should be included in the list based on the state of filter/expander buttons.
                 var filterHelper = new FilterStateHelper(_data.SelectedFilters);
                 filterHelper.LogTargetTypeFilterTelemetry(_session);
 
-                // Use a monotonically increasing integer to keep track the original alphabetical order of each item.
+                // We want to sort the items by pattern matching results while preserving the original alphabetical order for items with
+                // same pattern match score, but `List<T>.Sort` isn't stable. Therefore we have to add a monotonically increasing integer
+                // to `MatchResult` to keep track the original alphabetical order of each item.
                 var currentIndex = 0;
 
+                // Convert intial and update trigger reasons to corresponding Roslyn type so 
+                // we can interact with Roslyn's completion system
+                var roslynInitialTriggerKind = Helpers.GetRoslynTriggerKind(InitialTriggerReason);
+                var roslynFilterReason = Helpers.GetFilterReason(UpdateTriggerReason);
+
                 // Filter items based on the selected filters and matching.
                 foreach (var item in _data.InitialSortedList)
                 {
-                    _cancellationToken.ThrowIfCancellationRequested();
+                    cancellationToken.ThrowIfCancellationRequested();
 
                     if (filterHelper.ShouldBeFilteredOut(item))
                         continue;
 
                     var roslynItem = GetOrAddRoslynCompletionItem(item);
                     if (CompletionHelper.TryCreateMatchResult(_completionHelper, roslynItem, item, _filterText,
-                        _initialRoslynTriggerKind, FilterReason, _recentItemsManager.RecentItems, _highlightMatchingPortions, currentIndex,
-                        out var matchResult))
+                            roslynInitialTriggerKind, roslynFilterReason, _recentItemsManager.RecentItems, _highlightMatchingPortions, currentIndex,
+                            out var matchResult))
                     {
                         list.Add(matchResult);
                         currentIndex++;
                     }
                 }
 
-                // Sort the items by pattern matching results.
-                // Note that we want to preserve the original alphabetical order for items with same pattern match score,
-                // but `List<T>.Sort` isn't stable. Therefore we have to add a monotonically increasing integer
-                // to `MatchResult` to achieve this.
                 list.Sort(MatchResult<VSCompletionItem>.SortingComparer);
-
-                itemsToBeIncluded = list;
-                return disposer;
-
             }
 
             private ItemSelection? HandleNormalFiltering(IReadOnlyList<MatchResult<VSCompletionItem>> items)
@@ -229,10 +243,9 @@ private IDisposable ComputeItemsToBeIncluded(out IReadOnlyList<MatchResult<VSCom
                 // matches the text typed so far.
 
                 // Ask the language to determine which of the *matched* items it wants to select.
-                var matchingItems = items.Where(r => r.MatchedFilterText)
-                                               .SelectAsArray(t => (t.RoslynCompletionItem, t.PatternMatch));
+                var matchingItems = items.Where(r => r.MatchedFilterText).SelectAsArray(t => (t.RoslynCompletionItem, t.PatternMatch));
 
-                var chosenItems = FilterMethod(matchingItems, _filterText);
+                var chosenItems = _filterMethod(matchingItems, _filterText);
 
                 int selectedItemIndex;
                 VSCompletionItem? uniqueItem = null;
@@ -240,7 +253,8 @@ private IDisposable ComputeItemsToBeIncluded(out IReadOnlyList<MatchResult<VSCom
 
                 if (chosenItems.Length == 0)
                 {
-                    // We do not have matches: pick the one with longest common prefix or the first item from the list.
+                    // We do not have matches: pick the one with longest common prefix.
+                    // If we can't find such an item, just return the first item from the list.
                     selectedItemIndex = 0;
                     bestOrFirstMatchResult = items[0];
 
@@ -261,10 +275,8 @@ private IDisposable ComputeItemsToBeIncluded(out IReadOnlyList<MatchResult<VSCom
                 }
                 else
                 {
-                    var recentItems = _recentItemsManager.RecentItems;
-
                     // Of the items the service returned, pick the one most recently committed
-                    var bestItem = GetBestCompletionItemBasedOnMRU(chosenItems, recentItems);
+                    var bestItem = GetBestCompletionItemBasedOnMRUFirstOtherwiseOnPriority(chosenItems);
 
                     // Determine if we should consider this item 'unique' or not.  A unique item
                     // will be automatically committed if the user hits the 'invoke completion' 
@@ -282,11 +294,13 @@ private IDisposable ComputeItemsToBeIncluded(out IReadOnlyList<MatchResult<VSCom
                     Debug.Assert(selectedItemIndex < items.Count);
 
                     bestOrFirstMatchResult = items[selectedItemIndex];
-                    var deduplicatedListCount = matchingItems.Count(r => !r.RoslynCompletionItem.IsPreferredItem());
-                    if (deduplicatedListCount == 1 &&
-                        _filterText.Length > 0)
+
+                    if (_filterText.Length > 0)
                     {
-                        uniqueItem = items[selectedItemIndex].EditorCompletionItem;
+                        // PreferredItems from IntelliCode are duplicate of normal items, so we ignore them
+                        // when deciding if we have an unique item.
+                        if (matchingItems.Count(r => !r.RoslynCompletionItem.IsPreferredItem()) == 1)
+                            uniqueItem = items[selectedItemIndex].EditorCompletionItem;
                     }
                 }
 
@@ -297,7 +311,7 @@ private IDisposable ComputeItemsToBeIncluded(out IReadOnlyList<MatchResult<VSCom
                 // we should dismiss completion except cases where this is the first symbol typed for the completion session
                 // (string.IsNullOrEmpty(filterText) or string.Equals(filterText, typeChar.ToString(), StringComparison.OrdinalIgnoreCase)).
                 // In the latter case, we should keep the completion because it was confirmed just before in InitializeCompletion.
-                if (FilterReason == CompletionFilterReason.Insertion &&
+                if (UpdateTriggerReason == CompletionTriggerReason.Insertion &&
                     !string.IsNullOrEmpty(_filterText) &&
                     !string.Equals(_filterText, typedChar.ToString(), StringComparison.OrdinalIgnoreCase) &&
                     !IsPotentialFilterCharacter(typedChar) &&
@@ -306,9 +320,7 @@ private IDisposable ComputeItemsToBeIncluded(out IReadOnlyList<MatchResult<VSCom
                     return null;
                 }
 
-                var isHardSelection = IsHardSelection(
-                    _filterText, bestOrFirstMatchResult.RoslynCompletionItem, bestOrFirstMatchResult.MatchedFilterText, _hasSuggestedItemOptions);
-
+                var isHardSelection = IsHardSelection(bestOrFirstMatchResult.RoslynCompletionItem, bestOrFirstMatchResult.MatchedFilterText);
                 var updateSelectionHint = isHardSelection ? UpdateSelectionHint.Selected : UpdateSelectionHint.SoftSelected;
 
                 return new(selectedItemIndex, updateSelectionHint, uniqueItem);
@@ -317,8 +329,7 @@ private IDisposable ComputeItemsToBeIncluded(out IReadOnlyList<MatchResult<VSCom
             private ItemSelection? HandleDeletionTrigger(IReadOnlyList<MatchResult<VSCompletionItem>> items)
             {
                 var matchingItems = items.Where(r => r.MatchedFilterText);
-                if (TriggerReason == CompletionTriggerReason.Insertion &&
-                    !matchingItems.Any())
+                if (UpdateTriggerReason == CompletionTriggerReason.Insertion && !matchingItems.Any())
                 {
                     // The user has typed something, but nothing in the actual list matched what
                     // they were typing.  In this case, we want to dismiss completion entirely.
@@ -330,7 +341,7 @@ private IDisposable ComputeItemsToBeIncluded(out IReadOnlyList<MatchResult<VSCom
                 }
 
                 MatchResult<VSCompletionItem>? bestMatchResult = null;
-                var moreThanOneMatchWithSamePriority = false;
+                var moreThanOneMatch = false;
                 foreach (var currentMatchResult in matchingItems)
                 {
                     if (bestMatchResult == null)
@@ -343,12 +354,12 @@ private IDisposable ComputeItemsToBeIncluded(out IReadOnlyList<MatchResult<VSCom
                         var match = currentMatchResult.CompareTo(bestMatchResult.Value, _filterText);
                         if (match > 0)
                         {
-                            moreThanOneMatchWithSamePriority = false;
+                            moreThanOneMatch = false;
                             bestMatchResult = currentMatchResult;
                         }
                         else if (match == 0)
                         {
-                            moreThanOneMatchWithSamePriority = true;
+                            moreThanOneMatch = true;
                         }
                     }
                 }
@@ -377,44 +388,45 @@ private IDisposable ComputeItemsToBeIncluded(out IReadOnlyList<MatchResult<VSCom
                     hardSelect = false;
                 }
 
-                return new(index,
-                    hardSelect ? UpdateSelectionHint.Selected : UpdateSelectionHint.SoftSelected,
-                    moreThanOneMatchWithSamePriority ? null : bestMatchResult.GetValueOrDefault().EditorCompletionItem);
+                // We definitely don't have an unique item when moreThanOneMatch is true
+                return new(SelectedItemIndex: index,
+                    SelectionHint: hardSelect ? UpdateSelectionHint.Selected : UpdateSelectionHint.SoftSelected,
+                    UniqueItem: moreThanOneMatch ? null : bestMatchResult.GetValueOrDefault().EditorCompletionItem);
             }
 
-            private ImmutableArray<CompletionItemWithHighlight> GetHighlightedList(IReadOnlyList<MatchResult<VSCompletionItem>> items)
+            private ImmutableArray<CompletionItemWithHighlight> GetHighlightedList(IReadOnlyList<MatchResult<VSCompletionItem>> items, CancellationToken cancellationToken)
             {
                 return items.SelectAsArray(matchResult =>
                 {
-                    var highlightedSpans = GetHighlightedSpans(matchResult, _completionHelper, _filterText, _highlightMatchingPortions);
+                    cancellationToken.ThrowIfCancellationRequested();
+                    var highlightedSpans = _highlightMatchingPortions
+                        ? GetHighlightedSpans(matchResult, _completionHelper, _filterText)
+                        : ImmutableArray<Span>.Empty;
+
                     return new CompletionItemWithHighlight(matchResult.EditorCompletionItem, highlightedSpans);
                 });
 
                 static ImmutableArray<Span> GetHighlightedSpans(
                     MatchResult<VSCompletionItem> matchResult,
                     CompletionHelper completionHelper,
-                    string filterText,
-                    bool highlightMatchingPortions)
+                    string filterText)
                 {
-                    if (highlightMatchingPortions)
+                    if (matchResult.RoslynCompletionItem.HasDifferentFilterText)
                     {
-                        if (matchResult.RoslynCompletionItem.HasDifferentFilterText)
-                        {
-                            // The PatternMatch in MatchResult is calculated based on Roslyn item's FilterText, 
-                            // which can be used to calculate highlighted span for VSCompletion item's DisplayText w/o doing the matching again.
-                            // However, if the Roslyn item's FilterText is different from its DisplayText,
-                            // we need to do the match against the display text of the VS item directly to get the highlighted spans.
-                            return completionHelper.GetHighlightedSpans(
-                                matchResult.EditorCompletionItem.DisplayText, filterText, CultureInfo.CurrentCulture).SelectAsArray(s => s.ToSpan());
-                        }
+                        // The PatternMatch in MatchResult is calculated based on Roslyn item's FilterText, 
+                        // which can be used to calculate highlighted span for VSCompletion item's DisplayText w/o doing the matching again.
+                        // However, if the Roslyn item's FilterText is different from its DisplayText,
+                        // we need to do the match against the display text of the VS item directly to get the highlighted spans.
+                        return completionHelper.GetHighlightedSpans(
+                            matchResult.EditorCompletionItem.DisplayText, filterText, CultureInfo.CurrentCulture).SelectAsArray(s => s.ToSpan());
+                    }
 
-                        var patternMatch = matchResult.PatternMatch;
-                        if (patternMatch.HasValue)
-                        {
-                            // Since VS item's display text is created as Prefix + DisplayText + Suffix, 
-                            // we can calculate the highlighted span by adding an offset that is the length of the Prefix.
-                            return patternMatch.Value.MatchedSpans.SelectAsArray(s_highlightSpanGetter, matchResult.RoslynCompletionItem);
-                        }
+                    var patternMatch = matchResult.PatternMatch;
+                    if (patternMatch.HasValue)
+                    {
+                        // Since VS item's display text is created as Prefix + DisplayText + Suffix, 
+                        // we can calculate the highlighted span by adding an offset that is the length of the Prefix.
+                        return patternMatch.Value.MatchedSpans.SelectAsArray(s_highlightSpanGetter, matchResult.RoslynCompletionItem);
                     }
 
                     // If there's no match for Roslyn item's filter text which is identical to its display text,
@@ -425,7 +437,7 @@ static ImmutableArray<Span> GetHighlightedSpans(
 
             private FilteredCompletionModel? HandleAllItemsFilteredOut()
             {
-                if (TriggerReason == CompletionTriggerReason.Insertion)
+                if (UpdateTriggerReason == CompletionTriggerReason.Insertion)
                 {
                     // If the user was just typing, and the list went to empty *and* this is a 
                     // language that wants to dismiss on empty, then just return a null model
@@ -443,37 +455,39 @@ static ImmutableArray<Span> GetHighlightedSpans(
                 // If we are going to filter everything out, then just preserve the existing
                 // model (and all the previously filtered items), but switch over to soft
                 // selection.
-                var selection = UpdateSelectionHint.SoftSelected;
-
                 return new FilteredCompletionModel(
-                    ImmutableArray<CompletionItemWithHighlight>.Empty, selectedItemIndex: 0,
-                    _data.SelectedFilters, selection, centerSelection: true, uniqueItem: null);
+                    items: ImmutableArray<CompletionItemWithHighlight>.Empty, selectedItemIndex: 0,
+                    filters: _data.SelectedFilters, selectionHint: UpdateSelectionHint.SoftSelected, centerSelection: true, uniqueItem: null);
             }
 
-            private ImmutableArray<CompletionFilterWithState> GetUpdatedFilters(IReadOnlyList<MatchResult<VSCompletionItem>> items)
+            private ImmutableArray<CompletionFilterWithState> GetUpdatedFilters(IReadOnlyList<MatchResult<VSCompletionItem>> items, CancellationToken cancellationToken)
             {
-                var showCompletionItemFilters = _globalOptions.GetOption(CompletionViewOptions.ShowCompletionItemFilters, _document?.Project.Language);
-                if (!showCompletionItemFilters)
+                if (!_showCompletionItemFilters)
                     return ImmutableArray<CompletionFilterWithState>.Empty;
 
                 // See which filters might be enabled based on the typed code
-                using var _ = PooledHashSet<CompletionFilter>.GetInstance(out var textFilteredFilters);
-                textFilteredFilters.AddRange(items.SelectMany(n => n.EditorCompletionItem.Filters));
+                using var _ = PooledHashSet<CompletionFilter>.GetInstance(out var filters);
+                foreach (var item in items)
+                {
+                    cancellationToken.ThrowIfCancellationRequested();
+                    filters.AddRange(item.EditorCompletionItem.Filters);
+                }
 
                 // When no items are available for a given filter, it becomes unavailable.
                 // Expanders always appear available as long as it's presented.
-                return _data.SelectedFilters.SelectAsArray(n => n.WithAvailability(n.Filter is CompletionExpander || textFilteredFilters.Contains(n.Filter)));
+                return _data.SelectedFilters.SelectAsArray(n => n.WithAvailability(n.Filter is CompletionExpander || filters.Contains(n.Filter)));
             }
 
             /// <summary>
             /// Given multiple possible chosen completion items, pick the one that has the
             /// best MRU index, or the one with highest MatchPriority if none in MRU.
             /// </summary>
-            private static RoslynCompletionItem GetBestCompletionItemBasedOnMRU(
-                ImmutableArray<RoslynCompletionItem> chosenItems, ImmutableArray<string> recentItems)
+            private RoslynCompletionItem GetBestCompletionItemBasedOnMRUFirstOtherwiseOnPriority(ImmutableArray<RoslynCompletionItem> chosenItems)
             {
                 Debug.Assert(chosenItems.Length > 0);
 
+                var recentItems = _recentItemsManager.RecentItems;
+
                 // Try to find the chosen item has been most recently used.
                 var bestItem = chosenItems[0];
                 for (int i = 1, n = chosenItems.Length; i < n; i++)
@@ -495,8 +509,7 @@ private static RoslynCompletionItem GetBestCompletionItemBasedOnMRU(
                     return bestItem;
                 }
 
-                // Otherwise use the chosen item that has the highest
-                // matchPriority.
+                // Otherwise use the chosen item that has the highest matchPriority.
                 for (int i = 1, n = chosenItems.Length; i < n; i++)
                 {
                     var chosenItem = chosenItems[i];
@@ -531,13 +544,11 @@ private static bool TryGetInitialTriggerLocation(AsyncCompletionSessionDataSnaps
                 return false;
             }
 
-            private static bool IsHardSelection(
-                string filterText,
+            private bool IsHardSelection(
                 RoslynCompletionItem item,
-                bool matchedFilterText,
-                bool useSuggestionMode)
+                bool matchedFilterText)
             {
-                if (item == null || useSuggestionMode)
+                if (_hasSuggestedItemOptions)
                 {
                     return false;
                 }
@@ -558,7 +569,7 @@ private static bool IsHardSelection(
                 // It's possible the user is just typing language punctuation and selecting
                 // anything in the list will interfere.  We only allow this if the filter text
                 // exactly matches something in the list already. 
-                if (filterText.Length > 0 && IsAllPunctuation(filterText) && filterText != item.DisplayText)
+                if (_filterText.Length > 0 && IsAllPunctuation(_filterText) && _filterText != item.DisplayText)
                 {
                     return false;
                 }
@@ -566,7 +577,7 @@ private static bool IsHardSelection(
                 // If the user hasn't actually typed anything, then don't hard select any item.
                 // The only exception to this is if the completion provider has requested the
                 // item be preselected.
-                if (filterText.Length == 0)
+                if (_filterText.Length == 0)
                 {
                     // Item didn't want to be hard selected with no filter text.
                     // So definitely soft select it.
@@ -584,7 +595,7 @@ private static bool IsHardSelection(
 
                 // The user typed something, or the item asked to be preselected.  In 
                 // either case, don't soft select this.
-                Debug.Assert(filterText.Length > 0 || item.Rules.MatchPriority != MatchPriority.Default);
+                Debug.Assert(_filterText.Length > 0 || item.Rules.MatchPriority != MatchPriority.Default);
 
                 // If the user moved the caret left after they started typing, the 'best' match may not match at all
                 // against the full text span that this item would be replacing.
@@ -623,7 +634,7 @@ private static bool IsPotentialFilterCharacter(char c)
                     || c == '_';
             }
 
-            private ItemSelection UpdateSelectionBasedOnSuggestedDefaults(IReadOnlyList<MatchResult<VSCompletionItem>> items, ItemSelection itemSelection)
+            private ItemSelection UpdateSelectionBasedOnSuggestedDefaults(IReadOnlyList<MatchResult<VSCompletionItem>> items, ItemSelection itemSelection, CancellationToken cancellationToken)
             {
                 // Editor doesn't provide us a list of "default" items.
                 if (_data.Defaults.IsDefaultOrEmpty)
@@ -636,32 +647,35 @@ private ItemSelection UpdateSelectionBasedOnSuggestedDefaults(IReadOnlyList<Matc
 
                 var tick = Environment.TickCount;
 
-                var useAggressiveDefaultsMatching = _session.TextView.Options.GetOptionValue<bool>(AggressiveDefaultsMatchingOptionName);
-
-                var finalSelection = useAggressiveDefaultsMatching
-                    ? GetAggressiveDefaultsMatch(items, itemSelection)
-                    : GetDefaultsMatch(items, itemSelection);
+                var finalSelection = _useAggressiveDefaultsMatching
+                    ? GetAggressiveDefaultsMatch(items, itemSelection, cancellationToken)
+                    : GetDefaultsMatch(items, itemSelection, cancellationToken);
 
                 AsyncCompletionLogger.LogGetDefaultsMatchTicksDataPoint(Environment.TickCount - tick);
                 return finalSelection;
             }
 
             /// <summary>
-            /// With aggressive matching turned on, the default was use as long as what the user typed in the applicable to span
+            /// With aggressive matching turned on, the default would be used as long as what the user typed in the applicable to span
             /// was a case-insensitive prefix of the item.
+            /// 
+            /// For example: 
+            ///     a default "TaskCanceledException" would be a match for filter text "task" and therefore to be selected, even if
+            ///     the CompletionService returns item for a local variable "task" which is an exact match.
+            ///     
             /// The aggressive mode exist to make it easier for IntelliCode to experiment with default matching algorithm, so this is
-            /// not the default matching behavior we'd use and subject to further adjustment.
+            /// not the default matching behavior we use, and it is subject to further adjustment.
             /// </summary>
-            private ItemSelection GetAggressiveDefaultsMatch(IReadOnlyList<MatchResult<VSCompletionItem>> items, ItemSelection intialSelection)
+            private ItemSelection GetAggressiveDefaultsMatch(IReadOnlyList<MatchResult<VSCompletionItem>> items, ItemSelection intialSelection, CancellationToken cancellationToken)
             {
                 foreach (var defaultText in _data.Defaults)
                 {
+                    cancellationToken.ThrowIfCancellationRequested();
+
                     for (var i = 0; i < items.Count; ++i)
                     {
-                        // Currently in aggressive mode, the first item matches a default will be selected
+                        // Currently in aggressive mode, the first item that matches a default will be selected
                         // as long as the filter text is its prefix (case-insensitive).
-                        // e.g. a default "TaskCanceledException" would be a match for filter text "task" and therefore to be selected,
-                        // even if the CompletionService returns item for a local variable "task" which is an exact match.
                         var itemWithMatch = items[i];
                         if (itemWithMatch.RoslynCompletionItem.DisplayText != defaultText)
                             continue;
@@ -684,7 +698,7 @@ private ItemSelection GetAggressiveDefaultsMatch(IReadOnlyList<MatchResult<VSCom
             /// If the suggested default is no worse than current selected item (in a case-sensitive manner,) use the suggested default. Otherwise use the original selection.
             /// For example, if user typed "C", roslyn might select "CancellationToken", but with suggested default "Console" we will end up selecting "Console" instead.
             /// </summary>
-            private ItemSelection GetDefaultsMatch(IReadOnlyList<MatchResult<VSCompletionItem>> items, ItemSelection intialSelection)
+            private ItemSelection GetDefaultsMatch(IReadOnlyList<MatchResult<VSCompletionItem>> items, ItemSelection intialSelection, CancellationToken cancellationToken)
             {
                 // Because the items are already sorted based on pattern-matching score, try to limit the range for the items we compare default with
                 // by searching for the first "inferior" item, so we can avoid always going through the entire list.
@@ -701,6 +715,9 @@ private ItemSelection GetDefaultsMatch(IReadOnlyList<MatchResult<VSCompletionIte
                     // Find the last items in the range and use that to limit the items searched for from the defaults list.          
                     var selectedItemMatch = items[intialSelection.SelectedItemIndex].PatternMatch;
 
+                    // it's possible that an item doesn't match filter text but still ended up being selected, this is because we just always keep all the
+                    // items in the list in some cases. For example, user brought up completion with ctrl-j or through deletion.
+                    // Don't bother changing the selection in such cases.
                     if (!selectedItemMatch.HasValue)
                         return intialSelection;
 
@@ -719,6 +736,8 @@ private ItemSelection GetDefaultsMatch(IReadOnlyList<MatchResult<VSCompletionIte
 
                 foreach (var defaultText in _data.Defaults)
                 {
+                    cancellationToken.ThrowIfCancellationRequested();
+
                     // The range includes all items that are as good of a match as what we intially selected (and in descending order of matching score)
                     // so we just need to search for the first item that matches the suggested default.
                     for (var i = 0; i < inferiorItemIndex; ++i)
@@ -731,40 +750,6 @@ private ItemSelection GetDefaultsMatch(IReadOnlyList<MatchResult<VSCompletionIte
                 return intialSelection;
             }
 
-            private sealed class PooledListForMatchResult : IDisposable
-            {
-                // We might need to handle large amount of items with import completion enabled,
-                // so use a dedicated pool to minimize/avoid array allocations (especially in LOH)
-                // Set the size of pool to 1 because we don't expect UpdateCompletionListAsync to be
-                // called concurrently, which essentially makes the pooled list a singleton,
-                // but we still use ObjectPool for concurrency handling just to be robust.
-                private static readonly ObjectPool<List<MatchResult<VSCompletionItem>>> s_listOfMatchResultPool = new(factory: () => new(), size: 1);
-
-                private List<MatchResult<VSCompletionItem>>? _list;
-
-                public static IDisposable CreateInstance(out List<MatchResult<VSCompletionItem>> list)
-                {
-                    list = s_listOfMatchResultPool.Allocate();
-                    return new PooledListForMatchResult(list);
-                }
-
-                private PooledListForMatchResult(List<MatchResult<VSCompletionItem>> list)
-                {
-                    _list = list;
-                }
-
-                public void Dispose()
-                {
-                    if (_list is not null)
-                    {
-                        // Don't call ClearAndFree, which resets the capacity to a default value.
-                        _list.Clear();
-                        s_listOfMatchResultPool.Free(_list);
-                        _list = null;
-                    }
-                }
-            }
-
             private sealed class FilterStateHelper
             {
                 private readonly ImmutableArray<CompletionFilterWithState> _nonExpanderFilterStates;
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
index 20ce843140bbc..dba67a817d561 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.cs
@@ -54,8 +54,8 @@ public Task<ImmutableArray<VSCompletionItem>> SortCompletionListAsync(
             AsyncCompletionSessionDataSnapshot data,
             CancellationToken cancellationToken)
         {
-            var updater = new CompletionListUpdater(session, data, _recentItemsManager, _globalOptions, cancellationToken);
-            return Task.FromResult(updater.UpdateCompletionList());
+            var updater = new CompletionListUpdater(session, data, _recentItemsManager, _globalOptions);
+            return Task.FromResult(updater.UpdateCompletionList(cancellationToken));
         }
 
         private static RoslynCompletionItem GetOrAddRoslynCompletionItem(VSCompletionItem vsItem)

From 5619ddf8be67146967ccb6466dedf58372a536f4 Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Mon, 6 Dec 2021 18:19:22 -0800
Subject: [PATCH 099/444] Avoid unnecessary computation

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

diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
index a01229be95f3a..6ea1eda0540bd 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
@@ -490,16 +490,17 @@ private RoslynCompletionItem GetBestCompletionItemBasedOnMRUFirstOtherwiseOnPrio
 
                 // Try to find the chosen item has been most recently used.
                 var bestItem = chosenItems[0];
+                var mruIndex1 = GetRecentItemIndex(recentItems, bestItem);
                 for (int i = 1, n = chosenItems.Length; i < n; i++)
                 {
                     var chosenItem = chosenItems[i];
-                    var mruIndex1 = GetRecentItemIndex(recentItems, bestItem);
                     var mruIndex2 = GetRecentItemIndex(recentItems, chosenItem);
 
                     if ((mruIndex2 < mruIndex1) ||
                         (mruIndex2 == mruIndex1 && !bestItem.IsPreferredItem() && chosenItem.IsPreferredItem()))
                     {
                         bestItem = chosenItem;
+                        mruIndex1 = GetRecentItemIndex(recentItems, bestItem);
                     }
                 }
 

From 0ac323fba0b21742afaa01c5a380feee644714f3 Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Tue, 7 Dec 2021 10:54:20 -0800
Subject: [PATCH 100/444] Add comments

---
 .../ItemManager.CompletionListUpdater.cs      | 24 +++++++++++++------
 1 file changed, 17 insertions(+), 7 deletions(-)

diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
index 6ea1eda0540bd..c2ff5a47595ac 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
@@ -711,17 +711,17 @@ private ItemSelection GetDefaultsMatch(IReadOnlyList<MatchResult<VSCompletionIte
                 }
                 else
                 {
-                    // Because the items are sorted based on pattern-matching score, the selectedIndex is in the middle of a range of
-                    // -- as far as the pattern matcher is concerned -- equivalent items (items with identical PatternMatch.Kind and IsCaseSensitive).
-                    // Find the last items in the range and use that to limit the items searched for from the defaults list.          
                     var selectedItemMatch = items[intialSelection.SelectedItemIndex].PatternMatch;
 
-                    // it's possible that an item doesn't match filter text but still ended up being selected, this is because we just always keep all the
+                    // It's possible that an item doesn't match filter text but still ended up being selected, this is because we just always keep all the
                     // items in the list in some cases. For example, user brought up completion with ctrl-j or through deletion.
-                    // Don't bother changing the selection in such cases.
+                    // Don't bother changing the selection in such cases (since there's no match to the filter text in the list)
                     if (!selectedItemMatch.HasValue)
                         return intialSelection;
 
+                    // Because the items are sorted based on pattern-matching score, the selectedIndex is in the middle of a range of
+                    // -- as far as the pattern matcher is concerned -- equivalent items (items with identical PatternMatch.Kind and IsCaseSensitive).
+                    // Find the last items in the range and use that to limit the items searched for from the defaults list.     
                     inferiorItemIndex = intialSelection.SelectedItemIndex;
                     while (++inferiorItemIndex < items.Count)
                     {
@@ -748,6 +748,7 @@ private ItemSelection GetDefaultsMatch(IReadOnlyList<MatchResult<VSCompletionIte
                     }
                 }
 
+                // Don't change the original selection since there's no match to the defaults provided.
                 return intialSelection;
             }
 
@@ -755,8 +756,8 @@ private sealed class FilterStateHelper
             {
                 private readonly ImmutableArray<CompletionFilterWithState> _nonExpanderFilterStates;
                 private readonly ImmutableArray<CompletionFilter> _selectedNonExpanderFilters;
-                private readonly bool _needToFilter;
                 private readonly ImmutableArray<CompletionFilter> _unselectedExpanders;
+                private readonly bool _needToFilter;
                 private readonly bool _needToFilterExpanded;
 
                 // For telemetry
@@ -764,7 +765,16 @@ private sealed class FilterStateHelper
 
                 public FilterStateHelper(ImmutableArray<CompletionFilterWithState> filtersWithState)
                 {
-                    // We need to filter if 
+                    // The filter state list contains two kinds of "filters": regular filter and expander.
+                    // The difference between them is they have different semantics.
+                    // - When all filters or no filter is selected, everything should be inclued.
+                    //   But when a strict subset of filters is selected, only items correspding to the selected filters should be included.
+                    // - When expander is selected, all expanded items should be included, otherwise, expanded items should be excluded.
+                    //   expander state has no affect on non-expanded items.
+                    //   For example, right now we only have one expander for items from unimported namespaces, selecting/unselecting expander would
+                    //   include/exclude those items from completion list, but in-scope items would be shown regardless.
+                    // 
+                    // Therefore, we need to filter if 
                     // 1. a non-empty strict subset of filters are selected
                     // 2. a non-empty set of expanders are unselected
                     _nonExpanderFilterStates = filtersWithState.WhereAsArray(f => f.Filter is not CompletionExpander);

From 7658f5b325561e175c47eb1f199858d233aeb306 Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Tue, 7 Dec 2021 11:24:22 -0800
Subject: [PATCH 101/444] Combine loops

---
 .../ItemManager.CompletionListUpdater.cs      | 55 ++++++++++---------
 1 file changed, 30 insertions(+), 25 deletions(-)

diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
index c2ff5a47595ac..ad9238b7f8c6a 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
@@ -328,26 +328,32 @@ private void AddCompletionItems(List<MatchResult<VSCompletionItem>> list, Cancel
 
             private ItemSelection? HandleDeletionTrigger(IReadOnlyList<MatchResult<VSCompletionItem>> items)
             {
-                var matchingItems = items.Where(r => r.MatchedFilterText);
-                if (UpdateTriggerReason == CompletionTriggerReason.Insertion && !matchingItems.Any())
+                if (UpdateTriggerReason == CompletionTriggerReason.Insertion && !items.Any(r => r.MatchedFilterText))
                 {
-                    // The user has typed something, but nothing in the actual list matched what
-                    // they were typing.  In this case, we want to dismiss completion entirely.
-                    // The thought process is as follows: we aggressively brought up completion
-                    // to help them when they typed delete (in case they wanted to pick another
-                    // item).  However, they're typing something that doesn't seem to match at all
-                    // The completion list is just distracting at this point.
-                    return null;
                 }
 
+                // Go through the entire item list to find the best match(es).
+                // If we had matching items, then pick the best of the matching items and
+                // choose that one to be hard selected.  If we had no actual matching items
+                // (which can happen if the user deletes down to a single character and we
+                // include everything), then we just soft select the first item.
+                var indexToSelect = 0;
+                var hardSelect = false;
                 MatchResult<VSCompletionItem>? bestMatchResult = null;
                 var moreThanOneMatch = false;
-                foreach (var currentMatchResult in matchingItems)
+
+                for (var i = 0; i < items.Count; ++i)
                 {
+                    var currentMatchResult = items[i];
+
+                    if (!currentMatchResult.MatchedFilterText)
+                        continue;
+
                     if (bestMatchResult == null)
                     {
                         // We had no best result yet, so this is now our best result.
                         bestMatchResult = currentMatchResult;
+                        indexToSelect = i;
                     }
                     else
                     {
@@ -356,6 +362,7 @@ private void AddCompletionItems(List<MatchResult<VSCompletionItem>> list, Cancel
                         {
                             moreThanOneMatch = false;
                             bestMatchResult = currentMatchResult;
+                            indexToSelect = i;
                         }
                         else if (match == 0)
                         {
@@ -364,14 +371,18 @@ private void AddCompletionItems(List<MatchResult<VSCompletionItem>> list, Cancel
                     }
                 }
 
-                int index;
-                bool hardSelect;
+                if (UpdateTriggerReason == CompletionTriggerReason.Insertion && bestMatchResult is null)
+                {
+                    // The user has typed something, but nothing in the actual list matched what
+                    // they were typing.  In this case, we want to dismiss completion entirely.
+                    // The thought process is as follows: we aggressively brought up completion
+                    // to help them when they typed delete (in case they wanted to pick another
+                    // item).  However, they're typing something that doesn't seem to match at all
+                    // The completion list is just distracting at this point.
+                    return null;
+                }
 
-                // If we had a matching item, then pick the best of the matching items and
-                // choose that one to be hard selected.  If we had no actual matching items
-                // (which can happen if the user deletes down to a single character and we
-                // include everything), then we just soft select the first item.
-                if (bestMatchResult != null)
+                if (bestMatchResult is not null)
                 {
                     // Only hard select this result if it's a prefix match
                     // We need to do this so that
@@ -380,16 +391,10 @@ private void AddCompletionItems(List<MatchResult<VSCompletionItem>> list, Cancel
                     // * deleting through a word from the end keeps that word selected
                     // This also preserves the behavior the VB had through Dev12.
                     hardSelect = !_hasSuggestedItemOptions && bestMatchResult.Value.EditorCompletionItem.FilterText.StartsWith(_filterText, StringComparison.CurrentCultureIgnoreCase);
-                    index = items.IndexOf(bestMatchResult.Value);
-                }
-                else
-                {
-                    index = 0;
-                    hardSelect = false;
                 }
 
-                // We definitely don't have an unique item when moreThanOneMatch is true
-                return new(SelectedItemIndex: index,
+                // The best match we have selected is unique if `moreThanOneMatch` is false.
+                return new(SelectedItemIndex: indexToSelect,
                     SelectionHint: hardSelect ? UpdateSelectionHint.Selected : UpdateSelectionHint.SoftSelected,
                     UniqueItem: moreThanOneMatch ? null : bestMatchResult.GetValueOrDefault().EditorCompletionItem);
             }

From bc0593f8ab1af0d93d63f9fa12a84f69d3cf1d4b Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Tue, 7 Dec 2021 11:38:56 -0800
Subject: [PATCH 102/444] Remove the handling of AggressiveDefaultsMatching
 option

We need to clarify the design before implementing it
---
 .../ItemManager.CompletionListUpdater.cs      | 44 +------------------
 ...etionCommandHandlerTests_DefaultsSource.vb | 24 ----------
 2 files changed, 1 insertion(+), 67 deletions(-)

diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
index ad9238b7f8c6a..dcba945fa0550 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
@@ -45,7 +45,6 @@ private sealed class CompletionListUpdater
             private readonly CompletionHelper _completionHelper;
             private readonly bool _highlightMatchingPortions;
             private readonly bool _showCompletionItemFilters;
-            private readonly bool _useAggressiveDefaultsMatching;
 
             private readonly Func<ImmutableArray<(RoslynCompletionItem, PatternMatch?)>, string, ImmutableArray<RoslynCompletionItem>> _filterMethod;
 
@@ -106,7 +105,6 @@ public CompletionListUpdater(
                         && globalOptions.GetOption(CompletionViewOptions.HighlightMatchingPortionsOfCompletionListItems, _document?.Project.Language);
 
                 _showCompletionItemFilters = globalOptions.GetOption(CompletionViewOptions.ShowCompletionItemFilters, _document?.Project.Language);
-                _useAggressiveDefaultsMatching = _session.TextView.Options.GetOptionValue<bool>(AggressiveDefaultsMatchingOptionName);
             }
 
             public FilteredCompletionModel? UpdateCompletionList(CancellationToken cancellationToken)
@@ -653,52 +651,12 @@ private ItemSelection UpdateSelectionBasedOnSuggestedDefaults(IReadOnlyList<Matc
 
                 var tick = Environment.TickCount;
 
-                var finalSelection = _useAggressiveDefaultsMatching
-                    ? GetAggressiveDefaultsMatch(items, itemSelection, cancellationToken)
-                    : GetDefaultsMatch(items, itemSelection, cancellationToken);
+                var finalSelection = GetDefaultsMatch(items, itemSelection, cancellationToken);
 
                 AsyncCompletionLogger.LogGetDefaultsMatchTicksDataPoint(Environment.TickCount - tick);
                 return finalSelection;
             }
 
-            /// <summary>
-            /// With aggressive matching turned on, the default would be used as long as what the user typed in the applicable to span
-            /// was a case-insensitive prefix of the item.
-            /// 
-            /// For example: 
-            ///     a default "TaskCanceledException" would be a match for filter text "task" and therefore to be selected, even if
-            ///     the CompletionService returns item for a local variable "task" which is an exact match.
-            ///     
-            /// The aggressive mode exist to make it easier for IntelliCode to experiment with default matching algorithm, so this is
-            /// not the default matching behavior we use, and it is subject to further adjustment.
-            /// </summary>
-            private ItemSelection GetAggressiveDefaultsMatch(IReadOnlyList<MatchResult<VSCompletionItem>> items, ItemSelection intialSelection, CancellationToken cancellationToken)
-            {
-                foreach (var defaultText in _data.Defaults)
-                {
-                    cancellationToken.ThrowIfCancellationRequested();
-
-                    for (var i = 0; i < items.Count; ++i)
-                    {
-                        // Currently in aggressive mode, the first item that matches a default will be selected
-                        // as long as the filter text is its prefix (case-insensitive).
-                        var itemWithMatch = items[i];
-                        if (itemWithMatch.RoslynCompletionItem.DisplayText != defaultText)
-                            continue;
-
-                        if (itemWithMatch.PatternMatch != null && itemWithMatch.PatternMatch.Value.Kind > PatternMatchKind.Prefix)
-                            break;
-
-                        // Always hard-select except in suggestion mode.
-                        return _hasSuggestedItemOptions
-                            ? intialSelection with { SelectedItemIndex = i }
-                            : intialSelection with { SelectedItemIndex = i, SelectionHint = UpdateSelectionHint.Selected };
-                    }
-                }
-
-                return intialSelection;
-            }
-
             /// <summary>
             /// Compare the pattern matching result of the current selection with the pattern matching result of the suggested defaults (both w.r.t. the filter text.)
             /// If the suggested default is no worse than current selected item (in a case-sensitive manner,) use the suggested default. Otherwise use the original selection.
diff --git a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_DefaultsSource.vb b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_DefaultsSource.vb
index de692fbf24b5c..ec3f7745919b0 100644
--- a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_DefaultsSource.vb
+++ b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_DefaultsSource.vb
@@ -157,30 +157,6 @@ class C
             End Using
         End Function
 
-        <WpfFact>
-        <Trait(Traits.Feature, Traits.Features.Completion)>
-        Public Async Function SelectAggressiveDefaultsWithPrefixMatchingOverExactMatch() As Task
-            Using state = CreateTestStateWithAdditionalDocument(
-                              <Document>
-using NS1;
-class My
-{
-    void Method()
-    {
-        My$$
-    }
-}
-                              </Document>)
-
-                state.TextView.Options.SetOptionValue(ItemManager.AggressiveDefaultsMatchingOptionName, True)
-                state.SendInvokeCompletionList()
-
-                Await state.AssertCompletionItemsContain("My", displayTextSuffix:="")
-                Await state.AssertCompletionItemsContain("MyA", displayTextSuffix:="")
-                Await state.AssertSelectedCompletionItem("MyAB", isHardSelected:=True)
-            End Using
-        End Function
-
         Private Shared Function CreateTestStateWithAdditionalDocument(documentElement As XElement) As TestState
             Return TestStateFactory.CreateTestStateFromWorkspace(
                 <Workspace>

From 8b548465bea8526418c4fde787124fcf789428dd Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Tue, 7 Dec 2021 12:48:36 -0800
Subject: [PATCH 103/444] Address review comments

---
 .../ItemManager.CompletionListUpdater.cs       | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
index dcba945fa0550..9c10d8f8ddab0 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
@@ -102,7 +102,7 @@ public CompletionListUpdater(
 
                 // Nothing to highlight if user hasn't typed anything yet.
                 _highlightMatchingPortions = _filterText.Length > 0
-                        && globalOptions.GetOption(CompletionViewOptions.HighlightMatchingPortionsOfCompletionListItems, _document?.Project.Language);
+                    && globalOptions.GetOption(CompletionViewOptions.HighlightMatchingPortionsOfCompletionListItems, _document?.Project.Language);
 
                 _showCompletionItemFilters = globalOptions.GetOption(CompletionViewOptions.ShowCompletionItemFilters, _document?.Project.Language);
             }
@@ -140,7 +140,7 @@ public CompletionListUpdater(
                     // (via IAsyncCompletionDefaultsSource), where the "default" means the "default selection".
                     // The main scenario for this is to keep the selected item in completion list in sync with the
                     // suggestion of "Whole-Line Completion" feature, where the default is usually set to the first token
-                    // of the WLC suggetion.
+                    // of the WLC suggestion.
                     var finalSelection = UpdateSelectionBasedOnSuggestedDefaults(itemsToBeIncluded, initialSelection.Value, cancellationToken);
 
                     return new FilteredCompletionModel(
@@ -200,7 +200,7 @@ static bool IsAfterDot(ITextSnapshot snapshot, ITrackingSpan applicableToSpan)
 
             private void AddCompletionItems(List<MatchResult<VSCompletionItem>> list, CancellationToken cancellationToken)
             {
-                // FilterStateHelper is used to decide wheter a given item should be included in the list based on the state of filter/expander buttons.
+                // FilterStateHelper is used to decide whether a given item should be included in the list based on the state of filter/expander buttons.
                 var filterHelper = new FilterStateHelper(_data.SelectedFilters);
                 filterHelper.LogTargetTypeFilterTelemetry(_session);
 
@@ -209,7 +209,7 @@ private void AddCompletionItems(List<MatchResult<VSCompletionItem>> list, Cancel
                 // to `MatchResult` to keep track the original alphabetical order of each item.
                 var currentIndex = 0;
 
-                // Convert intial and update trigger reasons to corresponding Roslyn type so 
+                // Convert initial and update trigger reasons to corresponding Roslyn type so 
                 // we can interact with Roslyn's completion system
                 var roslynInitialTriggerKind = Helpers.GetRoslynTriggerKind(InitialTriggerReason);
                 var roslynFilterReason = Helpers.GetFilterReason(UpdateTriggerReason);
@@ -326,10 +326,6 @@ private void AddCompletionItems(List<MatchResult<VSCompletionItem>> list, Cancel
 
             private ItemSelection? HandleDeletionTrigger(IReadOnlyList<MatchResult<VSCompletionItem>> items)
             {
-                if (UpdateTriggerReason == CompletionTriggerReason.Insertion && !items.Any(r => r.MatchedFilterText))
-                {
-                }
-
                 // Go through the entire item list to find the best match(es).
                 // If we had matching items, then pick the best of the matching items and
                 // choose that one to be hard selected.  If we had no actual matching items
@@ -702,7 +698,7 @@ private ItemSelection GetDefaultsMatch(IReadOnlyList<MatchResult<VSCompletionIte
                 {
                     cancellationToken.ThrowIfCancellationRequested();
 
-                    // The range includes all items that are as good of a match as what we intially selected (and in descending order of matching score)
+                    // The range includes all items that are as good of a match as what we initially selected (and in descending order of matching score)
                     // so we just need to search for the first item that matches the suggested default.
                     for (var i = 0; i < inferiorItemIndex; ++i)
                     {
@@ -730,8 +726,8 @@ public FilterStateHelper(ImmutableArray<CompletionFilterWithState> filtersWithSt
                 {
                     // The filter state list contains two kinds of "filters": regular filter and expander.
                     // The difference between them is they have different semantics.
-                    // - When all filters or no filter is selected, everything should be inclued.
-                    //   But when a strict subset of filters is selected, only items correspding to the selected filters should be included.
+                    // - When all filters or no filter is selected, everything should be included.
+                    //   But when a strict subset of filters is selected, only items corresponding to the selected filters should be included.
                     // - When expander is selected, all expanded items should be included, otherwise, expanded items should be excluded.
                     //   expander state has no affect on non-expanded items.
                     //   For example, right now we only have one expander for items from unimported namespaces, selecting/unselecting expander would

From 108a8fb8bf0b9373a6140ea87e8de733e4004443 Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Tue, 7 Dec 2021 12:54:24 -0800
Subject: [PATCH 104/444] Replace delegate object with static local function

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

diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
index 9c10d8f8ddab0..6d1277648dce3 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
@@ -51,10 +51,6 @@ private sealed class CompletionListUpdater
             private CompletionTriggerReason InitialTriggerReason => _data.InitialTrigger.Reason;
             private CompletionTriggerReason UpdateTriggerReason => _data.Trigger.Reason;
 
-            // PERF: Create a singleton to avoid lambda allocation on hot path
-            private static readonly Func<TextSpan, RoslynCompletionItem, Span> s_highlightSpanGetter
-                = (span, item) => span.MoveTo(item.DisplayTextPrefix?.Length ?? 0).ToSpan();
-
             // We might need to handle large amount of items with import completion enabled,
             // so use a dedicated pool to minimize/avoid array allocations (especially in LOH)
             // Set the size of pool to 1 because we don't expect UpdateCompletionListAsync to be
@@ -425,13 +421,17 @@ static ImmutableArray<Span> GetHighlightedSpans(
                     {
                         // Since VS item's display text is created as Prefix + DisplayText + Suffix, 
                         // we can calculate the highlighted span by adding an offset that is the length of the Prefix.
-                        return patternMatch.Value.MatchedSpans.SelectAsArray(s_highlightSpanGetter, matchResult.RoslynCompletionItem);
+                        return patternMatch.Value.MatchedSpans.SelectAsArray(GetOffsetSpan, matchResult.RoslynCompletionItem);
                     }
 
                     // If there's no match for Roslyn item's filter text which is identical to its display text,
                     // then we can safely assume there'd be no matching to VS item's display text.
                     return ImmutableArray<Span>.Empty;
                 }
+
+                // PERF: static local function to avoid lambda allocation on hot path
+                static Span GetOffsetSpan(TextSpan span, RoslynCompletionItem item)
+                    => span.MoveTo(item.DisplayTextPrefix?.Length ?? 0).ToSpan();
             }
 
             private FilteredCompletionModel? HandleAllItemsFilteredOut()

From 61efe06d0c70f89bfbcc7bada14f810822855572 Mon Sep 17 00:00:00 2001
From: akhera99 <ankitakhera@microsoft.com>
Date: Wed, 8 Dec 2021 09:41:53 -0800
Subject: [PATCH 105/444] tests + other feedback

---
 .../Core.Wpf/InlineHints/InlineHintsTag.cs    |  14 +-
 .../Core.Wpf/InlineHints/InlineHintsTagger.cs |   2 +-
 .../InlineHints/AbstractInlineHintsTests.vb   |  51 +-
 .../CSharpInlineParameterNameHintsTests.vb    | 615 +++++++++++++++++-
 .../Compiler/Core/Log/FunctionId.cs           |   2 +
 5 files changed, 628 insertions(+), 56 deletions(-)

diff --git a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
index 31cb54575e728..f6274976bf373 100644
--- a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
@@ -16,10 +16,13 @@
 using Microsoft.CodeAnalysis.Editor.Host;
 using Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.QuickInfo;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.Elfie.Diagnostics;
 using Microsoft.CodeAnalysis.InlineHints;
+using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
+using Microsoft.CodeAnalysis.Text.Shared.Extensions;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Adornments;
 using Microsoft.VisualStudio.Text.Classification;
@@ -269,7 +272,16 @@ private void Adornment_MouseLeftButtonDown(object sender, MouseButtonEventArgs e
             {
                 e.Handled = true;
                 var replacementValue = _hint.ReplacementTextChange!.Value;
-                _ = _subjectBuffer.Replace(new VisualStudio.Text.Span(replacementValue.Span.Start, replacementValue.Span.Length), replacementValue.NewText);
+
+                if (_subjectBuffer.CurrentSnapshot.Length > replacementValue.Span.End)
+                {
+                    _subjectBuffer.Replace(new VisualStudio.Text.Span(replacementValue.Span.Start, replacementValue.Span.Length), replacementValue.NewText);
+                }
+                else
+                {
+                    Internal.Log.Logger.Log(FunctionId.Inline_Hints_DoubleClick,
+                        $"replacement span end:{replacementValue.Span.End} is greater than or equal to current snapshot length:{_subjectBuffer.CurrentSnapshot.Length}");
+                }
             }
         }
     }
diff --git a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTagger.cs b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTagger.cs
index 742d832067c97..9f07f9ff22a8d 100644
--- a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTagger.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTagger.cs
@@ -157,7 +157,7 @@ public IEnumerable<ITagSpan<IntraTextAdornmentTag>> GetTags(NormalizedSnapshotSp
                         if (_cache[i].tagSpan is not { } hintTagSpan)
                         {
                             var parameterHintUITag = InlineHintsTag.Create(
-                                    _cache[i].mappingTagSpan.Tag.Hint, Format, _textView, tagSpan, _taggerProvider, _formatMap, snapshot.TextBugger, classify);
+                                    _cache[i].mappingTagSpan.Tag.Hint, Format, _textView, tagSpan, _taggerProvider, _formatMap, snapshot.TextBuffer, classify);
                             hintTagSpan = new TagSpan<IntraTextAdornmentTag>(tagSpan, parameterHintUITag);
                             _cache[i] = (_cache[i].mappingTagSpan, hintTagSpan);
                         }
diff --git a/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb b/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb
index 9ca1fdc6718d7..3ed50c3aeed21 100644
--- a/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb
+++ b/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb
@@ -2,16 +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.
 
+Imports System.Collections.Immutable
 Imports System.Threading
 Imports Microsoft.CodeAnalysis.Editor.InlineHints
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
 Imports Microsoft.CodeAnalysis.InlineHints
 Imports Microsoft.CodeAnalysis.Options
+Imports Microsoft.CodeAnalysis.[Shared].Utilities
+Imports Microsoft.CodeAnalysis.Text
 
 Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
     <[UseExportProvider]>
     Public MustInherit Class AbstractInlineHintsTests
-        Protected Async Function VerifyParamHints(test As XElement, Optional optionIsEnabled As Boolean = True) As Task
+        Protected Async Function VerifyParamHints(test As XElement, Optional output As XElement = Nothing, Optional optionIsEnabled As Boolean = True) As Task
             Using workspace = TestWorkspace.Create(test)
                 WpfTestRunner.RequireWpfFact($"{NameOf(AbstractInlineHintsTests)}.{NameOf(Me.VerifyParamHints)} creates asynchronous taggers")
 
@@ -22,14 +25,18 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
 
                 Dim hostDocument = workspace.Documents.Single()
                 Dim snapshot = hostDocument.GetTextBuffer().CurrentSnapshot
-                Dim document = workspace.CurrentSolution.GetDocument(hostDocument.Id)
-                Dim tagService = document.GetRequiredLanguageService(Of IInlineParameterNameHintsService)
-                Dim inlineHints = Await tagService.GetInlineHintsAsync(document, New Text.TextSpan(0, snapshot.Length), New CancellationToken())
+                Dim annotatedDocument = workspace.CurrentSolution.GetDocument(hostDocument.Id)
+                Dim tagService = annotatedDocument.GetRequiredLanguageService(Of IInlineParameterNameHintsService)
+                Dim inlineHints = Await tagService.GetInlineHintsAsync(annotatedDocument, New Text.TextSpan(0, snapshot.Length), New CancellationToken())
 
                 Dim producedTags = From hint In inlineHints
                                    Select hint.DisplayParts.GetFullText().TrimEnd() + hint.Span.ToString
 
                 ValidateSpans(hostDocument, producedTags)
+
+                Dim outWorkspace = TestWorkspace.Create(output)
+                Dim expectedDocument = outWorkspace.CurrentSolution.GetDocument(outWorkspace.Documents.Single().Id)
+                Await ValidateDoubleClick(annotatedDocument, expectedDocument, inlineHints)
             End Using
         End Function
 
@@ -47,6 +54,21 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
             AssertEx.Equal(expectedTags, producedTags)
         End Sub
 
+        Private Shared Async Function ValidateDoubleClick(document As Document, expectedDocument As Document, inlineHints As ImmutableArray(Of InlineHint)) As Task
+            Dim textChanges = New List(Of TextChange)
+            For Each inlineHint In inlineHints
+                If inlineHint.ReplacementTextChange IsNot Nothing Then
+                    textChanges.Add(inlineHint.ReplacementTextChange.Value)
+                End If
+            Next
+
+            Dim value = Await document.GetTextAsync().ConfigureAwait(False)
+            Dim newText = value.WithChanges(textChanges).ToString()
+            Dim expectedText = Await expectedDocument.GetTextAsync().ConfigureAwait(False)
+
+            AssertEx.Equal(newText, expectedText.ToString())
+        End Function
+
         Protected Async Function VerifyTypeHints(test As XElement, Optional optionIsEnabled As Boolean = True, Optional ephemeral As Boolean = False) As Task
             Using workspace = TestWorkspace.Create(test)
                 WpfTestRunner.RequireWpfFact($"{NameOf(AbstractInlineHintsTests)}.{NameOf(Me.VerifyTypeHints)} creates asynchronous taggers")
@@ -71,26 +93,5 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
                 ValidateSpans(hostDocument, producedTags)
             End Using
         End Function
-
-        'Protected Async Function VerifyTypeHintsDoubleClick(test As XElement, Optional optionIsEnabled As Boolean = True, Optional ephemeral As Boolean = False) As Task
-        '    Using workspace = TestWorkspace.Create(test)
-        '        WpfTestRunner.RequireWpfFact($"{NameOf(AbstractInlineHintsTests)}.{NameOf(Me.VerifyTypeHints)} creates asynchronous taggers")
-
-        '        Dim language = workspace.CurrentSolution.Projects().First().Language
-        '        workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(
-        '        workspace.Options.WithChangedOption(InlineHintsOptions.EnabledForTypes, language, optionIsEnabled AndAlso Not ephemeral).
-        '                          WithChangedOption(InlineHintsOptions.DisplayAllOverride, ephemeral)))
-
-        '        Dim hostDocument = workspace.Documents.Single()
-        '        Dim snapshot = hostDocument.GetTextBuffer().CurrentSnapshot
-        '        Dim document = workspace.CurrentSolution.GetDocument(hostDocument.Id)
-        '        Dim tagService = document.GetRequiredLanguageService(Of IInlineTypeHintsService)
-        '        Dim typeHints = Await tagService.GetInlineHintsAsync(document, New Text.TextSpan(0, snapshot.Length), New CancellationToken())
-
-        '        For Each hint In typeHints
-        '            hint.ReplacementTextChange.Value.
-        '        Next
-        '    End Using
-        'End Function
     End Class
 End Namespace
diff --git a/src/EditorFeatures/Test2/InlineHints/CSharpInlineParameterNameHintsTests.vb b/src/EditorFeatures/Test2/InlineHints/CSharpInlineParameterNameHintsTests.vb
index 65221d267a656..7f37fc54ed6bc 100644
--- a/src/EditorFeatures/Test2/InlineHints/CSharpInlineParameterNameHintsTests.vb
+++ b/src/EditorFeatures/Test2/InlineHints/CSharpInlineParameterNameHintsTests.vb
@@ -27,7 +27,26 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    int testMethod()
+    {
+        return 5;
+    }
+    void Main() 
+    {
+        testMethod();
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -51,7 +70,26 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    int testMethod(int x)
+    {
+        return x;
+    }
+    void Main() 
+    {
+        testMethod(x: 5);
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -75,7 +113,26 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    int testMethod(int x, double y)
+    {
+        return x;
+    }
+    void Main() 
+    {
+        testMethod(x: 5, y: 2);
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -99,7 +156,26 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    int testMethod(int x, double y)
+    {
+        return x;
+    }
+    void Main() 
+    {
+        testMethod(x: -5, y: 2);
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -123,7 +199,26 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+           <Workspace>
+               <Project Language="C#" CommonReferences="true">
+                   <Document>
+class A
+{
+    int testMethod(int x, double y)
+    {
+        return x;
+    }
+    void Main() 
+    {
+        testMethod(x: (int)(double)(int)5.5, y: 2);
+    }
+}
+                    </Document>
+               </Project>
+           </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -147,7 +242,26 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    int testMethod(int x, object y)
+    {
+        return x;
+    }
+    void Main() 
+    {
+        testMethod(x: (int)5.5, y: new object());
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -171,7 +285,26 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    int testMethod(int x, object y)
+    {
+        return x;
+    }
+    void Main() 
+    {
+        testMethod(x: (int)-5.5, y: new object());
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -195,7 +328,26 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    int testMethod(int x, object y)
+    {
+        return x;
+    }
+    void Main() 
+    {
+        testMethod(x: -(int)5.5, y: new object());
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -219,7 +371,26 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    int testMethod(int)
+    {
+        return 5;
+    }
+    void Main() 
+    {
+        testMethod();
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -247,7 +418,30 @@ class Test
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+delegate void D(int x);
+
+class C
+{
+    public static void M1(int i) { }
+}
+
+class Test
+{
+    static void Main()
+    {
+        D cd1 = new D(C.M1);
+        cd1(x: -1);
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -265,7 +459,20 @@ unsafe class Example {
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true" AllowUnsafe="true">
+                    <Document>
+unsafe class Example {
+    void Example(delegate*&lt;int, void&gt; f) {
+        f(42);
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -289,7 +496,26 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    public void UseParams(params int[] list)
+    {
+    }
+
+    public void Main(string[] args)
+    {
+        UseParams(list: 1, 2, 3, 4, 5, 6); 
+    } 
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -310,7 +536,23 @@ class Foo
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+using System;
+
+[Obsolete(message: "test")]
+class Foo
+{
+        
+
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -334,7 +576,26 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    int testMethod(int x, object y)
+    {
+        return x;
+    }
+    void Main() 
+    {
+        testMethod(x: -(int)5.5,);
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -358,7 +619,26 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    string testMethod(string x)
+    {
+        return x;
+    }
+    void Main() 
+    {
+        testMethod(x: $"");
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -374,7 +654,17 @@ record Derived(int Other) : Base({|Alice:|}2, {|Bob:|}2);
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+record Base(int Alice, int Bob);
+record Derived(int Other) : Base(Alice: 2, Bob: 2);
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -396,7 +686,23 @@ class Derived : Base
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class Base
+{
+    public Base(int paramName) {}
+}
+class Derived : Base
+{
+    public Derived() : base(paramName: 20) {}
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -421,7 +727,26 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void EnableLogging(bool value)
+    {
+    }
+
+    void Main() 
+    {
+        EnableLogging(true);
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -446,7 +771,26 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void DisableLogging(bool value)
+    {
+    }
+
+    void Main() 
+    {
+        DisableLogging(true);
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -471,7 +815,26 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void EnableLogging(string value)
+    {
+    }
+
+    void Main() 
+    {
+        EnableLogging(value: "IO");
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -496,7 +859,26 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void DisableLogging(string value)
+    {
+    }
+
+    void Main() 
+    {
+        DisableLogging(value: "IO");
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -521,7 +903,26 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void SetClassification(string classification)
+    {
+    }
+
+    void Main() 
+    {
+        SetClassification("IO");
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -546,7 +947,26 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void SetClassification(string values)
+    {
+    }
+
+    void Main() 
+    {
+        SetClassification(values: "IO");
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -571,7 +991,26 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void Goo(int objA, int objB, int objC)
+    {
+    }
+
+    void Main() 
+    {
+        Goo(1, 2, 3);
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -596,7 +1035,26 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void Goo(int objA, int objB, int nonobjC)
+    {
+    }
+
+    void Main() 
+    {
+        Goo(objA: 1, objB: 2, nonobjC: 3);
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -621,7 +1079,26 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void Goo(int obj1, int obj2, int obj3)
+    {
+    }
+
+    void Main() 
+    {
+        Goo(1, 2, 3);
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -646,7 +1123,26 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void Goo(int obj1, int obj2, int nonobj3)
+    {
+    }
+
+    void Main() 
+    {
+        Goo(obj1: 1, obj2: 2, nonobj3: 3);
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -673,7 +1169,28 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+           <Workspace>
+               <Project Language="C#" CommonReferences="true">
+                   <Document>
+#nullable enable
+
+class A
+{
+    void M(string x)
+    {
+    }
+
+    void Main() 
+    {
+        M(x: null!);
+    }
+}
+                    </Document>
+               </Project>
+           </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -719,7 +1236,47 @@ class Program
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+public class TempRecord
+{
+    // Array of temperature values
+    float[] temps = new float[10]
+    {
+        56.2F, 56.7F, 56.5F, 56.9F, 58.8F,
+        61.3F, 65.9F, 62.1F, 59.2F, 57.5F
+    };
+
+    // To enable client code to validate input
+    // when accessing your indexer.
+    public int Length => temps.Length;
+    
+    // Indexer declaration.
+    // If index is out of range, the temps array will throw the exception.
+    public float this[int index]
+    {
+        get => temps[index];
+        set => temps[index] = value;
+    }
+}
+
+class Program
+{
+    static void Main()
+    {
+        var tempRecord = new TempRecord();
+
+        // Use the indexer's set accessor
+        var temp = tempRecord[index: 3];
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
     End Class
 End Namespace
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/FunctionId.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/FunctionId.cs
index 081c383687dcb..07772bdfb1de3 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/FunctionId.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/FunctionId.cs
@@ -534,5 +534,7 @@ internal enum FunctionId
         NavigateTo_CacheItemsMiss = 510,
 
         AssetService_Perf = 520,
+
+        Inline_Hints_DoubleClick = 530,
     }
 }

From f847cc90e5bd496ecbbf29ab108e72833dc19307 Mon Sep 17 00:00:00 2001
From: akhera99 <ankitakhera@microsoft.com>
Date: Wed, 8 Dec 2021 11:52:36 -0800
Subject: [PATCH 106/444] type hints tests

---
 .../InlineHints/AbstractInlineHintsTests.vb   |   8 +-
 .../InlineHints/CSharpInlineTypeHintsTests.vb | 378 ++++++++++++++++--
 .../CSharpInlineTypeHintsService.cs           |  14 +-
 3 files changed, 366 insertions(+), 34 deletions(-)

diff --git a/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb b/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb
index 3ed50c3aeed21..4447dcd7f3ddf 100644
--- a/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb
+++ b/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb
@@ -66,10 +66,10 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
             Dim newText = value.WithChanges(textChanges).ToString()
             Dim expectedText = Await expectedDocument.GetTextAsync().ConfigureAwait(False)
 
-            AssertEx.Equal(newText, expectedText.ToString())
+            AssertEx.Equal(expectedText.ToString(), newText)
         End Function
 
-        Protected Async Function VerifyTypeHints(test As XElement, Optional optionIsEnabled As Boolean = True, Optional ephemeral As Boolean = False) As Task
+        Protected Async Function VerifyTypeHints(test As XElement, Optional output As XElement = Nothing, Optional optionIsEnabled As Boolean = True, Optional ephemeral As Boolean = False) As Task
             Using workspace = TestWorkspace.Create(test)
                 WpfTestRunner.RequireWpfFact($"{NameOf(AbstractInlineHintsTests)}.{NameOf(Me.VerifyTypeHints)} creates asynchronous taggers")
                 Dim globalOptions = workspace.GetService(Of IGlobalOptionService)
@@ -91,6 +91,10 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
                                    Select hint.DisplayParts.GetFullText() + ":" + hint.Span.ToString()
 
                 ValidateSpans(hostDocument, producedTags)
+
+                Dim outWorkspace = TestWorkspace.Create(output)
+                Dim expectedDocument = outWorkspace.CurrentSolution.GetDocument(outWorkspace.Documents.Single().Id)
+                Await ValidateDoubleClick(document, expectedDocument, typeHints)
             End Using
         End Function
     End Class
diff --git a/src/EditorFeatures/Test2/InlineHints/CSharpInlineTypeHintsTests.vb b/src/EditorFeatures/Test2/InlineHints/CSharpInlineTypeHintsTests.vb
index 9232ddeef73a5..94f6fd1df503d 100644
--- a/src/EditorFeatures/Test2/InlineHints/CSharpInlineTypeHintsTests.vb
+++ b/src/EditorFeatures/Test2/InlineHints/CSharpInlineTypeHintsTests.vb
@@ -23,7 +23,22 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyTypeHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void Main() 
+    {
+        int i = 0;
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyTypeHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -43,7 +58,22 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyTypeHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void Main() 
+    {
+        int i = 0;
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyTypeHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -63,7 +93,22 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyTypeHints(input, ephemeral:=True)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void Main() 
+    {
+        int i = 0;
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyTypeHints(input, output, ephemeral:=True)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -83,7 +128,22 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyTypeHints(input)
+            Dim output =
+           <Workspace>
+               <Project Language="C#" CommonReferences="true">
+                   <Document>
+class A
+{
+    void Main() 
+    {
+        var (i, j) = (0, "");
+    }
+}
+                    </Document>
+               </Project>
+           </Workspace>
+
+            Await VerifyTypeHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -103,7 +163,22 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyTypeHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void Main(string[] args) 
+    {
+        foreach (string j in args) {}
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyTypeHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -123,7 +198,22 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyTypeHints(input, ephemeral:=True)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void Main(string[] args) 
+    {
+        foreach (string j in args) {}
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyTypeHints(input, output, ephemeral:=True)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -143,7 +233,22 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyTypeHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void Main(string[] args) 
+    {
+        foreach (string j in args) {}
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyTypeHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -163,7 +268,22 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyTypeHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void Main(string[] args) 
+    {
+        if (args is { Length: int goo }) { }
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyTypeHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -183,7 +303,21 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyTypeHints(input, ephemeral:=True)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void Main(string[] args) 
+    {
+        if (args is { Length: int goo }) { }
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+            Await VerifyTypeHints(input, output, ephemeral:=True)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -203,7 +337,22 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyTypeHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void Main(string[] args) 
+    {
+        if (args is { Length: int goo }) { }
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyTypeHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -224,7 +373,23 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyTypeHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+using System.Linq;
+class A
+{
+    void Main(string[] args) 
+    {
+        args.Where(a => a.Length > 0);
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyTypeHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -245,7 +410,23 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyTypeHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+using System.Linq;
+class A
+{
+    void Main(string[] args) 
+    {
+        args.Where((string a) => a.Length > 0);
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyTypeHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -266,7 +447,23 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyTypeHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+using System.Linq;
+class A
+{
+    void Main(string[] args) 
+    {
+        args.Where((string a) => a.Length > 0);
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyTypeHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -288,7 +485,24 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyTypeHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void Main(string[] args) 
+    {
+        if (int.TryParse("", out int x))
+        {
+        }
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyTypeHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -310,7 +524,24 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyTypeHints(input, ephemeral:=True)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void Main(string[] args) 
+    {
+        if (int.TryParse("", out int x))
+        {
+        }
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyTypeHints(input, output, ephemeral:=True)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -333,7 +564,24 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyTypeHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void Main(string[] args) 
+    {
+        if (int.TryParse("", out int x))
+        {
+        }
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyTypeHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -358,7 +606,26 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyTypeHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void M(int i) { }
+
+    void Main(string[] args) 
+    {
+        M(new int())
+        {
+        }
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyTypeHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -376,7 +643,19 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyTypeHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    int field = new int();
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyTypeHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -397,7 +676,22 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyTypeHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void M()
+    {
+        int i = new int();
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyTypeHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -415,7 +709,19 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyTypeHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    void M(System.Threading.CancellationToken ct = new CancellationToken()) { }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyTypeHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -436,7 +742,22 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyTypeHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="C#" CommonReferences="true">
+                    <Document>
+class A
+{
+    int M()
+    {
+        return new int();
+    }
+}
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyTypeHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -459,27 +780,24 @@ class A
                 </Project>
             </Workspace>
 
-            Await VerifyTypeHints(input)
-        End Function
-
-        <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
-        Public Async Function TestDoubleClickOnNonOverwriteType() As Task
-            Dim input =
+            Dim output =
             <Workspace>
                 <Project Language="C#" CommonReferences="true">
                     <Document>
 class A
 {
-    void Main() 
+    int M()
     {
-        var {|int :|}i = 0;
+        return true
+            ? 1
+            : new int();
     }
 }
                     </Document>
                 </Project>
             </Workspace>
 
-            Await VerifyTypeHints(input)
+            Await VerifyTypeHints(input, output)
         End Function
     End Class
 End Namespace
diff --git a/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs b/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs
index b41e11f9a6b1f..89f865cfad8d3 100644
--- a/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs
+++ b/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs
@@ -5,11 +5,13 @@
 using System;
 using System.Composition;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.InlineHints;
 using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
@@ -75,11 +77,19 @@ public CSharpInlineTypeHintsService(IGlobalOptionService globalOptions)
             {
                 if (node is ParameterSyntax { Type: null } parameterNode)
                 {
+                    var span = new TextSpan(parameterNode.Identifier.SpanStart, 0);
                     var parameter = semanticModel.GetDeclaredSymbol(parameterNode, cancellationToken);
                     if (parameter?.ContainingSymbol is IMethodSymbol { MethodKind: MethodKind.AnonymousFunction } &&
                         IsValidType(parameter?.Type))
                     {
-                        return new(parameter.Type, new TextSpan(parameterNode.Identifier.SpanStart, 0), textChange: null, trailingSpace: true);
+                        if (parameterNode.Parent!.Parent.IsKind(SyntaxKind.ParenthesizedLambdaExpression))
+                        {
+                            return new(parameter.Type, span, textChange: new TextChange(span, parameter.Type.ToDisplayString(s_minimalTypeStyle) + " "), trailingSpace: true);
+                        }
+                        else
+                        {
+                            return new(parameter.Type, span, textChange: null, trailingSpace: true);
+                        }
                     }
                 }
             }
@@ -92,7 +102,7 @@ public CSharpInlineTypeHintsService(IGlobalOptionService globalOptions)
                     if (IsValidType(type))
                     {
                         var span = new TextSpan(implicitNew.NewKeyword.Span.End, 0);
-                        return new(type, span, new TextChange(span, type.ToDisplayString(s_minimalTypeStyle)), leadingSpace: true);
+                        return new(type, span, new TextChange(span, " " + type.ToDisplayString(s_minimalTypeStyle)), leadingSpace: true);
                     }
                 }
             }

From 82707b58616caeedc3b9ea9f7cc4b1aea1a9a46d Mon Sep 17 00:00:00 2001
From: akhera99 <ankitakhera@microsoft.com>
Date: Wed, 8 Dec 2021 13:19:07 -0800
Subject: [PATCH 107/444] added vb tests

---
 .../InlineHints/AbstractInlineHintsTests.vb   |   4 +-
 .../CSharpInlineParameterNameHintsTests.vb    | 162 +-------
 .../InlineHints/CSharpInlineTypeHintsTests.vb |  88 +----
 ...isualBasicInlineParameterNameHintsTests.vb | 364 ++++++++++++++++--
 4 files changed, 353 insertions(+), 265 deletions(-)

diff --git a/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb b/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb
index 4447dcd7f3ddf..54d64fbb01f06 100644
--- a/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb
+++ b/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb
@@ -14,7 +14,7 @@ Imports Microsoft.CodeAnalysis.Text
 Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
     <[UseExportProvider]>
     Public MustInherit Class AbstractInlineHintsTests
-        Protected Async Function VerifyParamHints(test As XElement, Optional output As XElement = Nothing, Optional optionIsEnabled As Boolean = True) As Task
+        Protected Async Function VerifyParamHints(test As XElement, output As XElement, Optional optionIsEnabled As Boolean = True) As Task
             Using workspace = TestWorkspace.Create(test)
                 WpfTestRunner.RequireWpfFact($"{NameOf(AbstractInlineHintsTests)}.{NameOf(Me.VerifyParamHints)} creates asynchronous taggers")
 
@@ -69,7 +69,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
             AssertEx.Equal(expectedText.ToString(), newText)
         End Function
 
-        Protected Async Function VerifyTypeHints(test As XElement, Optional output As XElement = Nothing, Optional optionIsEnabled As Boolean = True, Optional ephemeral As Boolean = False) As Task
+        Protected Async Function VerifyTypeHints(test As XElement, output As XElement, Optional optionIsEnabled As Boolean = True, Optional ephemeral As Boolean = False) As Task
             Using workspace = TestWorkspace.Create(test)
                 WpfTestRunner.RequireWpfFact($"{NameOf(AbstractInlineHintsTests)}.{NameOf(Me.VerifyTypeHints)} creates asynchronous taggers")
                 Dim globalOptions = workspace.GetService(Of IGlobalOptionService)
diff --git a/src/EditorFeatures/Test2/InlineHints/CSharpInlineParameterNameHintsTests.vb b/src/EditorFeatures/Test2/InlineHints/CSharpInlineParameterNameHintsTests.vb
index 7f37fc54ed6bc..2f4b27d604871 100644
--- a/src/EditorFeatures/Test2/InlineHints/CSharpInlineParameterNameHintsTests.vb
+++ b/src/EditorFeatures/Test2/InlineHints/CSharpInlineParameterNameHintsTests.vb
@@ -27,26 +27,7 @@ class A
                 </Project>
             </Workspace>
 
-            Dim output =
-            <Workspace>
-                <Project Language="C#" CommonReferences="true">
-                    <Document>
-class A
-{
-    int testMethod()
-    {
-        return 5;
-    }
-    void Main() 
-    {
-        testMethod();
-    }
-}
-                    </Document>
-                </Project>
-            </Workspace>
-
-            Await VerifyParamHints(input, output)
+            Await VerifyParamHints(input, input)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -371,26 +352,7 @@ class A
                 </Project>
             </Workspace>
 
-            Dim output =
-            <Workspace>
-                <Project Language="C#" CommonReferences="true">
-                    <Document>
-class A
-{
-    int testMethod(int)
-    {
-        return 5;
-    }
-    void Main() 
-    {
-        testMethod();
-    }
-}
-                    </Document>
-                </Project>
-            </Workspace>
-
-            Await VerifyParamHints(input, output)
+            Await VerifyParamHints(input, input)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -459,20 +421,7 @@ unsafe class Example {
                 </Project>
             </Workspace>
 
-            Dim output =
-            <Workspace>
-                <Project Language="C#" CommonReferences="true" AllowUnsafe="true">
-                    <Document>
-unsafe class Example {
-    void Example(delegate*&lt;int, void&gt; f) {
-        f(42);
-    }
-}
-                    </Document>
-                </Project>
-            </Workspace>
-
-            Await VerifyParamHints(input, output)
+            Await VerifyParamHints(input, input)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -727,26 +676,7 @@ class A
                 </Project>
             </Workspace>
 
-            Dim output =
-            <Workspace>
-                <Project Language="C#" CommonReferences="true">
-                    <Document>
-class A
-{
-    void EnableLogging(bool value)
-    {
-    }
-
-    void Main() 
-    {
-        EnableLogging(true);
-    }
-}
-                    </Document>
-                </Project>
-            </Workspace>
-
-            Await VerifyParamHints(input, output)
+            Await VerifyParamHints(input, input)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -771,26 +701,7 @@ class A
                 </Project>
             </Workspace>
 
-            Dim output =
-            <Workspace>
-                <Project Language="C#" CommonReferences="true">
-                    <Document>
-class A
-{
-    void DisableLogging(bool value)
-    {
-    }
-
-    void Main() 
-    {
-        DisableLogging(true);
-    }
-}
-                    </Document>
-                </Project>
-            </Workspace>
-
-            Await VerifyParamHints(input, output)
+            Await VerifyParamHints(input, input)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -903,26 +814,7 @@ class A
                 </Project>
             </Workspace>
 
-            Dim output =
-            <Workspace>
-                <Project Language="C#" CommonReferences="true">
-                    <Document>
-class A
-{
-    void SetClassification(string classification)
-    {
-    }
-
-    void Main() 
-    {
-        SetClassification("IO");
-    }
-}
-                    </Document>
-                </Project>
-            </Workspace>
-
-            Await VerifyParamHints(input, output)
+            Await VerifyParamHints(input, input)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -991,26 +883,7 @@ class A
                 </Project>
             </Workspace>
 
-            Dim output =
-            <Workspace>
-                <Project Language="C#" CommonReferences="true">
-                    <Document>
-class A
-{
-    void Goo(int objA, int objB, int objC)
-    {
-    }
-
-    void Main() 
-    {
-        Goo(1, 2, 3);
-    }
-}
-                    </Document>
-                </Project>
-            </Workspace>
-
-            Await VerifyParamHints(input, output)
+            Await VerifyParamHints(input, input)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -1079,26 +952,7 @@ class A
                 </Project>
             </Workspace>
 
-            Dim output =
-            <Workspace>
-                <Project Language="C#" CommonReferences="true">
-                    <Document>
-class A
-{
-    void Goo(int obj1, int obj2, int obj3)
-    {
-    }
-
-    void Main() 
-    {
-        Goo(1, 2, 3);
-    }
-}
-                    </Document>
-                </Project>
-            </Workspace>
-
-            Await VerifyParamHints(input, output)
+            Await VerifyParamHints(input, input)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
diff --git a/src/EditorFeatures/Test2/InlineHints/CSharpInlineTypeHintsTests.vb b/src/EditorFeatures/Test2/InlineHints/CSharpInlineTypeHintsTests.vb
index 94f6fd1df503d..079e457d776ff 100644
--- a/src/EditorFeatures/Test2/InlineHints/CSharpInlineTypeHintsTests.vb
+++ b/src/EditorFeatures/Test2/InlineHints/CSharpInlineTypeHintsTests.vb
@@ -23,22 +23,7 @@ class A
                 </Project>
             </Workspace>
 
-            Dim output =
-            <Workspace>
-                <Project Language="C#" CommonReferences="true">
-                    <Document>
-class A
-{
-    void Main() 
-    {
-        int i = 0;
-    }
-}
-                    </Document>
-                </Project>
-            </Workspace>
-
-            Await VerifyTypeHints(input, output)
+            Await VerifyTypeHints(input, input)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -233,22 +218,7 @@ class A
                 </Project>
             </Workspace>
 
-            Dim output =
-            <Workspace>
-                <Project Language="C#" CommonReferences="true">
-                    <Document>
-class A
-{
-    void Main(string[] args) 
-    {
-        foreach (string j in args) {}
-    }
-}
-                    </Document>
-                </Project>
-            </Workspace>
-
-            Await VerifyTypeHints(input, output)
+            Await VerifyTypeHints(input, input)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -337,22 +307,7 @@ class A
                 </Project>
             </Workspace>
 
-            Dim output =
-            <Workspace>
-                <Project Language="C#" CommonReferences="true">
-                    <Document>
-class A
-{
-    void Main(string[] args) 
-    {
-        if (args is { Length: int goo }) { }
-    }
-}
-                    </Document>
-                </Project>
-            </Workspace>
-
-            Await VerifyTypeHints(input, output)
+            Await VerifyTypeHints(input, input)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -447,23 +402,7 @@ class A
                 </Project>
             </Workspace>
 
-            Dim output =
-            <Workspace>
-                <Project Language="C#" CommonReferences="true">
-                    <Document>
-using System.Linq;
-class A
-{
-    void Main(string[] args) 
-    {
-        args.Where((string a) => a.Length > 0);
-    }
-}
-                    </Document>
-                </Project>
-            </Workspace>
-
-            Await VerifyTypeHints(input, output)
+            Await VerifyTypeHints(input, input)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -564,24 +503,7 @@ class A
                 </Project>
             </Workspace>
 
-            Dim output =
-            <Workspace>
-                <Project Language="C#" CommonReferences="true">
-                    <Document>
-class A
-{
-    void Main(string[] args) 
-    {
-        if (int.TryParse("", out int x))
-        {
-        }
-    }
-}
-                    </Document>
-                </Project>
-            </Workspace>
-
-            Await VerifyTypeHints(input, output)
+            Await VerifyTypeHints(input, input)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
diff --git a/src/EditorFeatures/Test2/InlineHints/VisualBasicInlineParameterNameHintsTests.vb b/src/EditorFeatures/Test2/InlineHints/VisualBasicInlineParameterNameHintsTests.vb
index 2bc85485d97ec..cadead223ebb8 100644
--- a/src/EditorFeatures/Test2/InlineHints/VisualBasicInlineParameterNameHintsTests.vb
+++ b/src/EditorFeatures/Test2/InlineHints/VisualBasicInlineParameterNameHintsTests.vb
@@ -25,7 +25,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Await VerifyParamHints(input, input)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -47,7 +47,24 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="Visual Basic" CommonReferences="true">
+                    <Document>
+                        Class Foo
+                            Sub Main(args As String())
+                                TestMethod(x:=5)
+                            End Sub
+
+                            Sub TestMethod(x As Integer)
+
+                            End Sub
+                        End Class
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -69,7 +86,24 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="Visual Basic" CommonReferences="true">
+                    <Document>
+                        Class Foo
+                            Sub Main(args As String())
+                                TestMethod(x:=5, y:=2.2)
+                            End Sub
+
+                            Sub TestMethod(x As Integer, y As Double)
+
+                            End Sub
+                        End Class
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -91,7 +125,24 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="Visual Basic" CommonReferences="true">
+                    <Document>
+                        Class Foo
+                            Sub Main(args As String())
+                                TestMethod(x:=-5, y:=2.2)
+                            End Sub
+
+                            Sub TestMethod(x As Integer, y As Double)
+
+                            End Sub
+                        End Class
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -113,7 +164,24 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="Visual Basic" CommonReferences="true">
+                    <Document>
+                        Class Foo
+                            Sub Main(args As String())
+                                TestMethod(x:=CInt(5.5), y:=2.2)
+                            End Sub
+
+                            Sub TestMethod(x As Integer, y As Double)
+
+                            End Sub
+                        End Class
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -135,7 +203,24 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="Visual Basic" CommonReferences="true">
+                    <Document>
+                        Class Foo
+                            Sub Main(args As String())
+                                TestMethod(x:=CType(5.5, Integer), y:=2.2)
+                            End Sub
+
+                            Sub TestMethod(x As Integer, y As Double)
+
+                            End Sub
+                        End Class
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -157,7 +242,24 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="Visual Basic" CommonReferences="true">
+                    <Document>
+                        Public Class Test
+		                    Public Sub test(x As String)
+
+		                    End Sub
+
+		                    Public Sub Main()
+			                    test(x:=TryCast(New Object(), String))
+		                    End Sub
+	                    End Class
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -179,7 +281,24 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="Visual Basic" CommonReferences="true">
+                    <Document>
+                        Public Class Test
+		                    Public Sub test(x As String)
+
+		                    End Sub
+
+		                    Public Sub Main()
+			                    test(x:=DirectCast(New Object(), String))
+		                    End Sub
+	                    End Class
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -201,7 +320,24 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="Visual Basic" CommonReferences="true">
+                    <Document>
+                        Class Foo
+                            Sub Main(args As String())
+                                TestMethod(x:=CInt(-5.5), y:=2.2)
+                            End Sub
+
+                            Sub TestMethod(x As Integer, y As Double)
+
+                            End Sub
+                        End Class
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -223,7 +359,24 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="Visual Basic" CommonReferences="true">
+                    <Document>
+                        Class Foo
+                            Sub Main(args As String())
+                                TestMethod(x:=CInt(-5.5), y:=2.2, obj:=New Object())
+                            End Sub
+
+                            Sub TestMethod(x As Integer, y As Double, obj As Object)
+
+                            End Sub
+                        End Class
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -245,7 +398,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Await VerifyParamHints(input, input)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -265,7 +418,22 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="Visual Basic" CommonReferences="true">
+                    <Document>
+                        Public Class Test
+		                    Public Delegate Sub TestDelegate(ByVal str As String)
+
+		                    Public Sub TestTheDelegate(ByVal test As TestDelegate)
+			                    test(str:="Test")
+		                    End Sub
+	                    End Class
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -287,7 +455,24 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="Visual Basic" CommonReferences="true">
+                    <Document>
+                        Public Class Test
+		                    Public Sub UseParams(ParamArray args() As Integer)
+			                   
+		                    End Sub
+
+		                    Public Sub Main()
+			                    UseParams(args:=1, 2, 3, 4, 5)
+		                    End Sub
+	                    End Class
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -306,7 +491,21 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="Visual Basic" CommonReferences="true">
+                    <Document>
+                        &lt;Obsolete(message:="test")&gt;
+                        Public Class Foo
+                            Sub TestMethod()
+
+                            End Sub
+                        End Class
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -328,7 +527,24 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="Visual Basic" CommonReferences="true">
+                    <Document>
+                        Class Foo
+                            Sub Main(args As String())
+                                TestMethod(x:=5,)
+                            End Sub
+
+                            Sub TestMethod(x As Integer, y As Double)
+
+                            End Sub
+                        End Class
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.InlineHints)>
@@ -350,7 +566,24 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="Visual Basic" CommonReferences="true">
+                    <Document>
+                        Class Foo
+                            Sub Main(args As String())
+                                TestMethod(x:=$"")
+                            End Sub
+
+                            Sub TestMethod(x As String)
+
+                            End Sub
+                        End Class
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -372,7 +605,7 @@ end class
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Await VerifyParamHints(input, input)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -394,7 +627,7 @@ end class
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Await VerifyParamHints(input, input)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -416,7 +649,23 @@ end class
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="Visual Basic" CommonReferences="true">
+                    <Document>
+class A
+    sub EnableLogging(value as string)
+    end sub
+
+    sub Main() 
+        EnableLogging(value:="IO")
+    end sub
+end class
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -438,7 +687,23 @@ end class
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="Visual Basic" CommonReferences="true">
+                    <Document>
+class A
+    sub DisableLogging(value as string)
+    end sub
+
+    sub Main() 
+        DisableLogging(value:="IO")
+    end sub
+end class
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -460,7 +725,7 @@ end class
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Await VerifyParamHints(input, input)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -482,7 +747,23 @@ end class
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="Visual Basic" CommonReferences="true">
+                    <Document>
+class A
+    sub SetClassification(values as string)
+    end sub
+
+    sub Main() 
+        SetClassification(values:="IO")
+    end sub
+end class
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -504,7 +785,7 @@ end class
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Await VerifyParamHints(input, input)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -526,7 +807,22 @@ end class
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="Visual Basic" CommonReferences="true">
+                    <Document>
+class A
+    sub Goo(objA as integer, objB as integer, nonobjC as integer)
+    end sub
+
+    sub Main() 
+        Goo(objA:=1, objB:=2, nonobjC:=3)
+    end sub
+end class
+                    </Document>
+                </Project>
+            </Workspace>
+            Await VerifyParamHints(input, output)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -548,7 +844,7 @@ end class
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Await VerifyParamHints(input, input)
         End Function
 
         <WorkItem(47597, "https://github.com/dotnet/roslyn/issues/47597")>
@@ -570,7 +866,23 @@ end class
                 </Project>
             </Workspace>
 
-            Await VerifyParamHints(input)
+            Dim output =
+            <Workspace>
+                <Project Language="Visual Basic" CommonReferences="true">
+                    <Document>
+class A
+    sub Goo(obj1 as integer, obj2 as integer, nonobj3 as integer)
+    end sub
+
+    sub Main() 
+        Goo(obj1:=1, obj2:=2, nonobj3:=3)
+    end sub
+end class
+                    </Document>
+                </Project>
+            </Workspace>
+
+            Await VerifyParamHints(input, output)
         End Function
     End Class
 End Namespace

From cd37547af23c42b1c270a4b61ce420ae888d393f Mon Sep 17 00:00:00 2001
From: dotnet bot <dotnet-bot@dotnetfoundation.org>
Date: Thu, 9 Dec 2021 16:31:48 -0800
Subject: [PATCH 108/444] Localized file check-in by OneLocBuild Task: Build
 definition ID 327: Build ID 1505882

---
 .../CSharp/Portable/xlf/CSharpResources.cs.xlf     | 12 ++++++------
 .../CSharp/Portable/xlf/CSharpResources.de.xlf     | 12 ++++++------
 .../CSharp/Portable/xlf/CSharpResources.es.xlf     | 12 ++++++------
 .../CSharp/Portable/xlf/CSharpResources.fr.xlf     | 14 +++++++-------
 .../CSharp/Portable/xlf/CSharpResources.it.xlf     | 12 ++++++------
 .../CSharp/Portable/xlf/CSharpResources.ja.xlf     | 12 ++++++------
 .../CSharp/Portable/xlf/CSharpResources.ko.xlf     | 12 ++++++------
 .../CSharp/Portable/xlf/CSharpResources.pl.xlf     | 12 ++++++------
 .../CSharp/Portable/xlf/CSharpResources.pt-BR.xlf  | 12 ++++++------
 .../CSharp/Portable/xlf/CSharpResources.ru.xlf     | 12 ++++++------
 .../CSharp/Portable/xlf/CSharpResources.tr.xlf     | 12 ++++++------
 .../Portable/xlf/CSharpResources.zh-Hans.xlf       | 12 ++++++------
 .../Portable/xlf/CSharpResources.zh-Hant.xlf       | 12 ++++++------
 13 files changed, 79 insertions(+), 79 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
index 58d4b5275b7e7..d5ccacdd46f79 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
         <source>A lambda expression with attributes cannot be converted to an expression tree</source>
-        <target state="new">A lambda expression with attributes cannot be converted to an expression tree</target>
+        <target state="translated">Výraz lambda s atributy nejde převést na strom výrazu.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
@@ -1459,12 +1459,12 @@
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow">
         <source>The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">Operace může při běhu přetéct {0} (pro přepis použijte syntaxi unchecked)</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow_Title">
         <source>The operation may overflow at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">Operace může při běhu přetéct (pro přepis použijte syntaxi unchecked)</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_DoNotCompareFunctionPointers">
@@ -1489,12 +1489,12 @@
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
         <source>Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</source>
-        <target state="new">Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</target>
+        <target state="translated">Převádí se skupina metod {0} na nedelegující typ {1}. Chtěli jste volat tuto metodu?</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel_Title">
         <source>Converting method group to non-delegate type</source>
-        <target state="new">Converting method group to non-delegate type</target>
+        <target state="translated">Převádí se skupina metod na nedelegující typ.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1509,7 +1509,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="needs-review-translation">Parametr {0} se v seznamu parametrů nachází za {1}, ale používá se jako argument pro převody obslužných rutin interpolovaných řetězců. To vyžaduje, aby volající změnil pořadí parametrů s pojmenovanými argumenty na lokalitě volání. Doporučujeme, abyste parametr obslužné rutiny interpolovaného řetězce vložili za všechny ostatní zahrnuté argumenty.</target>
+        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
index bbeec52af850f..a091e9dc4c7b1 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
         <source>A lambda expression with attributes cannot be converted to an expression tree</source>
-        <target state="new">A lambda expression with attributes cannot be converted to an expression tree</target>
+        <target state="translated">Ein Lambdaausdruck mit Attributen kann nicht in eine Ausdrucksbaumstruktur konvertiert werden.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
@@ -1459,12 +1459,12 @@
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow">
         <source>The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">Der Vorgang kann zur Laufzeit einen Überlauf von „{0}“ verursachen (verwenden Sie zum Überschreiben die Syntax „unchecked“)</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow_Title">
         <source>The operation may overflow at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">Der Vorgang kann zur Laufzeit überlaufen (verwenden Sie zum Überschreiben die Syntax „unchecked“)</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_DoNotCompareFunctionPointers">
@@ -1489,12 +1489,12 @@
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
         <source>Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</source>
-        <target state="new">Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</target>
+        <target state="translated">Die Methodengruppe „{0}“ wird in den Nichtdelegattyp „{1}“ konvertiert. Wollten Sie die Methode aufrufen?</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel_Title">
         <source>Converting method group to non-delegate type</source>
-        <target state="new">Converting method group to non-delegate type</target>
+        <target state="translated">Die Methodengruppe wird in einen Nichtdelegattyp konvertiert.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1509,7 +1509,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="needs-review-translation">Der Parameter {0} tritt nach {1} in der Parameterliste auf, wird jedoch als Argument für die Handler-Konvertierungen einer interpolierten Zeichenfolge verwendet. Dies erfordert, dass der Aufrufer Parameter mit benannten Argumenten an der Aufrufsite neu anordnen kann. Erwägen Sie, den Handler-Parameter einer interpolierten Zeichenfolge hinter alle beteiligten Argumenten zu platzieren.</target>
+        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
index e17bac038c14d..ba6505b223f10 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
         <source>A lambda expression with attributes cannot be converted to an expression tree</source>
-        <target state="new">A lambda expression with attributes cannot be converted to an expression tree</target>
+        <target state="translated">Una expresión lambda con atributos no se puede convertir en un árbol de expresión</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
@@ -1459,12 +1459,12 @@
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow">
         <source>The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">La operación puede desbordar '{0}' en tiempo de ejecución (use la sintaxis "sin activar" para invalidar)</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow_Title">
         <source>The operation may overflow at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">La operación puede desbordarse en tiempo de ejecución (use la sintaxis "sin activar" para invalidarla).</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_DoNotCompareFunctionPointers">
@@ -1489,12 +1489,12 @@
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
         <source>Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</source>
-        <target state="new">Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</target>
+        <target state="translated">Convirtiendo el grupo de métodos '{0}' al tipo no delegado '{1}'. ¿Pretendía invocar el método?</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel_Title">
         <source>Converting method group to non-delegate type</source>
-        <target state="new">Converting method group to non-delegate type</target>
+        <target state="translated">Convirtiendo grupo de métodos a tipo no delegado</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1509,7 +1509,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="needs-review-translation">El parámetro {0}se produce después de {1} en la lista de parámetros, pero se usa como argumento para conversiones de controlador de cadena interpolada. Esto requerirá que el autor de llamada reordene los parámetros con argumentos con nombre en el sitio de llamada. Considere la posibilidad de colocar el parámetro de controlador de cadena interpolada después de todos los argumentos implicados.</target>
+        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
index 3c1a7323e1e38..61f2bc599aa2e 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
         <source>A lambda expression with attributes cannot be converted to an expression tree</source>
-        <target state="new">A lambda expression with attributes cannot be converted to an expression tree</target>
+        <target state="translated">Une expression lambda avec un corps d'instruction ne peut pas être convertie en arborescence de l'expression</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
@@ -1399,7 +1399,7 @@
       </trans-unit>
       <trans-unit id="WRN_CallerArgumentExpressionAttributeHasInvalidParameterName">
         <source>The CallerArgumentExpressionAttribute applied to parameter '{0}' will have no effect. It is applied with an invalid parameter name.</source>
-        <target state="new">The CallerArgumentExpressionAttribute applied to parameter '{0}' will have no effect. It is applied with an invalid parameter name.</target>
+        <target state="translated">Le CallerArgumentExpressionAttribute appliqué au paramètre « {0} » n’aura aucun effet. Il est appliqué avec un nom de paramètre non valide.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_CallerArgumentExpressionAttributeHasInvalidParameterName_Title">
@@ -1459,12 +1459,12 @@
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow">
         <source>The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">L'opération peut dépasser {0}' au moment de l'exécution (utilisez la syntaxe 'unchecked' pour passer outre).</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow_Title">
         <source>The operation may overflow at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">L'opération peut déborder au moment de l'exécution (utilisez la syntaxe 'unchecked' pour passer outre).</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_DoNotCompareFunctionPointers">
@@ -1489,12 +1489,12 @@
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
         <source>Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</source>
-        <target state="new">Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</target>
+        <target state="translated">Impossible de convertir le groupe de méthodes '{0}' en type non-délégué '{1}'. Souhaitiez-vous appeler la méthode?</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel_Title">
         <source>Converting method group to non-delegate type</source>
-        <target state="new">Converting method group to non-delegate type</target>
+        <target state="translated">Conversion d’un groupe de méthodes en type non-délégué</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1509,7 +1509,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="needs-review-translation">Le paramètre {0} se produit après {1} dans la liste de paramètres, mais est utilisé en tant qu’argument pour les conversions de gestionnaire de chaîne interpolées. Cela demande à l’appelant de réorganiser les paramètres avec des arguments nommés sur le site d’appel. Envisagez de placer le paramètre de gestionnaire de chaîne interpolé après tous les arguments concernés.</target>
+        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
index 7254c4dc7cfc1..84af42ac7a727 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
         <source>A lambda expression with attributes cannot be converted to an expression tree</source>
-        <target state="new">A lambda expression with attributes cannot be converted to an expression tree</target>
+        <target state="translated">Non è possibile convertire un'espressione lambda con attributi in un albero delle espressioni</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
@@ -1459,12 +1459,12 @@
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow">
         <source>The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">Con l’operazione può verificarsi un overflow '{0} 'in fase di esecuzione. Usare la sintassi 'unchecked' per eseguire l'override</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow_Title">
         <source>The operation may overflow at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">Con l’operazione può verificarsi un overflow in fase di esecuzione. Usare la sintassi 'unchecked' per eseguire l'override</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_DoNotCompareFunctionPointers">
@@ -1489,12 +1489,12 @@
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
         <source>Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</source>
-        <target state="new">Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</target>
+        <target state="translated">Conversione del gruppo di metodi '{0}' nel tipo non delegato '{1}'. Si intendeva richiamare il metodo?</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel_Title">
         <source>Converting method group to non-delegate type</source>
-        <target state="new">Converting method group to non-delegate type</target>
+        <target state="translated">Conversione del gruppo di metodi in un tipo non delegato</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1509,7 +1509,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="needs-review-translation">Il parametro {0} è indicato dopo {1} nell'elenco dei parametri, ma viene usato come argomento per le conversioni del gestore di stringhe interpolate. Al chiamante verrà richiesto di riordinare i parametri con argomenti denominati nel sito di chiamata. Provare a inserire il parametro del gestore di stringhe interpolate dopo tutti gli argomenti interessati.</target>
+        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
index a3333ff6a3b0e..cf30847919c65 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
         <source>A lambda expression with attributes cannot be converted to an expression tree</source>
-        <target state="new">A lambda expression with attributes cannot be converted to an expression tree</target>
+        <target state="translated">属性を含むラムダ式は、式ツリーに変換できません</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
@@ -1459,12 +1459,12 @@
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow">
         <source>The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">実行時に操作がオーバーフロー '{0}' する可能性があります (オーバーライドするには 'unchecked' 構文を使用してください)</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow_Title">
         <source>The operation may overflow at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">実行時に操作がオーバーフローする可能性があります (オーバーライドするには 'unchecked' 構文を使用してください)</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_DoNotCompareFunctionPointers">
@@ -1489,12 +1489,12 @@
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
         <source>Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</source>
-        <target state="new">Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</target>
+        <target state="translated">メソッド グループ '{0}' を非デリゲート型 '{1}' に変換中です。このメソッドを呼び出すつもりでしたか?</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel_Title">
         <source>Converting method group to non-delegate type</source>
-        <target state="new">Converting method group to non-delegate type</target>
+        <target state="translated">メソッド グループを非デリゲート型に変換しています</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1509,7 +1509,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="needs-review-translation">パラメーター リスト内の {1} の後にパラメーター {0} が発生しますが、補間された文字列ハンドラー変換の引数として使用されます。呼び出し元が呼び出しサイトで名前付き引数を使用してパラメーターを並べ替える必要があります。関係するすべての引数の後に、補間された文字列ハンドラーのパラメーターを指定することを検討してください。</target>
+        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
index 3c378cc729936..f1ae07a19a135 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
         <source>A lambda expression with attributes cannot be converted to an expression tree</source>
-        <target state="new">A lambda expression with attributes cannot be converted to an expression tree</target>
+        <target state="translated">특성이 있는 람다 식은 식 트리로 변환할 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
@@ -1459,12 +1459,12 @@
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow">
         <source>The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">작업이 런타임에 '{0}'을(를) 오버플로할 수 있습니다('선택되지 않은' 구문을 사용하여 재정의).</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow_Title">
         <source>The operation may overflow at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">작업이 런타임에 오버플로될 수 있습니다('선택되지 않은' 구문을 사용하여 재정의).</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_DoNotCompareFunctionPointers">
@@ -1489,12 +1489,12 @@
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
         <source>Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</source>
-        <target state="new">Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</target>
+        <target state="translated">메서드 그룹 '{0}'을(를) 비 위임 유형 '{1}'(으)로 변환하는 중입니다. 메서드를 호출하려고 했습니까?</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel_Title">
         <source>Converting method group to non-delegate type</source>
-        <target state="new">Converting method group to non-delegate type</target>
+        <target state="translated">메소드 그룹을 비 위임 유형으로 변환</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1509,7 +1509,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="needs-review-translation">매개 변수 {0}은 매개 변수 목록에서 {1} 다음에 나타나지만 보간된 문자열 처리기 변환을 위한 인수로 사용됩니다. 이렇게 하려면 호출자가 호출 사이트에서 명명된 인수를 사용하여 매개 변수를 재정렬해야 합니다. 관련된 모든 인수 뒤에 보간된 문자열 처리기 매개 변수를 넣는 것을 고려하세요.</target>
+        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
index f464377ad0eff..6809f795b8cd3 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
         <source>A lambda expression with attributes cannot be converted to an expression tree</source>
-        <target state="new">A lambda expression with attributes cannot be converted to an expression tree</target>
+        <target state="translated">Nie można przekonwertować wyrażenia lambda z atrybutami na drzewo wyrażeń</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
@@ -1459,12 +1459,12 @@
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow">
         <source>The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">Operacja może się przepełnić w środowisku uruchomieniowym „{0}” (użyj składni „niezaznaczone”, aby zastąpić)</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow_Title">
         <source>The operation may overflow at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">Operacja może się przepełnić w środowisku uruchomieniowym (użyj składni „niezaznaczone”, aby zastąpić)</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_DoNotCompareFunctionPointers">
@@ -1489,12 +1489,12 @@
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
         <source>Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</source>
-        <target state="new">Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</target>
+        <target state="translated">Konwertowanie grupy metod „{0}” na typ inny niż delegowany „{1}”. Czy zamierzasz wywołać metodę?</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel_Title">
         <source>Converting method group to non-delegate type</source>
-        <target state="new">Converting method group to non-delegate type</target>
+        <target state="translated">Konwertowanie grupy metod na typ inny niż delegowany</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1509,7 +1509,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="needs-review-translation">Parametr {0} występuje po {1} na liście parametrów, ale jest on używany jako argument dla konwersji procedury obsługi ciągów interpolowanych. Będzie to wymagać od wywołującego zmiany kolejności parametrów za pomocą nazwanych argumentów w lokacji wywołania. Rozważ umieszczenie parametru procedury obsługi ciągu interpolowanego po wszystkich zastosowanych argumentach.</target>
+        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
index 12929320d2901..a3438dab9ef84 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
         <source>A lambda expression with attributes cannot be converted to an expression tree</source>
-        <target state="new">A lambda expression with attributes cannot be converted to an expression tree</target>
+        <target state="translated">Uma expressão lambda com atributos não pode ser convertida em uma árvore de expressão</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
@@ -1459,12 +1459,12 @@
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow">
         <source>The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">A operação pode estourar '{0}' em tempo de execução (use a sintaxe 'não verificada' para substituir)</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow_Title">
         <source>The operation may overflow at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">A operação pode estourar em tempo de execução (use a sintaxe 'não verificada' para substituir)</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_DoNotCompareFunctionPointers">
@@ -1489,12 +1489,12 @@
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
         <source>Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</source>
-        <target state="new">Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</target>
+        <target state="translated">Convertendo grupo de métodos '{0}' em tipo não delegado '{1}'. Você pretendia invocar o método?</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel_Title">
         <source>Converting method group to non-delegate type</source>
-        <target state="new">Converting method group to non-delegate type</target>
+        <target state="translated">Convertendo grupo de método em tipo não delegado</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1509,7 +1509,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="needs-review-translation">O parâmetro {0} ocorre após {1} na lista de parâmetros, mas é usado como um argumento para as conversões do manipulador de cadeia de caracteres interpolada. Isso exigirá que o chamador reordene os parâmetros com argumentos nomeados no local de chamada. Considere colocar o parâmetro do manipulador de cadeia de caracteres interpolada após todos os argumentos envolvidos.</target>
+        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
index 411f8ec8d2c4e..e2f1ebf58c5b1 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
         <source>A lambda expression with attributes cannot be converted to an expression tree</source>
-        <target state="new">A lambda expression with attributes cannot be converted to an expression tree</target>
+        <target state="translated">Невозможно преобразовать лямбда-выражение с атрибутами в дерево выражения</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
@@ -1459,12 +1459,12 @@
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow">
         <source>The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">Операция может привести к переполнению "{0}" в среде выполнения (для переопределения используйте синтаксис "unchecked")</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow_Title">
         <source>The operation may overflow at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">Операция может привести к переполнению в среде выполнения (для переопределения используйте синтаксис "unchecked")</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_DoNotCompareFunctionPointers">
@@ -1489,12 +1489,12 @@
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
         <source>Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</source>
-        <target state="new">Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</target>
+        <target state="translated">Преобразование группы методов "{0}" в незаменяемый тип "{1}". Вы намеревались вызвать этот метод?</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel_Title">
         <source>Converting method group to non-delegate type</source>
-        <target state="new">Converting method group to non-delegate type</target>
+        <target state="translated">Преобразование группы методов в незаменямый тип</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1509,7 +1509,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="needs-review-translation">Параметр {0} указан после {1} в списке параметров, но используется в качестве аргумента для преобразований обработчика интерполированных строк. В этом случае вызывающий должен изменить порядок параметров с именованными аргументами на сайте вызова. Рекомендуем разместить параметр обработчика интерполированных строк после всех используемых аргументов.</target>
+        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
index ab0f6af30f932..fe6c460f85338 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
         <source>A lambda expression with attributes cannot be converted to an expression tree</source>
-        <target state="new">A lambda expression with attributes cannot be converted to an expression tree</target>
+        <target state="translated">Öznitelikleri olan bir lambda ifadesi bir ifade ağacına dönüştürülemez</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
@@ -1459,12 +1459,12 @@
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow">
         <source>The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">İşlem, çalışma zamanında “{0}” öğesini taşabilir (geçersiz kılmak için “denetlenmemiş” söz dizimini kullanın)</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow_Title">
         <source>The operation may overflow at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">İşlem, çalışma zamanında taşabilir (geçersiz kılmak için “denetlenmemiş” sözdizimini kullanın)</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_DoNotCompareFunctionPointers">
@@ -1489,12 +1489,12 @@
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
         <source>Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</source>
-        <target state="new">Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</target>
+        <target state="translated">“{0}” yöntem grubunu temsilci olmayan tip “{1}”e dönüştürme. Yöntemi çağırmayı düşündünüz mü?</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel_Title">
         <source>Converting method group to non-delegate type</source>
-        <target state="new">Converting method group to non-delegate type</target>
+        <target state="translated">Yöntem grubunu temsilci olmayan türe dönüştürme</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1509,7 +1509,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="needs-review-translation">Parametre listesinde parametre {0}, ardından parametre {1} gerçekleşir, ancak düz metin arasına kod eklenmiş dize işleyicisi dönüştürmeleri için bağımsız değişken olarak kullanılır. Bu, çağıranın, çağıran sitede adlandırılmış bağımsız değişkenlerle parametreleri yeniden düzenlemesini gerektirir. Tüm bağımsız değişkenlerin ardından düz metin arasına kod eklenmiş dize işleyicisi parametresini yerleştirmeyi göz önünde bulundurmanız gerekir.</target>
+        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
index 693c13a71cd40..a65f8d7b2ec3b 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
         <source>A lambda expression with attributes cannot be converted to an expression tree</source>
-        <target state="new">A lambda expression with attributes cannot be converted to an expression tree</target>
+        <target state="translated">无法将具有属性的 lambda 表达式转换为表达式树</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
@@ -1459,12 +1459,12 @@
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow">
         <source>The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">操作可能在运行时溢出“{0}”(请使用“unchecked”语法替代)</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow_Title">
         <source>The operation may overflow at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">操作可能在运行时溢出(请使用“unchecked”语法替代)</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_DoNotCompareFunctionPointers">
@@ -1489,12 +1489,12 @@
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
         <source>Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</source>
-        <target state="new">Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</target>
+        <target state="translated">将方法组“{0}”转换为非委托类型“{1}”。是否希望调用此方法?</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel_Title">
         <source>Converting method group to non-delegate type</source>
-        <target state="new">Converting method group to non-delegate type</target>
+        <target state="translated">将方法组转换为非委托类型</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1509,7 +1509,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="needs-review-translation">参数 {0} 在参数列表中的 {1} 后发生，但被用作内插字符串处理程序转换的参数。这将要求调用方在调用站点使用命名参数重新排列参数。请考虑将内插字符串处理程序参数放在涉及的所有参数的后面。</target>
+        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
index 70686e09b9e98..d159d4366ac26 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
         <source>A lambda expression with attributes cannot be converted to an expression tree</source>
-        <target state="new">A lambda expression with attributes cannot be converted to an expression tree</target>
+        <target state="translated">具有屬性的 Lambda 運算式，不可轉換成運算式樹狀架構</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LineSpanDirectiveEndLessThanStart">
@@ -1459,12 +1459,12 @@
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow">
         <source>The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">作業在執行階段可能會溢位 '{0}' (請使用 'unchecked' 語法覆寫)</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_CompileTimeCheckedOverflow_Title">
         <source>The operation may overflow at runtime (use 'unchecked' syntax to override)</source>
-        <target state="new">The operation may overflow at runtime (use 'unchecked' syntax to override)</target>
+        <target state="translated">作業在執行階段可能會溢位 (請使用 'unchecked' 語法覆寫)</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_DoNotCompareFunctionPointers">
@@ -1489,12 +1489,12 @@
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
         <source>Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</source>
-        <target state="new">Converting method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?</target>
+        <target state="translated">將方法群組 '{0}' 轉換成非委派類型 '{1}'。原本希望叫用該方法嗎?</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel_Title">
         <source>Converting method group to non-delegate type</source>
-        <target state="new">Converting method group to non-delegate type</target>
+        <target state="translated">將方法群組轉換為非委派類型</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1509,7 +1509,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="needs-review-translation">參數 {0} 發生在參數清單中 {1} 之後，但卻用為差補字串處理常式轉換的引數。這會要求呼叫者在呼叫網站使用具名引數重新排列參數。請考慮將差補字串處理常式參數置於所有相關的引數後面。</target>
+        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">

From 1905c1498b1c1f3d42167f7ee8291e12b3d48a8f Mon Sep 17 00:00:00 2001
From: dotnet bot <dotnet-bot@dotnetfoundation.org>
Date: Thu, 9 Dec 2021 16:34:58 -0800
Subject: [PATCH 109/444] Localized file check-in by OneLocBuild Task: Build
 definition ID 327: Build ID 1505882

---
 src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf   | 8 ++++----
 src/Features/Core/Portable/xlf/FeaturesResources.de.xlf   | 8 ++++----
 src/Features/Core/Portable/xlf/FeaturesResources.es.xlf   | 8 ++++----
 src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf   | 8 ++++----
 src/Features/Core/Portable/xlf/FeaturesResources.it.xlf   | 8 ++++----
 src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf   | 8 ++++----
 src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf   | 8 ++++----
 src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf   | 8 ++++----
 .../Core/Portable/xlf/FeaturesResources.pt-BR.xlf         | 8 ++++----
 src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf   | 8 ++++----
 src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf   | 8 ++++----
 11 files changed, 44 insertions(+), 44 deletions(-)

diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf
index 77e91fdc07aef..5342279a292fa 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf
@@ -1230,11 +1230,11 @@ Tato možnost se doporučuje, pokud víte, že zpětné vyhledávání nepovede
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="needs-review-translation">Definice vyrovnávací skupiny odstraní definici dříve definované skupiny a uloží interval mezi dříve definovanou skupinou a aktuální skupinou do aktuální skupiny.
-    
-Skupina name1 je aktuální skupina (volitelná), skupina name2 je dříve definovaná skupina a subexpression je libovolný platný vzor regulárního výrazu. Definice vyrovnávací skupiny odstraní definici skupiny name2 a uloží interval mezi skupinami name2 a name1 do skupiny name1. Pokud není definována žádná skupina name2, porovnávání se vrátí zpět. Vzhledem k tomu, že odstraněním poslední definice skupiny name2 se odkryje předchozí definice skupiny name2, umožňuje tento konstruktor použít zásobník zachycení pro skupinu name2 jako čítač pro uchování přehledu o vnořených konstruktorech, jako jsou kulaté nebo hranaté otevírací a uzavírací závorky.
+        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
 
-Definice vyrovnávací skupiny používá jako zásobník skupinu name2. Počáteční znak každého vnořeného konstruktoru se umístí do této skupiny a do její kolekce Group.Captures. Po nalezení uzavíracího znaku se odpovídající otevírací znak odebere ze skupiny a kolekce Captures se zmenší o jednu položku. Po nalezení otevíracích a uzavíracích znaků všech vnořených konstruktorů bude skupina name1 prázdná.</target>
+'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+
+The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf
index 70bfe06459cad..8400578b06720 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf
@@ -1230,11 +1230,11 @@ Diese Option empfiehlt sich, wenn Sie wissen, dass die Rückverfolgung nicht zum
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="needs-review-translation">Eine Ausgleichsgruppendefinition löscht die Definition einer zuvor definierten Gruppe und speichert in der aktuellen Gruppe das Intervall zwischen der zuvor definierten Gruppe und der aktuellen Gruppe.
-    
-"name1" ist die aktuelle Gruppe (optional), "name2" ist eine zuvor definierte Gruppe, und "teilausdruck" ist ein beliebiges gültiges Muster für reguläre Ausdrücke. Die Ausgleichsgruppendefinition löscht die Definition von "name2" und speichert das Intervall zwischen "name2" und "name1" in "name1". Wenn keine Gruppe "name2" definiert ist, wird für die Übereinstimmung eine Rückverfolgung durchgeführt. Weil durch das Löschen der letzten Definition von "name2" die vorherige Definition von "name2" angezeigt wird, können Sie mithilfe dieses Konstrukts den Stapel von Erfassungen für die Gruppe "name2" als Zähler für die Nachverfolgung geschachtelter Konstrukte wie z. B. öffnende und schließende Klammern verwenden.
+        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
 
-Die Ausgleichsgruppendefinition verwendet "name2" als Stapel. Das Anfangszeichen der einzelnen geschachtelten Konstrukte wird in der Gruppe und in der zugehörigen Group.Captures-Sammlung platziert. Wenn das schließende Zeichen gefunden wurde, wird das entsprechende öffnende Zeichen aus der Gruppe entfernt, und die Captures-Sammlung wird um eins verringert. Nachdem die öffnenden und schließenden Zeichen aller geschachtelten Konstrukte abgeglichen wurden, ist "name1" leer.</target>
+'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+
+The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf
index 16e50ea771bbc..c57a6c46a6ab6 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf
@@ -1230,11 +1230,11 @@ Se recomienda esta opción si sabe que la vuelta atrás no será correcta. Evita
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="needs-review-translation">Una definición de grupo de equilibrio elimina la definición de un grupo definido anteriormente y almacena, en el grupo actual, el intervalo entre el grupo definido anteriormente y el grupo actual.
-    
-"name1" es el grupo actual (opcional), "name2" es un grupo definido anteriormente y "subexpression" es cualquier patrón de expresión regular válido. La definición del grupo de equilibrio elimina la definición de name2 y almacena el intervalo entre name2 y name1 en name1. Si no se define un grupo de name2, la coincidencia se busca con retroceso. Como la eliminación de la última definición de name2 revela la definición anterior de name2, esta construcción permite usar la pila de capturas para el grupo name2 como contador para realizar el seguimiento de las construcciones anidadas, como los paréntesis o los corchetes de apertura y cierre.
+        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
 
-La definición del grupo de equilibrio usa "name2" como una pila. El carácter inicial de cada construcción anidada se coloca en el grupo y en su colección Group.Captures. Cuando coincide el carácter de cierre, se quita el carácter de apertura correspondiente del grupo y se quita uno de la colección Captures. Una vez que se han encontrado coincidencias de los caracteres de apertura y cierre de todas las construcciones anidadas, "name1" se queda vacío.</target>
+'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+
+The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf
index 56d4314a4a6ab..f98c7e68175ec 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf
@@ -1230,11 +1230,11 @@ Cette option est recommandée si vous savez que le retour sur trace va être un
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="needs-review-translation">Une définition de groupe d'équilibrage supprime la définition d'un groupe défini et stocke, dans le groupe actuel, l'intervalle entre le groupe défini et le groupe actuel.
-    
-'nom1' est le groupe actuel facultatif, 'nom2' est un groupe défini et 'sous-expression' est un modèle d'expression régulière valide. La définition du groupe d'équilibrage supprime la définition de name2 et stocke l'intervalle entre name2 et name1 dans name1. Si aucun groupe name2 n'est défini, la correspondance fait l'objet d'une rétroaction. Dans la mesure où la suppression de la dernière définition de name2 révèle la définition précédente de name2, cette construction vous permet d'utiliser la pile de captures du groupe name2 en tant que compteur permettant d'effectuer le suivi des constructions imbriquées telles que les parenthèses ou les crochets d'ouverture et de fermeture.
+        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
 
-La définition du groupe d'équilibrage utilise 'nom2' en tant que pile. Le caractère de début de chaque construction imbriquée est placé dans le groupe et dans sa collection Group.Captures. Quand le caractère de fermeture correspond, le caractère d'ouverture correspondant est supprimé du groupe, et la collection Captures est réduite d'un élément. Une fois que les caractères d'ouverture et de fermeture de toutes les constructions imbriquées ont été mis en correspondance, 'nom1' est vide.</target>
+'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+
+The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf
index e88788f7b3961..e2c888350583c 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf
@@ -1230,11 +1230,11 @@ Questa opzione è consigliata solo se si è certi che il backtracking avrà esit
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="needs-review-translation">Una definizione di gruppo di bilanciamento elimina la definizione di un gruppo precedentemente definito e archivia nel gruppo corrente l'intervallo tra il gruppo precedentemente definito e il gruppo corrente.
-    
-'name1' è il gruppo corrente (facoltativo), 'name2' è un gruppo precedentemente definito e 'subexpression' è qualsiasi criterio di ricerca di espressioni regolari valido. La definizione di gruppo di bilanciamento elimina la definizione di name2 e archivia l'intervallo tra name2 e name1 in name1. Se non è definito alcun gruppo name2, viene eseguito il backtracking della corrispondenza. Dal momento che l'eliminazione dell'ultima definizione di name2 rivela la definizione precedente di name2, questo costrutto consente di usare lo stack di acquisizioni per il gruppo name2 come contatore per tenere traccia dei costrutti annidati, come ad esempio le parentesi o le parentesi quadre di apertura e chiusura.
+        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
 
-La definizione del gruppo di bilanciamento usa 'name2' come uno stack. Il carattere iniziale di ogni costrutto annidato viene posizionato nel gruppo e nella relativa raccolta Group.Captures. Quando viene trovata la corrispondenza con il carattere di chiusura, il carattere di apertura associato viene rimosso dal gruppo e la raccolta Captures viene ridotta di uno. Dopo che la corrispondenza dei caratteri di apertura e chiusura di tutti i costrutti annidati è stata trovata, 'name1' è vuoto.</target>
+'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+
+The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf
index 8a08248fc5ad8..ed91d088918e3 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf
@@ -1230,11 +1230,11 @@ This option is recommended if you know that backtracking will not succeed. Preve
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="needs-review-translation">グループ定義の均等化では、既に定義されていたグループの定義を削除し、既に定義されていたグループと現在のグループの間隔を現在のグループに格納します。
-    
-'name1' は現在のグループ (省略可能) で、'name2' は既に定義されていたグループで、'subexpression' は有効な正規表現パターンです。グループ定義の均等化では、name2 の定義を削除し、name2 と name1 の間隔を name1 に格納します。name2 グループが定義されていない場合、一致はバックトラックされます。name2 の最後の定義を削除すると、name2 の以前の定義がわかるため、このコンストラクトによって、かっこや左右の角かっこなど入れ子になったコンストラクトを追跡するカウンターとして name2 グループのキャプチャのスタックを使用できます。
+        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
 
-グループ定義の均等化では、'name2' をスタックとして使用します。入れ子になった各コンストラクトの開始文字が、グループとその Group.Captures コレクションに配置されます。終了文字が一致すると、対応する開始文字がグループから削除され、Captures コレクションが 1 つ減らされます。入れ子になったすべてのコンストラクトの開始文字と終了文字が一致したら、name1 は空になります。</target>
+'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+
+The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf
index 817e281d37de5..e632e98d0dd51 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf
@@ -1230,11 +1230,11 @@ This option is recommended if you know that backtracking will not succeed. Preve
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="needs-review-translation">균형 조정 그룹 정의는 이전에 정의된 그룹의 정의를 삭제하고, 이전에 정의된 그룹과 현재 그룹 사이의 간격을 현재 그룹에 저장합니다.
-    
-'name1'은 현재 그룹이고(선택 사항), 'name2'는 이전에 정의된 그룹이며, 'subexpression'은 유효한 정규식 패턴입니다. 균형 조정 그룹 정의는 name2의 정의를 삭제하고 name2와 name1 사이의 간격을 name1에 저장합니다. name2 그룹이 정의되어 있지 않으면 일치에서 역추적합니다. name2의 마지막 정의를 삭제하면 name2의 이전 정의가 표시되므로 이 구문을 통해 name2 그룹에 대한 캡처 스택을 괄호 또는 여는 대괄호 및 닫는 대괄호와 같은 중첩 구문을 추적하기 위한 카운터로 사용할 수 있습니다.
+        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
 
-균형 조정 그룹 정의에서는 'name2'를 스택으로 사용합니다. 각 중첩 구문의 시작 문자는 그룹 및 해당 Group.Captures 컬렉션에 배치됩니다. 닫는 문자가 일치되면 해당하는 여는 문자가 그룹에서 제거되고 Captures 컬렉션이 하나 감소합니다. 모든 중첩 구문의 여는 문자와 닫는 문자가 일치되고 나면 'name1'은 비어 있는 상태가 됩니다.</target>
+'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+
+The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf
index b4173cb10a501..ce3e2f93969db 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf
@@ -1230,11 +1230,11 @@ Ta opcja jest zalecana, jeśli wiesz, że cofanie się nie powiedzie się. Zapob
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="needs-review-translation">Definicja grupy dopasowywania usuwa definicję uprzednio zdefiniowanej grupy i zapisuje w bieżącej grupie interwał między poprzednio zdefiniowaną grupą a bieżącą grupą.
-    
-„Nazwa1” to bieżąca grupa (opcjonalna), „nazwa2” to wcześniej zdefiniowana grupa, a element „podwyrażenie” to dowolny prawidłowy wzorzec wyrażenia regularnego. Definicja grupy dopasowywania usuwa definicję elementu nazwa2 i zapisuje interwał między elementami nazwa2 i nazwa1 w elemencie nazwa1. Jeśli nie zdefiniowano grupy nazwa2, następuje cofanie dopasowywania. Ponieważ usunięcie ostatniej definicji elementu nazwa2 ujawnia jego poprzednią definicję, ta konstrukcja umożliwia użycie stosu przechwyceń dla grupy nazwa2 jako licznika służącego do śledzenia zagnieżdżonych konstrukcji, takich jak nawiasy lub otwierające i zamykające nawiasy klamrowe.
+        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
 
-Definicja grupy dopasowywania używa elementu „nazwa2” jako stosu. Początkowy znak każdej zagnieżdżonej konstrukcji jest umieszczany w grupie i w jej kolekcji Group.Captures. Po dopasowaniu znaku zamykającego odpowiadający mu znak otwierający jest usuwany z grupy, a kolekcja Captures jest zmniejszana o jeden. Po dopasowaniu otwierających i zamykających znaków wszystkich zagnieżdżonych konstrukcji element „nazwa1” jest pusty.</target>
+'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+
+The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf
index 75328e454d401..7fabf52e97781 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf
@@ -1230,11 +1230,11 @@ Essa opção é recomendada quando você sabe que o rastreamento inverso não se
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="needs-review-translation">Uma definição de grupo de balanceamento exclui a definição de um grupo definido anteriormente e armazena, no grupo atual, o intervalo entre o grupo definido anteriormente e o grupo atual.
-    
-'name1' é o grupo atual (opcional), 'name2' é um grupo definido anteriormente e 'subexpression' é qualquer padrão de expressão regular válido. A definição de grupo de balanceamento exclui a definição de name2 e armazena o intervalo entre name2 e name1 no name1. Se não for definido nenhum name2, a correspondência retrocederá. Como a exclusão da última definição de name2 revela a definição anterior de name2, esse constructo permite o uso da pilha de capturas para o grupo name2 como um contador para manter o controle de constructos aninhados, como parênteses ou colchetes de abertura e fechamento.
+        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
 
-A definição de grupo de balanceamento usa 'name2' como uma pilha. O caractere inicial de cada constructo aninhado é colocado no grupo e em sua coleção Group.Captures. Quando o caractere de fechamento é correspondido, seu caractere de abertura correspondente é removido do grupo e a coleção Captures é reduzida em um. Após a correspondência dos caracteres de abertura e fechamento de todas as construções aninhadas, 'name1' ficará vazio.</target>
+'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+
+The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf
index 4520b95b50957..7a188854f2763 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf
@@ -1230,11 +1230,11 @@ This option is recommended if you know that backtracking will not succeed. Preve
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="needs-review-translation">Сбалансированное определение группы удаляет определение ранее определенной группы и сохраняет (в текущей группе) интервал между ранее определенной группой и текущей группой.
-    
-Значение "имя1" является текущей группой (необязательная), "имя2" является ранее определенной группой, а "часть выражения" является любым допустимым шаблоном регулярного выражения. Сбалансированное определение группы удаляет определение "имя2" и сохраняет интервал между "имя2" и "имя1" в "имя1". Если группа "имя2" не определена, соответствие определяется по обратному отслеживанию. Так как удаление последнего определения name2 приводит к раскрытию предыдущего определения "имя2", эта конструкция позволяет использовать стек записей для группы "имя2" в качестве счетчика для отслеживания вложенных конструкций, таких как круглые скобки или открывающие и закрывающие скобки.
+        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
 
-Сбалансированное определение группы использует "имя2" в качестве стека. Начальный символ каждой вложенной конструкции помещается в группу и ее коллекцию Group.Captures. При появлении совпадения для закрывающего символа соответствующий ему открывающий символ удаляется из группы, а коллекция Captures уменьшается на единицу. После обнаружения совпадений для всех открывающих и закрывающих символов всех вложенных конструкций "имя1" остается пустой.</target>
+'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+
+The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf
index 5094fac4ad630..03643f457100e 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf
@@ -1230,11 +1230,11 @@ Bu seçenek, geri izlemenin başarısız olacağını biliyorsanız önerilir. N
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="needs-review-translation">Bir dengeleme grubu tanımı, geçerli grupta, önceden tanımlanmış grup ile geçerli grup arasındaki aralıkta, önceden tanımlanmış bir grubun ve depoların tanımını siler.
-    
-'name1' geçerli grup (isteğe bağlı), 'name2' önceden tanımlanmış bir grup ve 'subexpression' ise herhangi bir geçerli normal ifade desenidir. Dengeleme grubu tanımı name2'nin tanımını siler ve name2 ile name1 arasındaki aralığı name1'e depolar. Bir name2 grubu tanımlanmamışsa, eşleşme geri iz sürer. name2'nin son tanımını silmek, name2'nin önceki tanımını ortaya çıkardığından, bu yapı name2 grubu için yakalama yığınını, parantez veya açma ve kapama ayracı gibi iç içe yapıları izlemek için bir sayaç olarak kullanmanıza olanak sağlar.
+        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
 
-Dengeleme grubu tanımı 'name2' öğesini bir yığın olarak kullanır. Her iç içe yapının başlangıç karakteri, gruba ve grubun Group.Captures koleksiyonuna yerleştirilir. Kapanış karakteri eşleştiğinde, karşılık gelen açma karakteri gruptan kaldırılır ve Captures koleksiyonunda bir öğe azalır. İç içe tüm yapıların açılış ve kapanış karakterleri eşleştirildikten sonra, 'name1' boş olur.</target>
+'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+
+The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">

From a729cc1129c320eadeae8aa2755c3edc875db3ab Mon Sep 17 00:00:00 2001
From: dotnet bot <dotnet-bot@dotnetfoundation.org>
Date: Thu, 9 Dec 2021 16:41:31 -0800
Subject: [PATCH 110/444] Localized file check-in by OneLocBuild Task: Build
 definition ID 327: Build ID 1505882

---
 .../Core/Portable/xlf/FeaturesResources.zh-Hans.xlf       | 8 ++++----
 .../Core/Portable/xlf/FeaturesResources.zh-Hant.xlf       | 8 ++++----
 src/VisualStudio/Core/Def/xlf/Commands.vsct.cs.xlf        | 2 +-
 src/VisualStudio/Core/Def/xlf/Commands.vsct.de.xlf        | 2 +-
 src/VisualStudio/Core/Def/xlf/Commands.vsct.es.xlf        | 2 +-
 src/VisualStudio/Core/Def/xlf/Commands.vsct.fr.xlf        | 2 +-
 src/VisualStudio/Core/Def/xlf/Commands.vsct.it.xlf        | 2 +-
 src/VisualStudio/Core/Def/xlf/Commands.vsct.ja.xlf        | 2 +-
 src/VisualStudio/Core/Def/xlf/Commands.vsct.ko.xlf        | 2 +-
 src/VisualStudio/Core/Def/xlf/Commands.vsct.pl.xlf        | 2 +-
 src/VisualStudio/Core/Def/xlf/Commands.vsct.pt-BR.xlf     | 2 +-
 src/VisualStudio/Core/Def/xlf/Commands.vsct.ru.xlf        | 2 +-
 src/VisualStudio/Core/Def/xlf/Commands.vsct.tr.xlf        | 2 +-
 src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hans.xlf   | 2 +-
 src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hant.xlf   | 2 +-
 15 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf
index 6dfd1ec62c71c..c1a837e7a92a7 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf
@@ -1230,11 +1230,11 @@ This option is recommended if you know that backtracking will not succeed. Preve
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="needs-review-translation">均衡组定义删除以前定义的组的定义，并在当前组中存储以前定义的组和当前组之间的时间间隔。
-    
-"name1" 是当前组(可选)，"name2" 是以前定义的组，而 "subexpression" 是任何有效的正则表达式模式。均衡组定义将删除 name2 的定义，并在 name1 中存储 name2 和 name1 之间的间隔。如果未定义 name2 组，则匹配回溯。由于删除 name2 的最后一个定义会发现 name2 的上一个定义，此构造使你能够使用作为计数器的组的捕获堆栈来跟踪嵌套构造(如括号)或左括号和右括号。
+        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
 
-均衡组定义使用 "name2" 作为堆栈。每个嵌套构造的开始字符都放在该组中并位于其组中。捕获集合。匹配结束字符时，将从组中删除其相应的左符号，并减小捕获集合 1。在所有嵌套构造的开始和结束字符都匹配后，"name1" 为空。</target>
+'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+
+The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf
index 2c253c962539c..c6005c0beac52 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf
@@ -1230,11 +1230,11 @@ This option is recommended if you know that backtracking will not succeed. Preve
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="needs-review-translation">平衡群組定義會刪除先前已定義群組的定義，並將先前定義的群組和目前群組間的間隔儲存在目前的群組內。
-    
-'name1' 是目前的群組 (選擇性)，'name2' 是先前定義的群組，'subexpression' 是任何有效的規則運算式模式。平衡群組定義會刪除 name2 的定義，並將 name2 與 name1 之間的間隔儲存在 name1 內。如果未指定 name2 群組，則比對會回溯。因為刪除 name2 的上一個定義會顯示 name2 先前的定義，所以此建構可讓您使用群組 name2 的擷取堆疊來作為計數器，用來追蹤括號或左右括弧等巢狀建構。
+        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
 
-平衡群組定義會使用 'name2' 作為堆疊。各巢狀建構的開頭字元會置於群組和其 Group.Captures 集合內。符合右側字元時，會將其對應的左側字元從群組移除，使 Captures 集合減少一。當所有巢狀建構的左側和右側字元均相符後，'name1' 會空白。</target>
+'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+
+The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.cs.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.cs.xlf
index f516d22dfad59..47016693a2da1 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.cs.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.cs.xlf
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="needs-review-translation">ViewEditorConfigSettings</target>
+        <target state="new">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.de.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.de.xlf
index b510ee4dc8dbd..5365882fb3c2e 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.de.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.de.xlf
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="needs-review-translation">ViewEditorConfigSettings</target>
+        <target state="new">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.es.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.es.xlf
index 7b6847b4b8126..b2391b1b620d7 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.es.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.es.xlf
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="needs-review-translation">ViewEditorConfigSettings</target>
+        <target state="new">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.fr.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.fr.xlf
index a0c243f37cd74..3358da7a885d7 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.fr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.fr.xlf
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="needs-review-translation">ViewEditorConfigSettings</target>
+        <target state="new">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.it.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.it.xlf
index 781f15670c508..23ede8b3c63e0 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.it.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.it.xlf
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="needs-review-translation">ViewEditorConfigSettings</target>
+        <target state="new">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ja.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ja.xlf
index e550efb10549a..16fbb59599d20 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ja.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ja.xlf
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="needs-review-translation">ViewEditorConfigSettings</target>
+        <target state="new">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ko.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ko.xlf
index 8becfe37d398c..6370a4b4f9349 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ko.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ko.xlf
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="needs-review-translation">ViewEditorConfigSettings</target>
+        <target state="new">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.pl.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.pl.xlf
index 23e0970b25ca2..1e087ee92161e 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.pl.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.pl.xlf
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="needs-review-translation">ViewEditorConfigSettings</target>
+        <target state="new">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.pt-BR.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.pt-BR.xlf
index 3487ee88ca2fe..84b30b014a033 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.pt-BR.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.pt-BR.xlf
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="needs-review-translation">ViewEditorConfigSettings</target>
+        <target state="new">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ru.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ru.xlf
index cac44003cd9f6..9a25da077a0d0 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ru.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ru.xlf
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="needs-review-translation">ViewEditorConfigSettings</target>
+        <target state="new">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.tr.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.tr.xlf
index 4309793a2a3f4..6f13ac38d8bf2 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.tr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.tr.xlf
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="needs-review-translation">ViewEditorConfigSettings</target>
+        <target state="new">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hans.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hans.xlf
index 43a17344db992..c54de2a375280 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hans.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hans.xlf
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="needs-review-translation">ViewEditorConfigSettings</target>
+        <target state="new">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hant.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hant.xlf
index 8d9c1550c5684..b94e275f845a7 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hant.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hant.xlf
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="needs-review-translation">ViewEditorConfigSettings</target>
+        <target state="new">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">

From cc2a201eace233c4f0a5d3f8338e59ef1071ed8a Mon Sep 17 00:00:00 2001
From: dotnet bot <dotnet-bot@dotnetfoundation.org>
Date: Thu, 9 Dec 2021 16:44:38 -0800
Subject: [PATCH 111/444] Localized file check-in by OneLocBuild Task: Build
 definition ID 327: Build ID 1505882


From 4cb9c04d6cb01051aecac262d2854318bc5e7df2 Mon Sep 17 00:00:00 2001
From: Joey Robichaud <jorobich@microsoft.com>
Date: Wed, 15 Dec 2021 10:12:30 -0800
Subject: [PATCH 112/444] Update hosted VS 2017 usage to 2019

---
 azure-pipelines-official.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/azure-pipelines-official.yml b/azure-pipelines-official.yml
index e05646782b48f..17a254002c669 100644
--- a/azure-pipelines-official.yml
+++ b/azure-pipelines-official.yml
@@ -284,7 +284,7 @@ stages:
       dependsOn:
         - OfficialBuild
       pool:
-        vmImage: vs2017-win2016
+        vmImage: windows-2019
 
 - stage: insert
   dependsOn:

From 08c07a2b81e52b53eaeba2cb473b04809e6dbf90 Mon Sep 17 00:00:00 2001
From: Joey Robichaud <jorobich@microsoft.com>
Date: Thu, 16 Dec 2021 10:06:00 -0800
Subject: [PATCH 113/444] Bump SDK

---
 global.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/global.json b/global.json
index 812f9823e3a73..d7b31f0fb8bc3 100644
--- a/global.json
+++ b/global.json
@@ -1,11 +1,11 @@
 {
   "sdk": {
-    "version": "6.0.100-preview.1.21103.13",
+    "version": "6.0.100-preview.3.21202.5",
     "allowPrerelease": true,
     "rollForward": "major"
   },
   "tools": {
-    "dotnet": "6.0.100-preview.1.21103.13",
+    "dotnet": "6.0.100-preview.3.21202.5",
     "vs": {
       "version": "16.8"
     },

From 6710f08ceff9e95a6805b2104e970004c5b38f9b Mon Sep 17 00:00:00 2001
From: Jonathon Marolf <jmarolf@microsoft.com>
Date: Thu, 16 Dec 2021 17:20:30 -0800
Subject: [PATCH 114/444] use pairwise testing approach

---
 azure-pipelines-integration-corehost.yml | 35 ++++++-----
 azure-pipelines-integration.yml          | 74 +++++++++++++++++-------
 2 files changed, 73 insertions(+), 36 deletions(-)

diff --git a/azure-pipelines-integration-corehost.yml b/azure-pipelines-integration-corehost.yml
index d34995411c3cc..4b819e3710179 100644
--- a/azure-pipelines-integration-corehost.yml
+++ b/azure-pipelines-integration-corehost.yml
@@ -18,27 +18,34 @@ pr:
 - features/*
 - demos/*
 
-variables:
-  - name: XUNIT_LOGS
-    value: $(Build.SourcesDirectory)\artifacts\log\$(_configuration)
-
 jobs:
-- job: VS_Integration_CoreHost
+- job: VS_Integration_CoreHost_Debug
   pool:
     name: NetCore1ESPool-Public
     demands: ImageOverride -equals $(queueName)
-  strategy:
-    maxParallel: 2
-    matrix:
-      debug:
-        _configuration: Debug
-      release:
-        _configuration: Release
   timeoutInMinutes: 135
-
+  variables:
+    - name: XUNIT_LOGS
+      value: $(Build.SourcesDirectory)\artifacts\log\Debug
   steps:
     - template: eng/pipelines/test-integration-job.yml
       parameters:
-        configuration: $(_configuration)
+        configuration: Debug
         oop64bit: true
         oopCoreClr: true
+
+- ${{ if ne(variables['Build.Reason'], 'PullRequest') }}:
+  - job: VS_Integration_CoreHost_Release
+    pool:
+      name: NetCore1ESPool-Public
+      demands: ImageOverride -equals $(queueName)
+    timeoutInMinutes: 135
+    variables:
+      - name: XUNIT_LOGS
+        value: $(Build.SourcesDirectory)\artifacts\log\Debug
+    steps:
+      - template: eng/pipelines/test-integration-job.yml
+        parameters:
+          configuration: Release
+          oop64bit: true
+          oopCoreClr: true
diff --git a/azure-pipelines-integration.yml b/azure-pipelines-integration.yml
index d47ecd4d8087a..190afc17d7a32 100644
--- a/azure-pipelines-integration.yml
+++ b/azure-pipelines-integration.yml
@@ -14,35 +14,65 @@ pr:
 - features/*
 - demos/*
 
-variables:
-  - name: XUNIT_LOGS
-    value: $(Build.SourcesDirectory)\artifacts\log\$(_configuration)
-
 jobs:
-- job: VS_Integration
+- ${{ if ne(variables['Build.Reason'], 'PullRequest') }}:
+  - job: VS_Integration_Debug_32
+    pool:
+      name: $(poolName)
+      demands: ImageOverride -equals $(queueName)
+    timeoutInMinutes: 135
+    variables:
+      - name: XUNIT_LOGS
+        value: $(Build.SourcesDirectory)\artifacts\log\Debug
+    steps:
+      - template: eng/pipelines/test-integration-job.yml
+        parameters:
+          configuration: Debug
+          oop64bit: false
+          lspEditor: false
+
+- job: VS_Integration_Debug_64
   pool:
     name: $(poolName)
     demands: ImageOverride -equals $(queueName)
-  strategy:
-    maxParallel: 4
-    matrix:
-      debug_32:
-        _configuration: Debug
-        _oop64bit: false
-      debug_64:
-        _configuration: Debug
-        _oop64bit: true
-      release_32:
-        _configuration: Release
-        _oop64bit: false
-      release_64:
-        _configuration: Release
-        _oop64bit: true
   timeoutInMinutes: 135
+  variables:
+    - name: XUNIT_LOGS
+      value: $(Build.SourcesDirectory)\artifacts\log\Debug
+  steps:
+    - template: eng/pipelines/test-integration-job.yml
+      parameters:
+        configuration: Debug
+        oop64bit: true
+        lspEditor: false
 
+- job: VS_Integration_Release_32
+  pool:
+    name: $(poolName)
+    demands: ImageOverride -equals $(queueName)
+  timeoutInMinutes: 135
+  variables:
+    - name: XUNIT_LOGS
+      value: $(Build.SourcesDirectory)\artifacts\log\Release
   steps:
     - template: eng/pipelines/test-integration-job.yml
       parameters:
-        configuration: $(_configuration)
-        oop64bit: $(_oop64bit)
+        configuration: Release
+        oop64bit: false
         lspEditor: false
+
+- ${{ if ne(variables['Build.Reason'], 'PullRequest') }}:
+  - job: VS_Integration_Release_64
+    pool:
+      name: $(poolName)
+      demands: ImageOverride -equals $(queueName)
+    timeoutInMinutes: 135
+    variables:
+      - name: XUNIT_LOGS
+        value: $(Build.SourcesDirectory)\artifacts\log\Release
+    steps:
+      - template: eng/pipelines/test-integration-job.yml
+        parameters:
+          configuration: Release
+          oop64bit: true
+          lspEditor: false

From 3035dcccf3324a5ee79149f5d1db43b18e6fdb6f Mon Sep 17 00:00:00 2001
From: Manish Vasani <mavasani@microsoft.com>
Date: Fri, 17 Dec 2021 03:39:00 -0800
Subject: [PATCH 115/444] Fixes
 [AB#1450689](https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1450689)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This regression was introduced with async lightbulb performance improvement PR: #56959. With that PR, we now optimize/reduce the number of analyzers to execute in the "Normal" priority bucket for async light bulb. We earlier executed all analyzers in this bucket, but now only try to execute analyzers which report at least one diagnostic ID which has a corresponding code fix provider that can fix that diagnostic ID.

To identify this reduced set of analyzers, we execute this newly added perf optimization to skip analyzers that don't have a code fix: https://github.com/dotnet/roslyn/blob/88f829939583d49d9e08104a71a7645d712bcfbc/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer_GetDiagnosticsForSpan.cs#L151-L155

`_owner.DiagnosticAnalyzerInfoCache.GetDiagnosticDescriptors` call in this code is problematic for TS analyzers, because these are not regular DiagnosticAnalyzer sub-types, but instead derive from our internal DocumentDiagnosticAnalyzer and ProjectDiagnosticAnalyzer types, and this analyzer lies to us and returns 0 supported diagnostic descriptors: https://github.com/dotnet/roslyn/blob/315c2e149ba7889b0937d872274c33fcbfe9af5f/src/Features/Core/Portable/ExternalAccess/VSTypeScript/VSTypeScriptDocumentDiagnosticAnalyzer.cs#L16 and https://github.com/dotnet/roslyn/blob/315c2e149ba7889b0937d872274c33fcbfe9af5f/src/Features/Core/Portable/ExternalAccess/VSTypeScript/VSTypeScriptProjectDiagnosticAnalyzer.cs#L16. So, we skip TS analyzers for "Normal" priority bucket.

This PR implements a short term fix to update the newly added code to special case DocumentDiagnosticAnalyzers and skip the newly added perf optimization for these analyzers. Note that ProjectDiagnosticAnalyzers are never executed in lightbulb/code fix path.

I will create a separate issue to track designing a better long term solution for TS analyzers to avoid such breaking changes in future.
---
 .../Test/CodeFixes/CodeFixServiceTests.cs     | 84 ++++++++++++++++---
 ...crementalAnalyzer_GetDiagnosticsForSpan.cs | 29 ++++++-
 2 files changed, 97 insertions(+), 16 deletions(-)

diff --git a/src/EditorFeatures/Test/CodeFixes/CodeFixServiceTests.cs b/src/EditorFeatures/Test/CodeFixes/CodeFixServiceTests.cs
index 8b05e633a8ab5..e3642b0df912a 100644
--- a/src/EditorFeatures/Test/CodeFixes/CodeFixServiceTests.cs
+++ b/src/EditorFeatures/Test/CodeFixes/CodeFixServiceTests.cs
@@ -158,6 +158,34 @@ public async Task TestGetFixesAsyncForFixableAndNonFixableAnalyzersAsync()
             Assert.True(analyzerWithoutFix.ReceivedCallback);
         }
 
+        [Fact, WorkItem(1450689, "https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1450689")]
+        public async Task TestGetFixesAsyncForDocumentDiagnosticAnalyzerAsync()
+        {
+            // TS has special DocumentDiagnosticAnalyzer that report 0 SupportedDiagnostics.
+            // We need to ensure that we don't skip these document analyzers
+            // when computing the diagnostics/code fixes for "Normal" priority bucket, which
+            // normally only execute those analyzers which report at least one fixable supported diagnostic.
+            var documentDiagnosticAnalyzer = new MockAnalyzerReference.MockDocumentDiagnosticAnalyzer(reportedDiagnosticIds: ImmutableArray<string>.Empty);
+            Assert.Empty(documentDiagnosticAnalyzer.SupportedDiagnostics);
+
+            var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(documentDiagnosticAnalyzer);
+            var codeFix = new MockFixer();
+            var analyzerReference = new MockAnalyzerReference(codeFix, analyzers);
+
+            // Verify no callbacks received at initialization.
+            Assert.False(documentDiagnosticAnalyzer.ReceivedCallback);
+
+            var tuple = ServiceSetup(codeFix, includeConfigurationFixProviders: false);
+            using var workspace = tuple.workspace;
+            GetDocumentAndExtensionManager(tuple.analyzerService, workspace, out var document, out var extensionManager, analyzerReference);
+
+            // Verify both analyzers are executed when GetFixesAsync is invoked with 'CodeActionRequestPriority.Normal'.
+            _ = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0),
+                priority: CodeActionRequestPriority.Normal, isBlocking: false,
+                addOperationScope: _ => null, cancellationToken: CancellationToken.None);
+            Assert.True(documentDiagnosticAnalyzer.ReceivedCallback);
+        }
+
         [Fact]
         public async Task TestGetCodeFixWithExceptionInRegisterMethod_Diagnostic()
         {
@@ -401,6 +429,18 @@ public override ImmutableArray<DiagnosticAnalyzer> GetAnalyzersForAllLanguages()
             public ImmutableArray<CodeFixProvider> GetFixers()
                 => Fixer != null ? ImmutableArray.Create(Fixer) : ImmutableArray<CodeFixProvider>.Empty;
 
+            private static ImmutableArray<DiagnosticDescriptor> CreateSupportedDiagnostics(ImmutableArray<(string id, string category)> reportedDiagnosticIdsWithCategories)
+            {
+                var builder = ArrayBuilder<DiagnosticDescriptor>.GetInstance();
+                foreach (var (diagnosticId, category) in reportedDiagnosticIdsWithCategories)
+                {
+                    var descriptor = new DiagnosticDescriptor(diagnosticId, "MockDiagnostic", "MockDiagnostic", category, DiagnosticSeverity.Warning, isEnabledByDefault: true);
+                    builder.Add(descriptor);
+                }
+
+                return builder.ToImmutableAndFree();
+            }
+
             public class MockDiagnosticAnalyzer : DiagnosticAnalyzer
             {
                 public MockDiagnosticAnalyzer(ImmutableArray<(string id, string category)> reportedDiagnosticIdsWithCategories)
@@ -423,18 +463,6 @@ public MockDiagnosticAnalyzer()
 
                 public bool ReceivedCallback { get; private set; }
 
-                private static ImmutableArray<DiagnosticDescriptor> CreateSupportedDiagnostics(ImmutableArray<(string id, string category)> reportedDiagnosticIdsWithCategories)
-                {
-                    var builder = ArrayBuilder<DiagnosticDescriptor>.GetInstance();
-                    foreach (var (diagnosticId, category) in reportedDiagnosticIdsWithCategories)
-                    {
-                        var descriptor = new DiagnosticDescriptor(diagnosticId, "MockDiagnostic", "MockDiagnostic", category, DiagnosticSeverity.Warning, isEnabledByDefault: true);
-                        builder.Add(descriptor);
-                    }
-
-                    return builder.ToImmutableAndFree();
-                }
-
                 public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; }
 
                 public override void Initialize(AnalysisContext context)
@@ -450,6 +478,38 @@ public override void Initialize(AnalysisContext context)
                     });
                 }
             }
+
+            public class MockDocumentDiagnosticAnalyzer : DocumentDiagnosticAnalyzer
+            {
+                public MockDocumentDiagnosticAnalyzer(ImmutableArray<(string id, string category)> reportedDiagnosticIdsWithCategories)
+                    => SupportedDiagnostics = CreateSupportedDiagnostics(reportedDiagnosticIdsWithCategories);
+
+                public MockDocumentDiagnosticAnalyzer(ImmutableArray<string> reportedDiagnosticIds)
+                    : this(reportedDiagnosticIds.SelectAsArray(id => (id, "InternalCategory")))
+                {
+                }
+
+                public MockDocumentDiagnosticAnalyzer()
+                    : this(ImmutableArray.Create(MockFixer.Id))
+                {
+                }
+
+                public bool ReceivedCallback { get; private set; }
+
+                public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; }
+
+                public override Task<ImmutableArray<Diagnostic>> AnalyzeSyntaxAsync(Document document, CancellationToken cancellationToken)
+                {
+                    ReceivedCallback = true;
+                    return Task.FromResult(ImmutableArray<Diagnostic>.Empty);
+                }
+
+                public override Task<ImmutableArray<Diagnostic>> AnalyzeSemanticsAsync(Document document, CancellationToken cancellationToken)
+                {
+                    ReceivedCallback = true;
+                    return Task.FromResult(ImmutableArray<Diagnostic>.Empty);
+                }
+            }
         }
 
         internal class TestErrorLogger : IErrorLoggerService
diff --git a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer_GetDiagnosticsForSpan.cs b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer_GetDiagnosticsForSpan.cs
index 239a1327c5863..6bb483dfd0bd5 100644
--- a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer_GetDiagnosticsForSpan.cs
+++ b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer_GetDiagnosticsForSpan.cs
@@ -148,11 +148,8 @@ public async Task<bool> TryGetAsync(ArrayBuilder<DiagnosticData> list, Cancellat
                     using var _3 = ArrayBuilder<DiagnosticAnalyzer>.GetInstance(out var semanticDocumentBasedAnalyzers);
                     foreach (var stateSet in _stateSets)
                     {
-                        if (_shouldIncludeDiagnostic != null &&
-                            !_owner.DiagnosticAnalyzerInfoCache.GetDiagnosticDescriptors(stateSet.Analyzer).Any(a => _shouldIncludeDiagnostic(a.Id)))
-                        {
+                        if (!ShouldIncludeAnalyzer(stateSet.Analyzer, _shouldIncludeDiagnostic, _owner))
                             continue;
-                        }
 
                         if (!await TryAddCachedDocumentDiagnosticsAsync(stateSet, AnalysisKind.Syntax, list, cancellationToken).ConfigureAwait(false))
                             syntaxAnalyzers.Add(stateSet.Analyzer);
@@ -186,6 +183,30 @@ public async Task<bool> TryGetAsync(ArrayBuilder<DiagnosticData> list, Cancellat
                 {
                     throw ExceptionUtilities.Unreachable;
                 }
+
+                // Local functions
+                static bool ShouldIncludeAnalyzer(
+                    DiagnosticAnalyzer analyzer,
+                    Func<string, bool>? shouldIncludeDiagnostic,
+                    DiagnosticIncrementalAnalyzer owner)
+                {
+                    // Special case DocumentDiagnosticAnalyzer to never skip these document analyzers
+                    // based on 'shouldIncludeDiagnostic' predicate. More specifically, TS has special document
+                    // analyzer which report 0 supported diagnostics, but we always want to execute it.
+                    if (analyzer is DocumentDiagnosticAnalyzer)
+                    {
+                        return true;
+                    }
+
+                    // Skip analyzer if none of its reported diagnostics should be included.
+                    if (shouldIncludeDiagnostic != null &&
+                        !owner.DiagnosticAnalyzerInfoCache.GetDiagnosticDescriptors(analyzer).Any(a => shouldIncludeDiagnostic(a.Id)))
+                    {
+                        return false;
+                    }
+
+                    return true;
+                }
             }
 
             /// <summary>

From 22e72688c39be22eb72d12a8a197a44d3092a8af Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Fri, 17 Dec 2021 08:23:41 -0800
Subject: [PATCH 116/444] Acquire component model with standard pattern

---
 .../Def/Implementation/LanguageService/AbstractPackage`2.cs   | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage`2.cs b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage`2.cs
index 08625ae785da0..6ea937414ab28 100644
--- a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage`2.cs
+++ b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage`2.cs
@@ -42,11 +42,9 @@ protected override async Task InitializeAsync(CancellationToken cancellationToke
         {
             await base.InitializeAsync(cancellationToken, progress).ConfigureAwait(true);
 
-            await TaskScheduler.Default;
-            _componentModel_doNotAccessDirectly = await this.GetServiceAsync<SComponentModel, IComponentModel>(throwOnFailure: true).ConfigureAwait(false);
-
             await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
 
+            _componentModel_doNotAccessDirectly = await this.GetServiceAsync<SComponentModel, IComponentModel>(throwOnFailure: true).ConfigureAwait(true);
             var shell = (IVsShell7)await GetServiceAsync(typeof(SVsShell)).ConfigureAwait(true);
             var solution = (IVsSolution)await GetServiceAsync(typeof(SVsSolution)).ConfigureAwait(true);
             cancellationToken.ThrowIfCancellationRequested();

From 1e45e16b16014f5d6ab3bc181cebb023831c0da9 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Fri, 17 Dec 2021 08:26:59 -0800
Subject: [PATCH 117/444] Use common pattern

---
 .../Def/Implementation/LanguageService/AbstractPackage`2.cs    | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage`2.cs b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage`2.cs
index 6ea937414ab28..a58c5201f89f6 100644
--- a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage`2.cs
+++ b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage`2.cs
@@ -44,10 +44,11 @@ protected override async Task InitializeAsync(CancellationToken cancellationToke
 
             await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
 
-            _componentModel_doNotAccessDirectly = await this.GetServiceAsync<SComponentModel, IComponentModel>(throwOnFailure: true).ConfigureAwait(true);
+            _componentModel_doNotAccessDirectly = (IComponentModel)await this.GetServiceAsync(typeof(SComponentModel)).ConfigureAwait(true);
             var shell = (IVsShell7)await GetServiceAsync(typeof(SVsShell)).ConfigureAwait(true);
             var solution = (IVsSolution)await GetServiceAsync(typeof(SVsSolution)).ConfigureAwait(true);
             cancellationToken.ThrowIfCancellationRequested();
+            Assumes.Present(_componentModel_doNotAccessDirectly);
             Assumes.Present(shell);
             Assumes.Present(solution);
 

From c9fb58469125a484919129428bd48d954c2c80fc Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Fri, 17 Dec 2021 08:28:11 -0800
Subject: [PATCH 118/444] Kill the this

---
 .../Def/Implementation/LanguageService/AbstractPackage`2.cs     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage`2.cs b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage`2.cs
index a58c5201f89f6..2ee2694d14ba0 100644
--- a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage`2.cs
+++ b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage`2.cs
@@ -44,7 +44,7 @@ protected override async Task InitializeAsync(CancellationToken cancellationToke
 
             await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
 
-            _componentModel_doNotAccessDirectly = (IComponentModel)await this.GetServiceAsync(typeof(SComponentModel)).ConfigureAwait(true);
+            _componentModel_doNotAccessDirectly = (IComponentModel)await GetServiceAsync(typeof(SComponentModel)).ConfigureAwait(true);
             var shell = (IVsShell7)await GetServiceAsync(typeof(SVsShell)).ConfigureAwait(true);
             var solution = (IVsSolution)await GetServiceAsync(typeof(SVsSolution)).ConfigureAwait(true);
             cancellationToken.ThrowIfCancellationRequested();

From bba724ff724a962d58b2f3b9a5c10d88f4dcb66c Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Fri, 17 Dec 2021 08:29:01 -0800
Subject: [PATCH 119/444] Assume present

---
 .../Def/Implementation/LanguageService/AbstractPackage`2.cs     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage`2.cs b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage`2.cs
index 2ee2694d14ba0..d238894e8d293 100644
--- a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage`2.cs
+++ b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage`2.cs
@@ -109,7 +109,7 @@ internal IComponentModel ComponentModel
         {
             get
             {
-                Contract.ThrowIfNull(_componentModel_doNotAccessDirectly);
+                Assumes.Present(_componentModel_doNotAccessDirectly);
                 return _componentModel_doNotAccessDirectly;
             }
         }

From abf38fd7be0155a27712a98f4ef9ef8694300e7a Mon Sep 17 00:00:00 2001
From: "dotnet-maestro[bot]"
 <42748379+dotnet-maestro[bot]@users.noreply.github.com>
Date: Fri, 17 Dec 2021 20:29:32 +0000
Subject: [PATCH 120/444] [main] Update dependencies from dotnet/source-build
 (#58191)

[main] Update dependencies from dotnet/source-build
---
 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 df0bb8154a9ed..85896ac039e85 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -6,9 +6,9 @@
       <Sha>7e80445ee82adbf9a8e6ae601ac5e239d982afaa</Sha>
       <SourceBuild RepoName="xliff-tasks" ManagedOnly="true" />
     </Dependency>
-    <Dependency Name="Microsoft.SourceBuild.Intermediate.source-build" Version="0.1.0-alpha.1.21604.1">
+    <Dependency Name="Microsoft.SourceBuild.Intermediate.source-build" Version="0.1.0-alpha.1.21616.4">
       <Uri>https://github.com/dotnet/source-build</Uri>
-      <Sha>84050eb5821252b0e9753e2a54dbd978ed217bf9</Sha>
+      <Sha>90bdf447e1b97605f109b34243ab8c9f215308e9</Sha>
       <SourceBuild RepoName="source-build" ManagedOnly="true" />
     </Dependency>
   </ProductDependencies>

From 882a2f236954bf3e7be2152b499f6fdf8471c441 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Fri, 17 Dec 2021 12:50:25 -0800
Subject: [PATCH 121/444] Move component model code to common location for all
 AbstractPackages

---
 .../LanguageService/AbstractPackage.cs        | 20 +++++++++++++++++++
 .../LanguageService/AbstractPackage`2.cs      | 12 -----------
 src/VisualStudio/Core/Def/RoslynPackage.cs    | 17 +++-------------
 3 files changed, 23 insertions(+), 26 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage.cs b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage.cs
index 2e697d6d82423..1e257d9034ff3 100644
--- a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage.cs
+++ b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage.cs
@@ -4,7 +4,9 @@
 
 #nullable disable
 
+using System;
 using System.Threading;
+using Microsoft.VisualStudio.ComponentModelHost;
 using Microsoft.VisualStudio.Shell;
 using Task = System.Threading.Tasks.Task;
 
@@ -12,6 +14,24 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.LanguageService
 {
     internal abstract class AbstractPackage : AsyncPackage
     {
+        private IComponentModel _componentModel_doNotAccessDirectly;
+
+        internal IComponentModel ComponentModel
+        {
+            get
+            {
+                Assumes.Present(_componentModel_doNotAccessDirectly);
+                return _componentModel_doNotAccessDirectly;
+            }
+        }
+
+        protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress<ServiceProgressData> progress)
+        {
+            await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+
+            _componentModel_doNotAccessDirectly = (IComponentModel)await GetServiceAsync(typeof(SComponentModel)).ConfigureAwait(true);
+        }
+
         protected async Task LoadComponentsInUIContextOnceSolutionFullyLoadedAsync(CancellationToken cancellationToken)
         {
             // UIContexts can be "zombied" if UIContexts aren't supported because we're in a command line build or in other scenarios.
diff --git a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage`2.cs b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage`2.cs
index d238894e8d293..f7546e274dc53 100644
--- a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage`2.cs
+++ b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage`2.cs
@@ -32,7 +32,6 @@ internal abstract partial class AbstractPackage<TPackage, TLanguageService> : Ab
 
         private PackageInstallerService _packageInstallerService;
         private VisualStudioSymbolSearchService _symbolSearchService;
-        private IComponentModel _componentModel_doNotAccessDirectly;
 
         protected AbstractPackage()
         {
@@ -44,11 +43,9 @@ protected override async Task InitializeAsync(CancellationToken cancellationToke
 
             await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
 
-            _componentModel_doNotAccessDirectly = (IComponentModel)await GetServiceAsync(typeof(SComponentModel)).ConfigureAwait(true);
             var shell = (IVsShell7)await GetServiceAsync(typeof(SVsShell)).ConfigureAwait(true);
             var solution = (IVsSolution)await GetServiceAsync(typeof(SVsSolution)).ConfigureAwait(true);
             cancellationToken.ThrowIfCancellationRequested();
-            Assumes.Present(_componentModel_doNotAccessDirectly);
             Assumes.Present(shell);
             Assumes.Present(solution);
 
@@ -105,15 +102,6 @@ protected override async Task LoadComponentsAsync(CancellationToken cancellation
             _symbolSearchService?.Connect(this.RoslynLanguageName);
         }
 
-        internal IComponentModel ComponentModel
-        {
-            get
-            {
-                Assumes.Present(_componentModel_doNotAccessDirectly);
-                return _componentModel_doNotAccessDirectly;
-            }
-        }
-
         protected abstract void RegisterMiscellaneousFilesWorkspaceInformation(MiscellaneousFilesWorkspace miscellaneousFilesWorkspace);
 
         protected abstract IEnumerable<IVsEditorFactory> CreateEditorFactories();
diff --git a/src/VisualStudio/Core/Def/RoslynPackage.cs b/src/VisualStudio/Core/Def/RoslynPackage.cs
index 5890c9ad8e5d6..5cfd84c835325 100644
--- a/src/VisualStudio/Core/Def/RoslynPackage.cs
+++ b/src/VisualStudio/Core/Def/RoslynPackage.cs
@@ -64,7 +64,6 @@ internal sealed class RoslynPackage : AbstractPackage
         private static RoslynPackage? _lazyInstance;
 
         private VisualStudioWorkspace? _workspace;
-        private IComponentModel? _componentModel;
         private RuleSetEventHandler? _ruleSetEventHandler;
         private ColorSchemeApplier? _colorSchemeApplier;
         private IDisposable? _solutionEventMonitor;
@@ -151,14 +150,12 @@ protected override async Task InitializeAsync(CancellationToken cancellationToke
 
             await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
 
-            _componentModel = (IComponentModel)await GetServiceAsync(typeof(SComponentModel)).ConfigureAwait(true);
             cancellationToken.ThrowIfCancellationRequested();
-            Assumes.Present(_componentModel);
 
             // Ensure the options persisters are loaded since we have to fetch options from the shell
-            LoadOptionPersistersAsync(_componentModel, cancellationToken).Forget();
+            LoadOptionPersistersAsync(this.ComponentModel, cancellationToken).Forget();
 
-            _workspace = _componentModel.GetService<VisualStudioWorkspace>();
+            _workspace = this.ComponentModel.GetService<VisualStudioWorkspace>();
 
             // Fetch the session synchronously on the UI thread; if this doesn't happen before we try using this on
             // the background thread then we will experience hangs like we see in this bug:
@@ -179,7 +176,7 @@ protected override async Task InitializeAsync(CancellationToken cancellationToke
 
             TrackBulkFileOperations();
 
-            var settingsEditorFactory = _componentModel.GetService<SettingsEditorFactory>();
+            var settingsEditorFactory = this.ComponentModel.GetService<SettingsEditorFactory>();
             RegisterEditorFactory(settingsEditorFactory);
         }
 
@@ -304,14 +301,6 @@ private async Task LoadCallstackExplorerMenusAsync(CancellationToken cancellatio
             StackTraceExplorerCommandHandler.Initialize(menuCommandService, this);
         }
 
-        internal IComponentModel ComponentModel
-        {
-            get
-            {
-                return _componentModel ?? throw new InvalidOperationException($"Cannot use {nameof(RoslynPackage)}.{nameof(ComponentModel)} prior to initialization.");
-            }
-        }
-
         protected override void Dispose(bool disposing)
         {
             DisposeVisualStudioServices();

From 35b0a04d1d99da97886986f765e01fb7e53bcc5b Mon Sep 17 00:00:00 2001
From: akhera99 <ankitakhera@microsoft.com>
Date: Fri, 17 Dec 2021 14:05:07 -0800
Subject: [PATCH 122/444] use the end of the span instead of the start to
 determine line position

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

diff --git a/src/EditorFeatures/Core.Wpf/InlineDiagnostics/InlineDiagnosticsAdornmentManager.cs b/src/EditorFeatures/Core.Wpf/InlineDiagnostics/InlineDiagnosticsAdornmentManager.cs
index 97ce478c2c1e3..929e599b576bb 100644
--- a/src/EditorFeatures/Core.Wpf/InlineDiagnostics/InlineDiagnosticsAdornmentManager.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineDiagnostics/InlineDiagnosticsAdornmentManager.cs
@@ -189,7 +189,7 @@ protected override void AddAdornmentsToAdornmentLayer_CallOnlyOnUIThread(Normali
                 }
 
                 // Need to get the SnapshotPoint to be able to get the IWpfTextViewLine
-                var point = tagMappingSpan.Span.Start.GetPoint(TextView.TextSnapshot, PositionAffinity.Predecessor);
+                var point = tagMappingSpan.Span.End.GetPoint(TextView.TextSnapshot, PositionAffinity.Predecessor);
                 if (point == null)
                 {
                     continue;

From e17723589da390b39f682d72bbbb073cc62b77f5 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrus.najmabadi@gmail.com>
Date: Fri, 17 Dec 2021 19:10:05 -0500
Subject: [PATCH 123/444] Update
 src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage.cs

Co-authored-by: Sam Harwell <sam@tunnelvisionlabs.com>
---
 .../Core/Def/Implementation/LanguageService/AbstractPackage.cs   | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage.cs b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage.cs
index 1e257d9034ff3..5e49c70e5a5e9 100644
--- a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage.cs
+++ b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage.cs
@@ -30,6 +30,7 @@ protected override async Task InitializeAsync(CancellationToken cancellationToke
             await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
 
             _componentModel_doNotAccessDirectly = (IComponentModel)await GetServiceAsync(typeof(SComponentModel)).ConfigureAwait(true);
+            Assumes.Present(_componentModel_doNotAccessDirectly);
         }
 
         protected async Task LoadComponentsInUIContextOnceSolutionFullyLoadedAsync(CancellationToken cancellationToken)

From e7d78b23f24ca1c4f3f2f19311ba5eff9711c201 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Fri, 17 Dec 2021 21:23:36 -0800
Subject: [PATCH 124/444] call to base

---
 .../Core/Def/Implementation/LanguageService/AbstractPackage.cs   | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage.cs b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage.cs
index 1e257d9034ff3..6eef91308e7ee 100644
--- a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage.cs
+++ b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage.cs
@@ -27,6 +27,7 @@ internal IComponentModel ComponentModel
 
         protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress<ServiceProgressData> progress)
         {
+            await base.InitializeAsync(cancellationToken, progress).ConfigureAwait(true);
             await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
 
             _componentModel_doNotAccessDirectly = (IComponentModel)await GetServiceAsync(typeof(SComponentModel)).ConfigureAwait(true);

From 31d442ce427c197b3117f8f5e41cf6f0ae525423 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Fri, 17 Dec 2021 21:24:12 -0800
Subject: [PATCH 125/444] NRT'

---
 .../Def/Implementation/LanguageService/AbstractPackage.cs     | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage.cs b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage.cs
index 35bae587be256..654e8721e475e 100644
--- a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage.cs
+++ b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractPackage.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System;
 using System.Threading;
 using Microsoft.VisualStudio.ComponentModelHost;
@@ -14,7 +12,7 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.LanguageService
 {
     internal abstract class AbstractPackage : AsyncPackage
     {
-        private IComponentModel _componentModel_doNotAccessDirectly;
+        private IComponentModel? _componentModel_doNotAccessDirectly;
 
         internal IComponentModel ComponentModel
         {

From 8df82f3f44f27ab55ed3ba76d3d4b05ab6f0297d Mon Sep 17 00:00:00 2001
From: Manish Vasani <mavasani@microsoft.com>
Date: Fri, 17 Dec 2021 23:40:30 -0800
Subject: [PATCH 126/444] Fix leak in _hostAnalyzerStateMap

Fixes [AB#1449967](https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1449967)

#57648 fixed a race condition in computing the host analyzer references, but introduced a leak in _hostAnalyzerStateMap, wherein each new solution opened ends up creating a new entry in this map, even though the underlying set of host analyzer references doesn't change. This is due to the fact that each new SolutionState instance creates a new instance of HostDiagnosticAnalyzers, whose constructor creates a new map from analyzer references ID to the analyzer reference. This map is used as part of the key for _hostAnalyzerStateMap, leading to the leak.

This change fixes the leak by using the underlying list of host analyzer references as part of the key for _hostAnalyzerStateMap, which is reference equals across all solution instances opened in the VS session. Verified manually that after this fix, repeatedly opening and closing a solution in VS no longer leads to unbounded growth of _hostAnalyzerStateMap.
---
 .../Test2/Diagnostics/DiagnosticServiceTests.vb           | 3 +--
 ...agnosticIncrementalAnalyzer.StateManager.HostStates.cs | 6 +++---
 .../DiagnosticIncrementalAnalyzer.StateManager.cs         | 4 ++--
 .../Core/Portable/Diagnostics/HostDiagnosticAnalyzers.cs  | 8 ++++----
 4 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb b/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb
index 91c3d346c47ec..5a47f2cc52cb4 100644
--- a/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb
+++ b/src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb
@@ -149,8 +149,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.Diagnostics.UnitTests
                 Assert.Equal(workspaceDiagnosticAnalyzer.DiagDescriptor.Id, descriptors(0).Id)
 
                 ' Add an existing workspace analyzer to the project, ensure no duplicate diagnostics.
-                Dim duplicateProjectAnalyzersReference = hostAnalyzers.GetHostAnalyzerReferencesMap().First().Value
-                project = project.WithAnalyzerReferences({duplicateProjectAnalyzersReference})
+                project = project.WithAnalyzerReferences(hostAnalyzers.HostAnalyzerReferences)
 
                 ' Verify duplicate descriptors or diagnostics.
                 descriptorsMap = hostAnalyzers.GetDiagnosticDescriptorsPerReference(diagnosticService.AnalyzerInfoCache, project)
diff --git a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.HostStates.cs b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.HostStates.cs
index af1fe1edd92ab..fe8be59046e32 100644
--- a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.HostStates.cs
+++ b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.HostStates.cs
@@ -16,10 +16,10 @@ private partial class StateManager
         {
             public IEnumerable<StateSet> GetAllHostStateSets()
             {
-                var analyzerReferencesMap = _workspace.CurrentSolution.State.Analyzers.GetHostAnalyzerReferencesMap();
+                var analyzerReferences = _workspace.CurrentSolution.State.Analyzers.HostAnalyzerReferences;
                 foreach (var (key, value) in _hostAnalyzerStateMap)
                 {
-                    if (key.AnalyzerReferences == analyzerReferencesMap)
+                    if (key.AnalyzerReferences == analyzerReferences)
                     {
                         foreach (var stateSet in value.OrderedStateSets)
                         {
@@ -31,7 +31,7 @@ public IEnumerable<StateSet> GetAllHostStateSets()
 
             private HostAnalyzerStateSets GetOrCreateHostStateSets(Project project, ProjectAnalyzerStateSets projectStateSets)
             {
-                var key = new HostAnalyzerStateSetKey(project.Language, project.Solution.State.Analyzers.GetHostAnalyzerReferencesMap());
+                var key = new HostAnalyzerStateSetKey(project.Language, project.Solution.State.Analyzers.HostAnalyzerReferences);
                 var hostStateSets = ImmutableInterlocked.GetOrAdd(ref _hostAnalyzerStateMap, key, CreateLanguageSpecificAnalyzerMap, project.Solution.State.Analyzers);
                 return hostStateSets.WithExcludedAnalyzers(projectStateSets.SkippedAnalyzersInfo.SkippedAnalyzers);
 
diff --git a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.cs b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.cs
index 1cd6f957c6a29..8cd11d6a45737 100644
--- a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.cs
+++ b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.cs
@@ -314,14 +314,14 @@ private void VerifyProjectDiagnosticStates(IEnumerable<StateSet> stateSets)
 
             private readonly struct HostAnalyzerStateSetKey : IEquatable<HostAnalyzerStateSetKey>
             {
-                public HostAnalyzerStateSetKey(string language, ImmutableDictionary<object, AnalyzerReference> analyzerReferences)
+                public HostAnalyzerStateSetKey(string language, IReadOnlyList<AnalyzerReference> analyzerReferences)
                 {
                     Language = language;
                     AnalyzerReferences = analyzerReferences;
                 }
 
                 public string Language { get; }
-                public ImmutableDictionary<object, AnalyzerReference> AnalyzerReferences { get; }
+                public IReadOnlyList<AnalyzerReference> AnalyzerReferences { get; }
 
                 public bool Equals(HostAnalyzerStateSetKey other)
                     => Language == other.Language && AnalyzerReferences == other.AnalyzerReferences;
diff --git a/src/Workspaces/Core/Portable/Diagnostics/HostDiagnosticAnalyzers.cs b/src/Workspaces/Core/Portable/Diagnostics/HostDiagnosticAnalyzers.cs
index ea6e57536778b..70d8c63279ca1 100644
--- a/src/Workspaces/Core/Portable/Diagnostics/HostDiagnosticAnalyzers.cs
+++ b/src/Workspaces/Core/Portable/Diagnostics/HostDiagnosticAnalyzers.cs
@@ -53,8 +53,9 @@ internal sealed class HostDiagnosticAnalyzers
         /// </remarks>
         private readonly ConditionalWeakTable<IReadOnlyList<AnalyzerReference>, StrongBox<ImmutableDictionary<string, SkippedHostAnalyzersInfo>>> _skippedHostAnalyzers;
 
-        internal HostDiagnosticAnalyzers(IEnumerable<AnalyzerReference> hostAnalyzerReferences)
+        internal HostDiagnosticAnalyzers(IReadOnlyList<AnalyzerReference> hostAnalyzerReferences)
         {
+            HostAnalyzerReferences = hostAnalyzerReferences;
             _hostAnalyzerReferencesMap = CreateAnalyzerReferencesMap(hostAnalyzerReferences);
             _hostDiagnosticAnalyzersPerLanguageMap = new ConcurrentDictionary<string, ImmutableDictionary<object, ImmutableArray<DiagnosticAnalyzer>>>(concurrencyLevel: 2, capacity: 2);
             _lazyHostDiagnosticAnalyzersPerReferenceMap = new Lazy<ImmutableDictionary<object, ImmutableArray<DiagnosticAnalyzer>>>(() => CreateDiagnosticAnalyzersPerReferenceMap(_hostAnalyzerReferencesMap), isThreadSafe: true);
@@ -64,10 +65,9 @@ internal HostDiagnosticAnalyzers(IEnumerable<AnalyzerReference> hostAnalyzerRefe
         }
 
         /// <summary>
-        /// It returns a map with <see cref="AnalyzerReference.Id"/> as key and <see cref="AnalyzerReference"/> as value
+        /// List of host <see cref="AnalyzerReference"/>s
         /// </summary>
-        public ImmutableDictionary<object, AnalyzerReference> GetHostAnalyzerReferencesMap()
-            => _hostAnalyzerReferencesMap;
+        public IReadOnlyList<AnalyzerReference> HostAnalyzerReferences { get; }
 
         /// <summary>
         /// Get <see cref="AnalyzerReference"/> identity and <see cref="DiagnosticAnalyzer"/>s map for given <paramref name="language"/>

From 55c4ba96fc6be78d6a946c465940ac8601452840 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Dec 2021 08:07:47 -0800
Subject: [PATCH 127/444] Remove unnecessary weakref valuessources in
 compilation tracker.

---
 ...pilationTracker.CompilationTrackerState.cs | 28 ++++++-------------
 .../SolutionState.CompilationTracker.cs       | 10 +++----
 .../WorkspaceConfigurationOptions.cs          | 10 +------
 3 files changed, 15 insertions(+), 33 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs
index 7da382f9dc134..53203f228348c 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs
@@ -167,18 +167,9 @@ public static CompilationTrackerState Create(
                     // DeclarationState now. We'll pass false for generatedDocumentsAreFinal because this is being called
                     // if our referenced projects are changing, so we'll have to rerun to consume changes.
                     return intermediateProjects.Length == 0
-                        ? new AllSyntaxTreesParsedState(solutionServices, compilation, generatorInfo.WithDocumentsAreFinal(false))
+                        ? new AllSyntaxTreesParsedState(compilation, generatorInfo.WithDocumentsAreFinal(false))
                         : new InProgressState(compilation, generatorInfo, compilationWithGeneratedDocuments, intermediateProjects);
                 }
-
-                public static ValueSource<Optional<Compilation>> CreateValueSource(
-                    Compilation compilation,
-                    SolutionServices services)
-                {
-                    return services.SupportsCachingRecoverableObjects && !services.Workspace.Options.GetOption(WorkspaceConfigurationOptions.DisableCompilationTrackerWeakCompilationReferences)
-                        ? new WeakValueSource<Compilation>(compilation)
-                        : new ConstantValueSource<Optional<Compilation>>(compilation);
-                }
             }
 
             /// <summary>
@@ -236,10 +227,9 @@ public InProgressState(
             private sealed class AllSyntaxTreesParsedState : CompilationTrackerState
             {
                 public AllSyntaxTreesParsedState(
-                    SolutionServices solutionServices,
                     Compilation declarationCompilation,
                     CompilationTrackerGeneratorInfo generatorInfo)
-                    : base(CreateValueSource(declarationCompilation, solutionServices),
+                    : base(new ConstantValueSource<Optional<Compilation>>(declarationCompilation),
                            generatorInfo)
                 {
                 }
@@ -277,24 +267,24 @@ private sealed class FinalState : CompilationTrackerState
                 public override ValueSource<Optional<Compilation>> FinalCompilationWithGeneratedDocuments { get; }
 
                 private FinalState(
-                    ValueSource<Optional<Compilation>> finalCompilationSource,
-                    ValueSource<Optional<Compilation>> compilationWithoutGeneratedFilesSource,
+                    Compilation finalCompilationSource,
+                    Compilation compilationWithoutGeneratedFilesSource,
                     Compilation compilationWithoutGeneratedFiles,
                     bool hasSuccessfullyLoaded,
                     CompilationTrackerGeneratorInfo generatorInfo,
                     UnrootedSymbolSet unrootedSymbolSet)
-                    : base(compilationWithoutGeneratedFilesSource,
+                    : base(new ConstantValueSource<Optional<Compilation>>(compilationWithoutGeneratedFilesSource),
                           generatorInfo.WithDocumentsAreFinal(true)) // when we're in a final state, we've ran generators and should not run again
                 {
                     HasSuccessfullyLoaded = hasSuccessfullyLoaded;
-                    FinalCompilationWithGeneratedDocuments = finalCompilationSource;
+                    FinalCompilationWithGeneratedDocuments = new ConstantValueSource<Optional<Compilation>>(finalCompilationSource);
                     UnrootedSymbolSet = unrootedSymbolSet;
 
                     if (this.GeneratorInfo.Documents.IsEmpty)
                     {
                         // In this case, the finalCompilationSource and compilationWithoutGeneratedFilesSource should point to the
                         // same Compilation, which should be compilationWithoutGeneratedFiles itself
-                        Debug.Assert(finalCompilationSource.TryGetValue(out var finalCompilationVal));
+                        Debug.Assert(FinalCompilationWithGeneratedDocuments.TryGetValue(out var finalCompilationVal));
                         Debug.Assert(object.ReferenceEquals(finalCompilationVal.Value, compilationWithoutGeneratedFiles));
                     }
                 }
@@ -303,8 +293,8 @@ private FinalState(
                 /// <param name="projectId">Not held onto</param>
                 /// <param name="metadataReferenceToProjectId">Not held onto</param>
                 public static FinalState Create(
-                    ValueSource<Optional<Compilation>> finalCompilationSource,
-                    ValueSource<Optional<Compilation>> compilationWithoutGeneratedFilesSource,
+                    Compilation finalCompilationSource,
+                    Compilation compilationWithoutGeneratedFilesSource,
                     Compilation compilationWithoutGeneratedFiles,
                     bool hasSuccessfullyLoaded,
                     CompilationTrackerGeneratorInfo generatorInfo,
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs
index 2597b6e1883af..e6306074b3bdc 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs
@@ -205,8 +205,8 @@ public ICompilationTracker FreezePartialStateWithTree(SolutionState solution, Do
                 // have the compilation immediately disappear.  So we force it to stay around with a ConstantValueSource.
                 // As a policy, all partial-state projects are said to have incomplete references, since the state has no guarantees.
                 var finalState = FinalState.Create(
-                    finalCompilationSource: new ConstantValueSource<Optional<Compilation>>(compilationPair.CompilationWithGeneratedDocuments),
-                    compilationWithoutGeneratedFilesSource: new ConstantValueSource<Optional<Compilation>>(compilationPair.CompilationWithoutGeneratedDocuments),
+                    finalCompilationSource: compilationPair.CompilationWithGeneratedDocuments,
+                    compilationWithoutGeneratedFilesSource: compilationPair.CompilationWithoutGeneratedDocuments,
                     compilationWithoutGeneratedFiles: compilationPair.CompilationWithoutGeneratedDocuments,
                     hasSuccessfullyLoaded: false,
                     generatorInfo,
@@ -581,7 +581,7 @@ private async Task<Compilation> BuildDeclarationCompilationFromScratchAsync(
                     }
 
                     compilation = compilation.AddSyntaxTrees(trees);
-                    WriteState(new AllSyntaxTreesParsedState(solutionServices, compilation, generatorInfo), solutionServices);
+                    WriteState(new AllSyntaxTreesParsedState(compilation, generatorInfo), solutionServices);
                     return compilation;
                 }
                 catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
@@ -922,8 +922,8 @@ private async Task<CompilationInfo> FinalizeCompilationAsync(
                     }
 
                     var finalState = FinalState.Create(
-                        CompilationTrackerState.CreateValueSource(compilationWithGenerators, solution.Services),
-                        CompilationTrackerState.CreateValueSource(compilationWithoutGenerators, solution.Services),
+                        compilationWithGenerators,
+                        compilationWithoutGenerators,
                         compilationWithoutGenerators,
                         hasSuccessfullyLoaded,
                         generatorInfo,
diff --git a/src/Workspaces/Core/Portable/Workspace/WorkspaceConfigurationOptions.cs b/src/Workspaces/Core/Portable/Workspace/WorkspaceConfigurationOptions.cs
index a865ce4a4c85d..d70cef1949bfb 100644
--- a/src/Workspaces/Core/Portable/Workspace/WorkspaceConfigurationOptions.cs
+++ b/src/Workspaces/Core/Portable/Workspace/WorkspaceConfigurationOptions.cs
@@ -26,17 +26,9 @@ internal class WorkspaceConfigurationOptions : IOptionProvider
             nameof(WorkspaceConfigurationOptions), nameof(DisableProjectCacheService), defaultValue: false,
             new FeatureFlagStorageLocation("Roslyn.DisableProjectCacheService"));
 
-        /// <summary>
-        /// Disables holding onto the assembly references for runtime (not user/nuget/etc.) dlls weakly.
-        /// </summary>
-        public static readonly Option<bool> DisableCompilationTrackerWeakCompilationReferences = new(
-            nameof(WorkspaceConfigurationOptions), nameof(DisableCompilationTrackerWeakCompilationReferences), defaultValue: false,
-            new FeatureFlagStorageLocation("Roslyn.DisableCompilationTrackerWeakCompilationReferences"));
-
         ImmutableArray<IOption> IOptionProvider.Options { get; } = ImmutableArray.Create<IOption>(
             DisableRecoverableTrees,
-            DisableProjectCacheService,
-            DisableCompilationTrackerWeakCompilationReferences);
+            DisableProjectCacheService);
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]

From 36beb71827cb58769525e1aacda35adc8966c39e Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Dec 2021 08:12:50 -0800
Subject: [PATCH 128/444] REmove value-source as everything in constant

---
 ...pilationTracker.CompilationTrackerState.cs | 24 +++++++------------
 .../SolutionState.CompilationTracker.cs       | 20 +++++++---------
 2 files changed, 18 insertions(+), 26 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs
index 53203f228348c..ea113b4c82ab5 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs
@@ -109,12 +109,10 @@ private abstract class CompilationTrackerState
                         documentsAreFinal: false));
 
                 /// <summary>
-                /// The best compilation that is available that source generators have not ran on. May be an in-progress,
-                /// full declaration,  a final compilation, or <see langword="null"/>.
-                /// The value is an <see cref="Optional{Compilation}"/> to represent the
-                /// possibility of the compilation already having been garabage collected.
+                /// The best compilation that is available that source generators have not ran on. May be an
+                /// in-progress, full declaration,  a final compilation, or <see langword="null"/>.
                 /// </summary>
-                public ValueSource<Optional<Compilation>>? CompilationWithoutGeneratedDocuments { get; }
+                public Compilation? CompilationWithoutGeneratedDocuments { get; }
 
                 public CompilationTrackerGeneratorInfo GeneratorInfo { get; }
 
@@ -132,7 +130,7 @@ private abstract class CompilationTrackerState
                 public virtual ValueSource<Optional<Compilation>>? FinalCompilationWithGeneratedDocuments => null;
 
                 protected CompilationTrackerState(
-                    ValueSource<Optional<Compilation>>? compilationWithoutGeneratedDocuments,
+                    Compilation? compilationWithoutGeneratedDocuments,
                     CompilationTrackerGeneratorInfo generatorInfo)
                 {
                     CompilationWithoutGeneratedDocuments = compilationWithoutGeneratedDocuments;
@@ -155,7 +153,6 @@ protected CompilationTrackerState(
                 }
 
                 public static CompilationTrackerState Create(
-                    SolutionServices solutionServices,
                     Compilation compilation,
                     CompilationTrackerGeneratorInfo generatorInfo,
                     Compilation? compilationWithGeneratedDocuments,
@@ -209,7 +206,7 @@ public InProgressState(
                     CompilationTrackerGeneratorInfo generatorInfo,
                     Compilation? compilationWithGeneratedDocuments,
                     ImmutableArray<(ProjectState state, CompilationAndGeneratorDriverTranslationAction action)> intermediateProjects)
-                    : base(compilationWithoutGeneratedDocuments: new ConstantValueSource<Optional<Compilation>>(inProgressCompilation),
+                    : base(compilationWithoutGeneratedDocuments: inProgressCompilation,
                            generatorInfo.WithDocumentsAreFinal(false)) // since we have a set of transformations to make, we'll always have to run generators again
                 {
                     Contract.ThrowIfTrue(intermediateProjects.IsDefault);
@@ -226,11 +223,8 @@ public InProgressState(
             /// </summary>
             private sealed class AllSyntaxTreesParsedState : CompilationTrackerState
             {
-                public AllSyntaxTreesParsedState(
-                    Compilation declarationCompilation,
-                    CompilationTrackerGeneratorInfo generatorInfo)
-                    : base(new ConstantValueSource<Optional<Compilation>>(declarationCompilation),
-                           generatorInfo)
+                public AllSyntaxTreesParsedState(Compilation declarationCompilation, CompilationTrackerGeneratorInfo generatorInfo)
+                    : base(declarationCompilation, generatorInfo)
                 {
                 }
             }
@@ -273,8 +267,8 @@ private FinalState(
                     bool hasSuccessfullyLoaded,
                     CompilationTrackerGeneratorInfo generatorInfo,
                     UnrootedSymbolSet unrootedSymbolSet)
-                    : base(new ConstantValueSource<Optional<Compilation>>(compilationWithoutGeneratedFilesSource),
-                          generatorInfo.WithDocumentsAreFinal(true)) // when we're in a final state, we've ran generators and should not run again
+                    : base(compilationWithoutGeneratedFilesSource,
+                           generatorInfo.WithDocumentsAreFinal(true)) // when we're in a final state, we've ran generators and should not run again
                 {
                     HasSuccessfullyLoaded = hasSuccessfullyLoaded;
                     FinalCompilationWithGeneratedDocuments = new ConstantValueSource<Optional<Compilation>>(finalCompilationSource);
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs
index e6306074b3bdc..1c2460399a0ae 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs
@@ -76,7 +76,7 @@ private void WriteState(CompilationTrackerState state, SolutionServices solution
                 {
                     // Allow the cache service to create a strong reference to the compilation. We'll get the "furthest along" compilation we have
                     // and hold onto that.
-                    var compilationToCache = state.FinalCompilationWithGeneratedDocuments?.GetValueOrNull() ?? state.CompilationWithoutGeneratedDocuments?.GetValueOrNull();
+                    var compilationToCache = state.FinalCompilationWithGeneratedDocuments?.GetValueOrNull() ?? state.CompilationWithoutGeneratedDocuments;
                     solutionServices.CacheService.CacheObjectIfCachingEnabledForKey(ProjectState.Id, state, compilationToCache);
                 }
 
@@ -122,7 +122,7 @@ public ICompilationTracker Fork(
             {
                 var state = ReadState();
 
-                var baseCompilation = state.CompilationWithoutGeneratedDocuments?.GetValueOrNull(cancellationToken);
+                var baseCompilation = state.CompilationWithoutGeneratedDocuments;
                 if (baseCompilation != null)
                 {
                     var intermediateProjects = state is InProgressState inProgressState
@@ -154,7 +154,7 @@ public ICompilationTracker Fork(
                     }
 
                     var newState = CompilationTrackerState.Create(
-                        solutionServices, baseCompilation, state.GeneratorInfo, state.FinalCompilationWithGeneratedDocuments?.GetValueOrNull(cancellationToken), intermediateProjects);
+                        baseCompilation, state.GeneratorInfo, state.FinalCompilationWithGeneratedDocuments?.GetValueOrNull(cancellationToken), intermediateProjects);
 
                     return new CompilationTracker(newProject, newState, this.SkeletonReferenceCache.Clone());
                 }
@@ -236,7 +236,7 @@ private void GetPartialCompilationState(
                 CancellationToken cancellationToken)
             {
                 var state = ReadState();
-                var compilationWithoutGeneratedDocuments = state.CompilationWithoutGeneratedDocuments?.GetValueOrNull(cancellationToken);
+                var compilationWithoutGeneratedDocuments = state.CompilationWithoutGeneratedDocuments;
 
                 // check whether we can bail out quickly for typing case
                 var inProgressState = state as InProgressState;
@@ -414,7 +414,7 @@ private async Task<Compilation> GetOrBuildDeclarationCompilationAsync(SolutionSe
                             return compilation;
                         }
 
-                        compilation = state.CompilationWithoutGeneratedDocuments?.GetValueOrNull(cancellationToken);
+                        compilation = state.CompilationWithoutGeneratedDocuments;
                         if (compilation == null)
                         {
                             // We've got nothing.  Build it from scratch :(
@@ -506,7 +506,7 @@ private async Task<CompilationInfo> BuildCompilationInfoAsync(
                     return new CompilationInfo(compilation, state.HasSuccessfullyLoaded.Value, state.GeneratorInfo.Documents);
                 }
 
-                compilation = state.CompilationWithoutGeneratedDocuments?.GetValueOrNull(cancellationToken);
+                compilation = state.CompilationWithoutGeneratedDocuments;
 
                 if (compilation == null)
                 {
@@ -682,7 +682,7 @@ private async Task<CompilationInfo> BuildFinalStateFromInProgressStateAsync(
                         intermediateProjects = intermediateProjects.RemoveAt(0);
 
                         this.WriteState(CompilationTrackerState.Create(
-                            solutionServices, compilationWithoutGenerators, state.GeneratorInfo.WithDriver(generatorDriver), compilationWithGenerators, intermediateProjects), solutionServices);
+                            compilationWithoutGenerators, state.GeneratorInfo.WithDriver(generatorDriver), compilationWithGenerators, intermediateProjects), solutionServices);
                     }
 
                     return (compilationWithoutGenerators, compilationWithGenerators, generatorDriver);
@@ -989,13 +989,11 @@ private async Task<CompilationInfo> FinalizeCompilationAsync(
                 var state = ReadState();
 
                 // get compilation in any state it happens to be in right now.
-                if (state.CompilationWithoutGeneratedDocuments != null &&
-                    state.CompilationWithoutGeneratedDocuments.TryGetValue(out var compilationOpt) &&
-                    compilationOpt.HasValue &&
+                if (state.CompilationWithoutGeneratedDocuments is { } compilationOpt &&
                     ProjectState.LanguageServices == fromProject.LanguageServices)
                 {
                     // if we have a compilation and its the correct language, use a simple compilation reference
-                    return compilationOpt.Value.ToMetadataReference(projectReference.Aliases, projectReference.EmbedInteropTypes);
+                    return compilationOpt.ToMetadataReference(projectReference.Aliases, projectReference.EmbedInteropTypes);
                 }
 
                 return null;

From f62f5740201232cf60b456a27181d1180bc54331 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Wed, 15 Dec 2021 17:44:42 -0800
Subject: [PATCH 129/444] Remove unnecessary assertion that CancellationSeries
 is disposed

This type functions correctly whether or not it is explicitly disposed.
---
 .../Portable/Utilities/CancellationSeries.cs  | 22 -------------------
 1 file changed, 22 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Utilities/CancellationSeries.cs b/src/Workspaces/Core/Portable/Utilities/CancellationSeries.cs
index 0dd0e7e17714c..f5072e2033b34 100644
--- a/src/Workspaces/Core/Portable/Utilities/CancellationSeries.cs
+++ b/src/Workspaces/Core/Portable/Utilities/CancellationSeries.cs
@@ -9,9 +9,6 @@
 // reference implementation.
 
 using System;
-#if DEBUG
-using System.Diagnostics;
-#endif
 using System.Threading;
 
 namespace Roslyn.Utilities
@@ -42,22 +39,7 @@ public CancellationSeries(CancellationToken token = default)
             _cts.Cancel();
 
             _superToken = token;
-
-#if DEBUG
-            _ctorStack = new StackTrace();
-#endif
-        }
-
-#if DEBUG
-        private readonly StackTrace _ctorStack;
-
-        ~CancellationSeries()
-        {
-            Contract.ThrowIfFalse(
-                Environment.HasShutdownStarted || _cts == null,
-                $"Instance of CancellationSeries not disposed before being finalized{Environment.NewLine}Stack at construction:{Environment.NewLine}{_ctorStack}");
         }
-#endif
 
         /// <summary>
         /// Determines if the cancellation series has an active token which has not been cancelled.
@@ -131,10 +113,6 @@ public CancellationToken CreateNext(CancellationToken token = default)
 
         public void Dispose()
         {
-#if DEBUG
-            GC.SuppressFinalize(this);
-#endif
-
             var source = Interlocked.Exchange(ref _cts, null);
 
             if (source == null)

From 999ff1ea085adde8dbade01d98ca351b4f2703e9 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Dec 2021 08:25:33 -0800
Subject: [PATCH 130/444] Inline another value always known to be a constnat
 value source.

---
 ...pilationTracker.CompilationTrackerState.cs | 22 +++++-----
 .../SolutionState.CompilationTracker.cs       | 44 ++++++++-----------
 2 files changed, 28 insertions(+), 38 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs
index ea113b4c82ab5..4f1747a68f027 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs
@@ -124,10 +124,8 @@ private abstract class CompilationTrackerState
 
                 /// <summary>
                 /// The final compilation is potentially available, otherwise <see langword="null"/>.
-                /// The value is an <see cref="Optional{Compilation}"/> to represent the
-                /// possibility of the compilation already having been garabage collected.
                 /// </summary>
-                public virtual ValueSource<Optional<Compilation>>? FinalCompilationWithGeneratedDocuments => null;
+                public virtual Compilation? FinalCompilationWithGeneratedDocuments => null;
 
                 protected CompilationTrackerState(
                     Compilation? compilationWithoutGeneratedDocuments,
@@ -252,13 +250,14 @@ private sealed class FinalState : CompilationTrackerState
                 public readonly UnrootedSymbolSet UnrootedSymbolSet;
 
                 /// <summary>
-                /// The final compilation, with all references and source generators run. This is distinct from
-                /// <see cref="Compilation"/>, which in the <see cref="FinalState"/> case will be the compilation
-                /// before any source generators were ran. This ensures that a later invocation of the source generators
-                /// consumes <see cref="Compilation"/> which will avoid generators being ran a second time on a compilation that
-                /// already contains the output of other generators. If source generators are not active, this is equal to <see cref="Compilation"/>.
+                /// The final compilation, with all references and source generators run. This is distinct from <see
+                /// cref="Compilation"/>, which in the <see cref="FinalState"/> case will be the compilation before any
+                /// source generators were ran. This ensures that a later invocation of the source generators consumes
+                /// <see cref="Compilation"/> which will avoid generators being ran a second time on a compilation that
+                /// already contains the output of other generators. If source generators are not active, this is equal
+                /// to <see cref="Compilation"/>.
                 /// </summary>
-                public override ValueSource<Optional<Compilation>> FinalCompilationWithGeneratedDocuments { get; }
+                public override Compilation FinalCompilationWithGeneratedDocuments { get; }
 
                 private FinalState(
                     Compilation finalCompilationSource,
@@ -271,15 +270,14 @@ private FinalState(
                            generatorInfo.WithDocumentsAreFinal(true)) // when we're in a final state, we've ran generators and should not run again
                 {
                     HasSuccessfullyLoaded = hasSuccessfullyLoaded;
-                    FinalCompilationWithGeneratedDocuments = new ConstantValueSource<Optional<Compilation>>(finalCompilationSource);
+                    FinalCompilationWithGeneratedDocuments = finalCompilationSource;
                     UnrootedSymbolSet = unrootedSymbolSet;
 
                     if (this.GeneratorInfo.Documents.IsEmpty)
                     {
                         // In this case, the finalCompilationSource and compilationWithoutGeneratedFilesSource should point to the
                         // same Compilation, which should be compilationWithoutGeneratedFiles itself
-                        Debug.Assert(FinalCompilationWithGeneratedDocuments.TryGetValue(out var finalCompilationVal));
-                        Debug.Assert(object.ReferenceEquals(finalCompilationVal.Value, compilationWithoutGeneratedFiles));
+                        Debug.Assert(object.ReferenceEquals(finalCompilationSource, compilationWithoutGeneratedFiles));
                     }
                 }
 
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs
index 1c2460399a0ae..a6ea2170d53f9 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs
@@ -76,7 +76,7 @@ private void WriteState(CompilationTrackerState state, SolutionServices solution
                 {
                     // Allow the cache service to create a strong reference to the compilation. We'll get the "furthest along" compilation we have
                     // and hold onto that.
-                    var compilationToCache = state.FinalCompilationWithGeneratedDocuments?.GetValueOrNull() ?? state.CompilationWithoutGeneratedDocuments;
+                    var compilationToCache = state.FinalCompilationWithGeneratedDocuments ?? state.CompilationWithoutGeneratedDocuments;
                     solutionServices.CacheService.CacheObjectIfCachingEnabledForKey(ProjectState.Id, state, compilationToCache);
                 }
 
@@ -154,7 +154,7 @@ public ICompilationTracker Fork(
                     }
 
                     var newState = CompilationTrackerState.Create(
-                        baseCompilation, state.GeneratorInfo, state.FinalCompilationWithGeneratedDocuments?.GetValueOrNull(cancellationToken), intermediateProjects);
+                        baseCompilation, state.GeneratorInfo, state.FinalCompilationWithGeneratedDocuments, intermediateProjects);
 
                     return new CompilationTracker(newProject, newState, this.SkeletonReferenceCache.Clone());
                 }
@@ -269,20 +269,18 @@ private void GetPartialCompilationState(
                 // if we already have a final compilation we are done.
                 if (compilationWithoutGeneratedDocuments != null && state is FinalState finalState)
                 {
-                    var finalCompilation = finalState.FinalCompilationWithGeneratedDocuments.GetValueOrNull(cancellationToken);
+                    var finalCompilation = finalState.FinalCompilationWithGeneratedDocuments;
+                    Contract.ThrowIfNull(finalCompilation, "We have a FinalState, so we must have a non-null final compilation");
 
-                    if (finalCompilation != null)
-                    {
-                        compilations = new CompilationPair(compilationWithoutGeneratedDocuments, finalCompilation);
-
-                        // This should hopefully be safe to return as null.  Because we already reached the 'FinalState'
-                        // before, we should have already recorded the assembly symbols for it.  So not recording them
-                        // again is likely ok (as long as compilations continue to return the same IAssemblySymbols for
-                        // the same references across source edits).
-                        metadataReferenceToProjectId = null;
-                        SolutionLogger.UseExistingFullProjectState();
-                        return;
-                    }
+                    compilations = new CompilationPair(compilationWithoutGeneratedDocuments, finalCompilation);
+
+                    // This should hopefully be safe to return as null.  Because we already reached the 'FinalState'
+                    // before, we should have already recorded the assembly symbols for it.  So not recording them
+                    // again is likely ok (as long as compilations continue to return the same IAssemblySymbols for
+                    // the same references across source edits).
+                    metadataReferenceToProjectId = null;
+                    SolutionLogger.UseExistingFullProjectState();
+                    return;
                 }
 
                 // 1) if we have an in-progress compilation use it.  
@@ -365,14 +363,8 @@ private static bool IsTouchDocumentActionForDocument(CompilationAndGeneratorDriv
             public bool TryGetCompilation([NotNullWhen(true)] out Compilation? compilation)
             {
                 var state = ReadState();
-                if (state.FinalCompilationWithGeneratedDocuments != null && state.FinalCompilationWithGeneratedDocuments.TryGetValue(out var compilationOpt) && compilationOpt.HasValue)
-                {
-                    compilation = compilationOpt.Value;
-                    return true;
-                }
-
-                compilation = null;
-                return false;
+                compilation = state.FinalCompilationWithGeneratedDocuments;
+                return compilation != null;
             }
 
             public Task<Compilation> GetCompilationAsync(SolutionState solution, CancellationToken cancellationToken)
@@ -408,7 +400,7 @@ private async Task<Compilation> GetOrBuildDeclarationCompilationAsync(SolutionSe
                         var state = ReadState();
 
                         // we are already in the final stage. just return it.
-                        var compilation = state.FinalCompilationWithGeneratedDocuments?.GetValueOrNull(cancellationToken);
+                        var compilation = state.FinalCompilationWithGeneratedDocuments;
                         if (compilation != null)
                         {
                             return compilation;
@@ -457,7 +449,7 @@ private async Task<CompilationInfo> GetOrBuildCompilationInfoAsync(
                         var state = ReadState();
 
                         // Try to get the built compilation.  If it exists, then we can just return that.
-                        var finalCompilation = state.FinalCompilationWithGeneratedDocuments?.GetValueOrNull(cancellationToken);
+                        var finalCompilation = state.FinalCompilationWithGeneratedDocuments;
                         if (finalCompilation != null)
                         {
                             RoslynDebug.Assert(state.HasSuccessfullyLoaded.HasValue);
@@ -499,7 +491,7 @@ private async Task<CompilationInfo> BuildCompilationInfoAsync(
 
                 // if we already have a compilation, we must be already done!  This can happen if two
                 // threads were waiting to build, and we came in after the other succeeded.
-                var compilation = state.FinalCompilationWithGeneratedDocuments?.GetValueOrNull(cancellationToken);
+                var compilation = state.FinalCompilationWithGeneratedDocuments;
                 if (compilation != null)
                 {
                     RoslynDebug.Assert(state.HasSuccessfullyLoaded.HasValue);

From 24bd3ebfe8471ea13e3e560665118fa0a806c312 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Dec 2021 08:26:08 -0800
Subject: [PATCH 131/444] Add contract

---
 ...tionState.CompilationTracker.CompilationTrackerState.cs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs
index 4f1747a68f027..679d2f109c71a 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs
@@ -260,7 +260,7 @@ private sealed class FinalState : CompilationTrackerState
                 public override Compilation FinalCompilationWithGeneratedDocuments { get; }
 
                 private FinalState(
-                    Compilation finalCompilationSource,
+                    Compilation finalCompilation,
                     Compilation compilationWithoutGeneratedFilesSource,
                     Compilation compilationWithoutGeneratedFiles,
                     bool hasSuccessfullyLoaded,
@@ -269,15 +269,16 @@ private FinalState(
                     : base(compilationWithoutGeneratedFilesSource,
                            generatorInfo.WithDocumentsAreFinal(true)) // when we're in a final state, we've ran generators and should not run again
                 {
+                    Contract.ThrowIfNull(finalCompilation);
                     HasSuccessfullyLoaded = hasSuccessfullyLoaded;
-                    FinalCompilationWithGeneratedDocuments = finalCompilationSource;
+                    FinalCompilationWithGeneratedDocuments = finalCompilation;
                     UnrootedSymbolSet = unrootedSymbolSet;
 
                     if (this.GeneratorInfo.Documents.IsEmpty)
                     {
                         // In this case, the finalCompilationSource and compilationWithoutGeneratedFilesSource should point to the
                         // same Compilation, which should be compilationWithoutGeneratedFiles itself
-                        Debug.Assert(object.ReferenceEquals(finalCompilationSource, compilationWithoutGeneratedFiles));
+                        Debug.Assert(object.ReferenceEquals(finalCompilation, compilationWithoutGeneratedFiles));
                     }
                 }
 

From 8316b81bae7384e6d24decf502af2383ffa36815 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Dec 2021 08:28:34 -0800
Subject: [PATCH 132/444] Remove specific ValueSource subclass that is no
 longer used

---
 .../Core/CompilerExtensions.projitems         |  1 -
 .../ValuesSources/WeakValueSource.cs          | 48 -------------------
 2 files changed, 49 deletions(-)
 delete mode 100644 src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/ValuesSources/WeakValueSource.cs

diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems
index 896e22e8878b3..f079edaaf9ae6 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems
@@ -512,7 +512,6 @@
     <Compile Include="$(MSBuildThisFileDirectory)Utilities\ValuesSources\ValueSource.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Utilities\ValuesSources\WeaklyCachedRecoverableValueSource.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Utilities\ValuesSources\WeaklyCachedValueSource.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Utilities\ValuesSources\WeakValueSource.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Utilities\WeakEventHandler.cs" />
   </ItemGroup>
   <ItemGroup>
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/ValuesSources/WeakValueSource.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/ValuesSources/WeakValueSource.cs
deleted file mode 100644
index 530ea06680e17..0000000000000
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/ValuesSources/WeakValueSource.cs
+++ /dev/null
@@ -1,48 +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 System.Threading.Tasks;
-using Microsoft.CodeAnalysis;
-
-namespace Roslyn.Utilities
-{
-    /// <summary>
-    /// A <see cref="ValueSource{T}"/> that keeps a weak reference to a value.
-    /// </summary>
-    internal sealed class WeakValueSource<T> : ValueSource<Optional<T>>
-        where T : class
-    {
-        private readonly WeakReference<T> _weakValue;
-
-        public WeakValueSource(T value)
-            => _weakValue = new WeakReference<T>(value);
-
-        public override bool TryGetValue(out Optional<T> value)
-        {
-            if (_weakValue.TryGetTarget(out var target))
-            {
-                value = target;
-                return true;
-            }
-
-            value = default;
-            return false;
-        }
-
-        public override Optional<T> GetValue(CancellationToken cancellationToken)
-        {
-            if (_weakValue.TryGetTarget(out var target))
-            {
-                return target;
-            }
-
-            return default;
-        }
-
-        public override Task<Optional<T>> GetValueAsync(CancellationToken cancellationToken)
-            => Task.FromResult(GetValue(cancellationToken));
-    }
-}

From d19870c2c9d38573eaabc51cd82018ad47986cd7 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Mon, 20 Dec 2021 08:19:11 -0800
Subject: [PATCH 133/444] Add initial test for inline diagnostics tagger

---
 .../InlineDiagnosticsTaggerProviderTests.cs   | 47 +++++++++++++++++++
 .../Squiggles/ErrorSquiggleProducerTests.cs   | 20 ++++----
 .../SuggestionTagProducerTests.cs             |  2 +-
 .../Test/Preview/PreviewWorkspaceTests.cs     |  2 +-
 .../Diagnostics/DiagnosticTaggerWrapper.cs    |  4 +-
 .../Squiggles/SquiggleUtilities.cs            | 12 +++--
 .../Squiggles/TestDiagnosticTagProducer.cs    | 15 +++---
 .../Squiggles/ErrorSquiggleProducerTests.vb   |  6 +--
 8 files changed, 81 insertions(+), 27 deletions(-)
 create mode 100644 src/EditorFeatures/CSharpTest/InlineDiagnostics/InlineDiagnosticsTaggerProviderTests.cs

diff --git a/src/EditorFeatures/CSharpTest/InlineDiagnostics/InlineDiagnosticsTaggerProviderTests.cs b/src/EditorFeatures/CSharpTest/InlineDiagnostics/InlineDiagnosticsTaggerProviderTests.cs
new file mode 100644
index 0000000000000..fcbb5b673911a
--- /dev/null
+++ b/src/EditorFeatures/CSharpTest/InlineDiagnostics/InlineDiagnosticsTaggerProviderTests.cs
@@ -0,0 +1,47 @@
+// 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.Linq;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Editor.InlineDiagnostics;
+using Microsoft.CodeAnalysis.Editor.UnitTests.Extensions;
+using Microsoft.CodeAnalysis.Editor.UnitTests.Squiggles;
+using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Microsoft.VisualStudio.Text.Adornments;
+using Microsoft.VisualStudio.Text.Tagging;
+using Roslyn.Test.Utilities;
+using Roslyn.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.InlineDiagnostics
+{
+    [UseExportProvider]
+    public class InlineDiagnosticsTaggerProviderTests
+    {
+        [WpfFact, Trait(Traits.Feature, Traits.Features.ErrorSquiggles)]
+        public async Task ErrorTagGeneratedForError()
+        {
+            var spans = await GetTagSpansAsync("class C {");
+            Assert.Equal(1, spans.Count());
+
+            var firstSpan = spans.First();
+            Assert.Equal(PredefinedErrorTypeNames.SyntaxError, firstSpan.Tag.ErrorType);
+        }
+
+        private static async Task<ImmutableArray<ITagSpan<InlineDiagnosticsTag>>> GetTagSpansAsync(string content)
+        {
+            using var workspace = TestWorkspace.CreateCSharp(content, composition: SquiggleUtilities.WpfCompositionWithSolutionCrawler);
+            return await GetTagSpansAsync(workspace);
+        }
+
+        private static async Task<ImmutableArray<ITagSpan<InlineDiagnosticsTag>>> GetTagSpansAsync(TestWorkspace workspace)
+        {
+            workspace.ApplyOptions(new[] { KeyValuePairUtil.Create(new OptionKey2(InlineDiagnosticsOptions.EnableInlineDiagnostics, LanguageNames.CSharp), (object)true) });
+            return (await TestDiagnosticTagProducer<InlineDiagnosticsTaggerProvider, InlineDiagnosticsTag>.GetDiagnosticsAndErrorSpans(workspace)).Item2;
+        }
+    }
+}
diff --git a/src/EditorFeatures/CSharpTest/Squiggles/ErrorSquiggleProducerTests.cs b/src/EditorFeatures/CSharpTest/Squiggles/ErrorSquiggleProducerTests.cs
index cbdbef1636087..599213a3cc41b 100644
--- a/src/EditorFeatures/CSharpTest/Squiggles/ErrorSquiggleProducerTests.cs
+++ b/src/EditorFeatures/CSharpTest/Squiggles/ErrorSquiggleProducerTests.cs
@@ -75,7 +75,7 @@ void Test()
 </Workspace>";
 
             using var workspace = TestWorkspace.Create(workspaceXml);
-            var spans = (await TestDiagnosticTagProducer<DiagnosticsSquiggleTaggerProvider>.GetDiagnosticsAndErrorSpans(workspace)).Item2;
+            var spans = (await TestDiagnosticTagProducer<DiagnosticsSquiggleTaggerProvider, IErrorTag>.GetDiagnosticsAndErrorSpans(workspace)).Item2;
 
             Assert.Equal(1, spans.Count());
             Assert.Equal(PredefinedErrorTypeNames.SyntaxError, spans.First().Tag.ErrorType);
@@ -126,7 +126,7 @@ void Test()
                     }
                 };
 
-            var diagnosticsAndSpans = await TestDiagnosticTagProducer<DiagnosticsSquiggleTaggerProvider>.GetDiagnosticsAndErrorSpans(workspace, analyzerMap);
+            var diagnosticsAndSpans = await TestDiagnosticTagProducer<DiagnosticsSquiggleTaggerProvider, IErrorTag>.GetDiagnosticsAndErrorSpans(workspace, analyzerMap);
 
             var spans =
                 diagnosticsAndSpans.Item1
@@ -204,7 +204,7 @@ public async Task SemanticErrorReported()
         {
             using var workspace = TestWorkspace.CreateCSharp("class C : Bar { }", composition: SquiggleUtilities.CompositionWithSolutionCrawler);
 
-            var spans = await TestDiagnosticTagProducer<DiagnosticsSquiggleTaggerProvider>.GetDiagnosticsAndErrorSpans(workspace);
+            var spans = await TestDiagnosticTagProducer<DiagnosticsSquiggleTaggerProvider, IErrorTag>.GetDiagnosticsAndErrorSpans(workspace);
 
             Assert.Equal(1, spans.Item2.Count());
 
@@ -296,10 +296,10 @@ class Test
             var updateArgs = DiagnosticsUpdatedArgs.DiagnosticsCreated(
                     new object(), workspace, workspace.CurrentSolution, document.Project.Id, document.Id,
                     ImmutableArray.Create(
-                        TestDiagnosticTagProducer<DiagnosticsSquiggleTaggerProvider>.CreateDiagnosticData(document, new TextSpan(0, 0)),
-                        TestDiagnosticTagProducer<DiagnosticsSquiggleTaggerProvider>.CreateDiagnosticData(document, new TextSpan(0, 1))));
+                        TestDiagnosticTagProducer<DiagnosticsSquiggleTaggerProvider, IErrorTag>.CreateDiagnosticData(document, new TextSpan(0, 0)),
+                        TestDiagnosticTagProducer<DiagnosticsSquiggleTaggerProvider, IErrorTag>.CreateDiagnosticData(document, new TextSpan(0, 1))));
 
-            var spans = await TestDiagnosticTagProducer<DiagnosticsSquiggleTaggerProvider>.GetErrorsFromUpdateSource(workspace, updateArgs);
+            var spans = await TestDiagnosticTagProducer<DiagnosticsSquiggleTaggerProvider, IErrorTag>.GetErrorsFromUpdateSource(workspace, updateArgs);
 
             Assert.Equal(1, spans.Count());
             var first = spans.First();
@@ -327,10 +327,10 @@ class Test
             var updateArgs = DiagnosticsUpdatedArgs.DiagnosticsCreated(
                     new LiveId(), workspace, workspace.CurrentSolution, document.Project.Id, document.Id,
                     ImmutableArray.Create(
-                        TestDiagnosticTagProducer<DiagnosticsSquiggleTaggerProvider>.CreateDiagnosticData(document, new TextSpan(0, 0)),
-                        TestDiagnosticTagProducer<DiagnosticsSquiggleTaggerProvider>.CreateDiagnosticData(document, new TextSpan(0, 1))));
+                        TestDiagnosticTagProducer<DiagnosticsSquiggleTaggerProvider, IErrorTag>.CreateDiagnosticData(document, new TextSpan(0, 0)),
+                        TestDiagnosticTagProducer<DiagnosticsSquiggleTaggerProvider, IErrorTag>.CreateDiagnosticData(document, new TextSpan(0, 1))));
 
-            var spans = await TestDiagnosticTagProducer<DiagnosticsSquiggleTaggerProvider>.GetErrorsFromUpdateSource(workspace, updateArgs);
+            var spans = await TestDiagnosticTagProducer<DiagnosticsSquiggleTaggerProvider, IErrorTag>.GetErrorsFromUpdateSource(workspace, updateArgs);
 
             Assert.Equal(2, spans.Count());
             var first = spans.First();
@@ -350,7 +350,7 @@ public LiveId()
         private static async Task<ImmutableArray<ITagSpan<IErrorTag>>> GetTagSpansAsync(string content)
         {
             using var workspace = TestWorkspace.CreateCSharp(content, composition: SquiggleUtilities.CompositionWithSolutionCrawler);
-            return (await TestDiagnosticTagProducer<DiagnosticsSquiggleTaggerProvider>.GetDiagnosticsAndErrorSpans(workspace)).Item2;
+            return (await TestDiagnosticTagProducer<DiagnosticsSquiggleTaggerProvider, IErrorTag>.GetDiagnosticsAndErrorSpans(workspace)).Item2;
         }
 
         private sealed class ReportOnClassWithLink : DiagnosticAnalyzer
diff --git a/src/EditorFeatures/CSharpTest/SuggestionTags/SuggestionTagProducerTests.cs b/src/EditorFeatures/CSharpTest/SuggestionTags/SuggestionTagProducerTests.cs
index 7d236a28c1f68..60a800bee0936 100644
--- a/src/EditorFeatures/CSharpTest/SuggestionTags/SuggestionTagProducerTests.cs
+++ b/src/EditorFeatures/CSharpTest/SuggestionTags/SuggestionTagProducerTests.cs
@@ -47,7 +47,7 @@ void M() {
                 { LanguageNames.CSharp, ImmutableArray.Create<DiagnosticAnalyzer>(new CSharpUseObjectInitializerDiagnosticAnalyzer()) }
             };
 
-            var spans = (await TestDiagnosticTagProducer<DiagnosticsSuggestionTaggerProvider>.GetDiagnosticsAndErrorSpans(workspace, analyzerMap)).Item2;
+            var spans = (await TestDiagnosticTagProducer<DiagnosticsSuggestionTaggerProvider, IErrorTag>.GetDiagnosticsAndErrorSpans(workspace, analyzerMap)).Item2;
             return (spans, workspace.Documents.Single().SelectedSpans.Single());
         }
     }
diff --git a/src/EditorFeatures/Test/Preview/PreviewWorkspaceTests.cs b/src/EditorFeatures/Test/Preview/PreviewWorkspaceTests.cs
index a089e84008738..9ad9af6c9bc95 100644
--- a/src/EditorFeatures/Test/Preview/PreviewWorkspaceTests.cs
+++ b/src/EditorFeatures/Test/Preview/PreviewWorkspaceTests.cs
@@ -185,7 +185,7 @@ public async Task TestPreviewDiagnosticTagger()
             // enable preview diagnostics
             previewWorkspace.EnableDiagnostic();
 
-            var diagnosticsAndErrorsSpans = await SquiggleUtilities.GetDiagnosticsAndErrorSpansAsync<DiagnosticsSquiggleTaggerProvider>(workspace);
+            var diagnosticsAndErrorsSpans = await SquiggleUtilities.GetDiagnosticsAndErrorSpansAsync<DiagnosticsSquiggleTaggerProvider, IErrorTag>(workspace);
             const string AnalyzerCount = "Analyzer Count: ";
             Assert.Equal(AnalyzerCount + 1, AnalyzerCount + diagnosticsAndErrorsSpans.Item1.Length);
 
diff --git a/src/EditorFeatures/TestUtilities/Diagnostics/DiagnosticTaggerWrapper.cs b/src/EditorFeatures/TestUtilities/Diagnostics/DiagnosticTaggerWrapper.cs
index 9b228efd368af..bd97c0ed0d506 100644
--- a/src/EditorFeatures/TestUtilities/Diagnostics/DiagnosticTaggerWrapper.cs
+++ b/src/EditorFeatures/TestUtilities/Diagnostics/DiagnosticTaggerWrapper.cs
@@ -9,6 +9,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editor.Implementation.Diagnostics;
+using Microsoft.CodeAnalysis.Editor.InlineDiagnostics;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
@@ -76,7 +77,8 @@ public ITaggerProvider TaggerProvider
 
                     if (typeof(TProvider) == typeof(DiagnosticsSquiggleTaggerProvider)
                         || typeof(TProvider) == typeof(DiagnosticsSuggestionTaggerProvider)
-                        || typeof(TProvider) == typeof(DiagnosticsClassificationTaggerProvider))
+                        || typeof(TProvider) == typeof(DiagnosticsClassificationTaggerProvider)
+                        || typeof(TProvider) == typeof(InlineDiagnosticsTaggerProvider))
                     {
                         _taggerProvider = _workspace.ExportProvider.GetExportedValues<ITaggerProvider>()
                             .OfType<TProvider>()
diff --git a/src/EditorFeatures/TestUtilities/Squiggles/SquiggleUtilities.cs b/src/EditorFeatures/TestUtilities/Squiggles/SquiggleUtilities.cs
index 421c387d4c951..1df8d05f47a29 100644
--- a/src/EditorFeatures/TestUtilities/Squiggles/SquiggleUtilities.cs
+++ b/src/EditorFeatures/TestUtilities/Squiggles/SquiggleUtilities.cs
@@ -26,13 +26,17 @@ public static class SquiggleUtilities
         internal static TestComposition CompositionWithSolutionCrawler = EditorTestCompositions.EditorFeatures
             .RemoveParts(typeof(MockWorkspaceEventListenerProvider));
 
-        internal static async Task<(ImmutableArray<DiagnosticData>, ImmutableArray<ITagSpan<IErrorTag>>)> GetDiagnosticsAndErrorSpansAsync<TProvider>(
+        internal static TestComposition WpfCompositionWithSolutionCrawler = EditorTestCompositions.EditorFeaturesWpf
+            .RemoveParts(typeof(MockWorkspaceEventListenerProvider));
+
+        internal static async Task<(ImmutableArray<DiagnosticData>, ImmutableArray<ITagSpan<TTag>>)> GetDiagnosticsAndErrorSpansAsync<TProvider, TTag>(
             TestWorkspace workspace,
             IReadOnlyDictionary<string, ImmutableArray<DiagnosticAnalyzer>> analyzerMap = null)
-            where TProvider : AbstractDiagnosticsAdornmentTaggerProvider<IErrorTag>
+            where TProvider : AbstractDiagnosticsAdornmentTaggerProvider<TTag>
+            where TTag : class, ITag
         {
-            using var wrapper = new DiagnosticTaggerWrapper<TProvider, IErrorTag>(workspace, analyzerMap);
-            var tagger = wrapper.TaggerProvider.CreateTagger<IErrorTag>(workspace.Documents.First().GetTextBuffer());
+            using var wrapper = new DiagnosticTaggerWrapper<TProvider, TTag>(workspace, analyzerMap);
+            var tagger = wrapper.TaggerProvider.CreateTagger<TTag>(workspace.Documents.First().GetTextBuffer());
 
             using var disposable = tagger as IDisposable;
             await wrapper.WaitForTags();
diff --git a/src/EditorFeatures/TestUtilities/Squiggles/TestDiagnosticTagProducer.cs b/src/EditorFeatures/TestUtilities/Squiggles/TestDiagnosticTagProducer.cs
index 18e8a2a490cdf..bcf78b9d02685 100644
--- a/src/EditorFeatures/TestUtilities/Squiggles/TestDiagnosticTagProducer.cs
+++ b/src/EditorFeatures/TestUtilities/Squiggles/TestDiagnosticTagProducer.cs
@@ -22,24 +22,25 @@
 
 namespace Microsoft.CodeAnalysis.Editor.UnitTests.Squiggles
 {
-    internal sealed class TestDiagnosticTagProducer<TProvider>
-        where TProvider : AbstractDiagnosticsAdornmentTaggerProvider<IErrorTag>
+    internal sealed class TestDiagnosticTagProducer<TProvider, TTag>
+        where TProvider : AbstractDiagnosticsAdornmentTaggerProvider<TTag>
+        where TTag : class, ITag
     {
-        internal static Task<(ImmutableArray<DiagnosticData>, ImmutableArray<ITagSpan<IErrorTag>>)> GetDiagnosticsAndErrorSpans(
+        internal static Task<(ImmutableArray<DiagnosticData>, ImmutableArray<ITagSpan<TTag>>)> GetDiagnosticsAndErrorSpans(
             TestWorkspace workspace,
             IReadOnlyDictionary<string, ImmutableArray<DiagnosticAnalyzer>> analyzerMap = null)
         {
-            return SquiggleUtilities.GetDiagnosticsAndErrorSpansAsync<TProvider>(workspace, analyzerMap);
+            return SquiggleUtilities.GetDiagnosticsAndErrorSpansAsync<TProvider, TTag>(workspace, analyzerMap);
         }
 
-        internal static async Task<IList<ITagSpan<IErrorTag>>> GetErrorsFromUpdateSource(TestWorkspace workspace, DiagnosticsUpdatedArgs updateArgs)
+        internal static async Task<IList<ITagSpan<TTag>>> GetErrorsFromUpdateSource(TestWorkspace workspace, DiagnosticsUpdatedArgs updateArgs)
         {
             var globalOptions = workspace.GetService<IGlobalOptionService>();
             var source = new TestDiagnosticUpdateSource(globalOptions);
 
-            using var wrapper = new DiagnosticTaggerWrapper<TProvider, IErrorTag>(workspace, updateSource: source);
+            using var wrapper = new DiagnosticTaggerWrapper<TProvider, TTag>(workspace, updateSource: source);
 
-            var tagger = wrapper.TaggerProvider.CreateTagger<IErrorTag>(workspace.Documents.First().GetTextBuffer());
+            var tagger = wrapper.TaggerProvider.CreateTagger<TTag>(workspace.Documents.First().GetTextBuffer());
             using var disposable = (IDisposable)tagger;
 
             source.RaiseDiagnosticsUpdated(updateArgs);
diff --git a/src/EditorFeatures/VisualBasicTest/Squiggles/ErrorSquiggleProducerTests.vb b/src/EditorFeatures/VisualBasicTest/Squiggles/ErrorSquiggleProducerTests.vb
index cb2703bb6094b..7987e1167cd42 100644
--- a/src/EditorFeatures/VisualBasicTest/Squiggles/ErrorSquiggleProducerTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/Squiggles/ErrorSquiggleProducerTests.vb
@@ -25,7 +25,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Squiggles
 
         Private Shared Async Function ProduceSquiggles(content As String) As Task(Of ImmutableArray(Of ITagSpan(Of IErrorTag)))
             Using workspace = TestWorkspace.CreateVisualBasic(content)
-                Return (Await TestDiagnosticTagProducer(Of DiagnosticsSquiggleTaggerProvider).GetDiagnosticsAndErrorSpans(workspace)).Item2
+                Return (Await TestDiagnosticTagProducer(Of DiagnosticsSquiggleTaggerProvider, IErrorTag).GetDiagnosticsAndErrorSpans(workspace)).Item2
             End Using
         End Function
 
@@ -68,7 +68,7 @@ End Class")
     End Sub
 End Class")
 
-                Dim diagnosticsAndSpans = Await TestDiagnosticTagProducer(Of DiagnosticsSquiggleTaggerProvider).GetDiagnosticsAndErrorSpans(workspace)
+                Dim diagnosticsAndSpans = Await TestDiagnosticTagProducer(Of DiagnosticsSquiggleTaggerProvider, IErrorTag).GetDiagnosticsAndErrorSpans(workspace)
                 Dim spans = diagnosticsAndSpans.Item1.Zip(diagnosticsAndSpans.Item2, Function(diagostic, span) (diagostic, span)).OrderBy(Function(s) s.span.Span.Span.Start).ToImmutableArray()
 
                 Assert.Equal(1, spans.Count())
@@ -122,7 +122,7 @@ End Class"
                 options.Add(preferIntrinsicPredefinedTypeOption, preferIntrinsicPredefinedTypeOptionValue)
                 workspace.ApplyOptions(options)
 
-                Dim diagnosticsAndSpans = Await TestDiagnosticTagProducer(Of DiagnosticsSquiggleTaggerProvider).GetDiagnosticsAndErrorSpans(workspace, analyzerMap)
+                Dim diagnosticsAndSpans = Await TestDiagnosticTagProducer(Of DiagnosticsSquiggleTaggerProvider, IErrorTag).GetDiagnosticsAndErrorSpans(workspace, analyzerMap)
                 Dim spans = diagnosticsAndSpans.Item1.Zip(diagnosticsAndSpans.Item2, Function(diagostic, span) (diagostic, span)).OrderBy(Function(s) s.span.Span.Span.Start).ToImmutableArray()
 
                 Assert.Equal(2, spans.Length)

From bca0522ffc71b5f41d8dbc7f886bebe64bf0ed14 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Mon, 20 Dec 2021 09:29:21 -0800
Subject: [PATCH 134/444] Fix incremental build failure for customization of
 RunAnalyzersDuringBuild

---
 eng/targets/Imports.targets | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/eng/targets/Imports.targets b/eng/targets/Imports.targets
index 15b067deb0476..57c34c2b6a7e4 100644
--- a/eng/targets/Imports.targets
+++ b/eng/targets/Imports.targets
@@ -56,7 +56,7 @@
           Otherwise, default to 'true'.
   -->
   <PropertyGroup Condition="'$(RunAnalyzersDuringBuild)' == ''">
-    <RunAnalyzersDuringBuild Condition="'$(DesignTimeBuild)' != 'true' AND '$(ContinuousIntegrationBuild)' != 'true' AND !('$(RoslynEnforceCodeStyle)' == 'true' OR '$(RunCodeAnalysis)' == 'true')">false</RunAnalyzersDuringBuild>
+    <RunAnalyzersDuringBuild Condition="'$(RoslynEnforceCodeStyle)' != 'true' AND '$(RunCodeAnalysis)' != 'true'">false</RunAnalyzersDuringBuild>
     <RunAnalyzersDuringBuild Condition="'$(RunAnalyzersDuringBuild)' == ''">true</RunAnalyzersDuringBuild>
   </PropertyGroup>
 

From e3fd8e27534b35ff64f5a96b754c3c212999e9ba Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Dec 2021 09:44:06 -0800
Subject: [PATCH 135/444] Update underling-reassigned-variable to understand
 suppressed variables as well

---
 .../CSharpReassignedVariableTests.cs          | 34 +++++++++++++++++++
 .../Extensions/ExpressionSyntaxExtensions.cs  | 27 ++++++++++++---
 2 files changed, 57 insertions(+), 4 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/ReassignedVariable/CSharpReassignedVariableTests.cs b/src/EditorFeatures/CSharpTest/ReassignedVariable/CSharpReassignedVariableTests.cs
index 4860b46b1673a..f7fe02f04df99 100644
--- a/src/EditorFeatures/CSharpTest/ReassignedVariable/CSharpReassignedVariableTests.cs
+++ b/src/EditorFeatures/CSharpTest/ReassignedVariable/CSharpReassignedVariableTests.cs
@@ -8,6 +8,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor.UnitTests.ReassignedVariable;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
+using Roslyn.Test.Utilities;
 using Xunit;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ReassignedVariable
@@ -652,6 +653,23 @@ void M()
 }");
         }
 
+        [Fact]
+        public async Task TestReadonlyRefLocalWithNoReassignment1()
+        {
+            await TestAsync(
+@"
+using System;
+class C
+{
+    void M()
+    {
+        int p = 0;
+        ref readonly int refP = ref p!;
+        Console.WriteLine(p);
+    }
+}");
+        }
+
         [Fact]
         public async Task TestPointerCausingPossibleReassignment()
         {
@@ -994,6 +1012,22 @@ void M(int p, int p)
     {
         p = 1;
     }
+}");
+        }
+
+        [Fact, WorkItem(58161, "https://github.com/dotnet/roslyn/issues/58161")]
+        public async Task TestRefToSuppression1()
+        {
+            await TestAsync(
+@"#nullable enable
+
+using System.Diagnostics.CodeAnalysis;
+using System.Threading;
+
+class C
+{
+    public static T EnsureInitialized<T>([NotNull] ref T? [|target|]) where T : class
+        => Volatile.Read(ref [|target|]!);
 }");
         }
     }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ExpressionSyntaxExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ExpressionSyntaxExtensions.cs
index 86b38a51a44be..ac112a463f720 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ExpressionSyntaxExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ExpressionSyntaxExtensions.cs
@@ -197,8 +197,27 @@ public static bool IsInOutContext(this ExpressionSyntax expression)
         }
 
         public static bool IsInRefContext(this ExpressionSyntax expression)
-            => expression.IsParentKind(SyntaxKind.RefExpression) ||
-               (expression?.Parent as ArgumentSyntax)?.RefOrOutKeyword.Kind() == SyntaxKind.RefKeyword;
+            => IsInRefContext(expression, out _);
+
+        /// <summary>
+        /// Returns true if this expression is in some <c>ref</c> keyword context.  If <see langword="true"/> then
+        /// <paramref name="refParent"/> will be the node containing the <see langword="ref"/> keyword.
+        /// </summary>
+        public static bool IsInRefContext(this ExpressionSyntax expression, [NotNullWhen(true)] out SyntaxNode? refParent)
+        {
+            while (expression.Parent is ParenthesizedExpressionSyntax or PostfixUnaryExpressionSyntax(SyntaxKind.SuppressNullableWarningExpression))
+                expression = (ExpressionSyntax)expression.Parent;
+
+            if (expression.Parent is RefExpressionSyntax or
+                                     ArgumentSyntax { RefOrOutKeyword.RawKind: (int)SyntaxKind.RefKeyword })
+            {
+                refParent = expression.Parent;
+                return true;
+            }
+
+            refParent = null;
+            return false;
+        }
 
         public static bool IsInInContext(this ExpressionSyntax expression)
             => (expression?.Parent as ArgumentSyntax)?.RefKindKeyword.Kind() == SyntaxKind.InKeyword;
@@ -311,12 +330,12 @@ public static bool IsWrittenTo(this ExpressionSyntax expression, SemanticModel s
             if (expression.IsOnlyWrittenTo())
                 return true;
 
-            if (expression.IsInRefContext())
+            if (expression.IsInRefContext(out var refParent))
             {
                 // most cases of `ref x` will count as a potential write of `x`.  An important exception is:
                 // `ref readonly y = ref x`.  In that case, because 'y' can't be written to, this would not 
                 // be a write of 'x'.
-                if (expression is { Parent: { RawKind: (int)SyntaxKind.RefExpression, Parent: EqualsValueClauseSyntax { Parent: VariableDeclaratorSyntax { Parent: VariableDeclarationSyntax { Type: RefTypeSyntax refType } } } } }
+                if (refParent.Parent is EqualsValueClauseSyntax { Parent: VariableDeclaratorSyntax { Parent: VariableDeclarationSyntax { Type: RefTypeSyntax refType } } }
                     && refType.ReadOnlyKeyword != default)
                 {
                     return false;

From 1bc95daa25c96afccd61a0c07a03723c5f013309 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Mon, 20 Dec 2021 09:54:04 -0800
Subject: [PATCH 136/444] Fix incremental build failure for package projects

These projects were expecting but not creating XML documentation files.
---
 eng/targets/PackageProject.props                   | 14 ++++++++++++++
 eng/targets/PackageProject.targets                 |  7 -------
 src/NuGet/Directory.Build.props                    |  5 +++++
 src/NuGet/Directory.Build.targets                  |  2 +-
 .../DevDivInsertionFiles/Directory.Build.props     |  5 +++++
 .../DevDivInsertionFiles/Directory.Build.targets   |  2 +-
 src/Setup/DevDivVsix/Directory.Build.props         |  5 +++++
 src/Setup/DevDivVsix/Directory.Build.targets       |  2 +-
 src/Setup/Installer/Directory.Build.props          |  5 +++++
 src/Setup/Installer/Directory.Build.targets        |  2 +-
 10 files changed, 38 insertions(+), 11 deletions(-)
 create mode 100644 eng/targets/PackageProject.props
 create mode 100644 src/NuGet/Directory.Build.props
 create mode 100644 src/Setup/DevDivInsertionFiles/Directory.Build.props
 create mode 100644 src/Setup/DevDivVsix/Directory.Build.props
 create mode 100644 src/Setup/Installer/Directory.Build.props

diff --git a/eng/targets/PackageProject.props b/eng/targets/PackageProject.props
new file mode 100644
index 0000000000000..9368ce294f65f
--- /dev/null
+++ b/eng/targets/PackageProject.props
@@ -0,0 +1,14 @@
+<!-- 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>
+  <!-- 
+    Include this props file in projects that build meta-packages.
+  -->
+
+  <PropertyGroup>
+    <ProduceReferenceAssembly>false</ProduceReferenceAssembly>
+    <GenerateDocumentationFile>false</GenerateDocumentationFile>
+
+    <!-- Remove once https://github.com/NuGet/Home/issues/8583 is fixed -->
+    <NoWarn>$(NoWarn);NU5128</NoWarn>
+  </PropertyGroup>
+</Project>
\ No newline at end of file
diff --git a/eng/targets/PackageProject.targets b/eng/targets/PackageProject.targets
index 4b28a318384ae..dac70a7b1a079 100644
--- a/eng/targets/PackageProject.targets
+++ b/eng/targets/PackageProject.targets
@@ -11,11 +11,4 @@
   <Target Name="CoreBuild" DependsOnTargets="ResolveProjectReferences">
     <MakeDir Directories="$(IntermediateOutputPath)" ContinueOnError="True"/>
   </Target>
-
-  <PropertyGroup>
-    <ProduceReferenceAssembly>false</ProduceReferenceAssembly>
-
-    <!-- Remove once https://github.com/NuGet/Home/issues/8583 is fixed -->
-    <NoWarn>$(NoWarn);NU5128</NoWarn>
-  </PropertyGroup>
 </Project>
\ No newline at end of file
diff --git a/src/NuGet/Directory.Build.props b/src/NuGet/Directory.Build.props
new file mode 100644
index 0000000000000..13fab30f50f0f
--- /dev/null
+++ b/src/NuGet/Directory.Build.props
@@ -0,0 +1,5 @@
+<!-- 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>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove('Directory.Build.props', '$(MSBuildThisFileDirectory)../'))" />
+  <Import Project="$(RepositoryEngineeringDir)targets\PackageProject.props"/>
+</Project>
diff --git a/src/NuGet/Directory.Build.targets b/src/NuGet/Directory.Build.targets
index 609d4bacd63b0..e1dbd218d1d8b 100644
--- a/src/NuGet/Directory.Build.targets
+++ b/src/NuGet/Directory.Build.targets
@@ -1,5 +1,5 @@
 <!-- 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>
-  <Import Project="..\..\Directory.Build.targets" />
+  <Import Project="$([MSBuild]::GetPathOfFileAbove('Directory.Build.targets', '$(MSBuildThisFileDirectory)../'))" />
   <Import Project="$(RepositoryEngineeringDir)targets\PackageProject.targets" Condition="'$(TargetFramework)' != ''"/>
 </Project>
\ No newline at end of file
diff --git a/src/Setup/DevDivInsertionFiles/Directory.Build.props b/src/Setup/DevDivInsertionFiles/Directory.Build.props
new file mode 100644
index 0000000000000..13fab30f50f0f
--- /dev/null
+++ b/src/Setup/DevDivInsertionFiles/Directory.Build.props
@@ -0,0 +1,5 @@
+<!-- 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>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove('Directory.Build.props', '$(MSBuildThisFileDirectory)../'))" />
+  <Import Project="$(RepositoryEngineeringDir)targets\PackageProject.props"/>
+</Project>
diff --git a/src/Setup/DevDivInsertionFiles/Directory.Build.targets b/src/Setup/DevDivInsertionFiles/Directory.Build.targets
index 59416fe039717..f4a6a73d16e4a 100644
--- a/src/Setup/DevDivInsertionFiles/Directory.Build.targets
+++ b/src/Setup/DevDivInsertionFiles/Directory.Build.targets
@@ -1,5 +1,5 @@
 <!-- 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>
-  <Import Project="..\..\..\Directory.Build.targets" />
+  <Import Project="$([MSBuild]::GetPathOfFileAbove('Directory.Build.targets', '$(MSBuildThisFileDirectory)../'))" />
   <Import Project="$(RepositoryEngineeringDir)targets\PackageProject.targets"/>
 </Project>
\ No newline at end of file
diff --git a/src/Setup/DevDivVsix/Directory.Build.props b/src/Setup/DevDivVsix/Directory.Build.props
new file mode 100644
index 0000000000000..13fab30f50f0f
--- /dev/null
+++ b/src/Setup/DevDivVsix/Directory.Build.props
@@ -0,0 +1,5 @@
+<!-- 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>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove('Directory.Build.props', '$(MSBuildThisFileDirectory)../'))" />
+  <Import Project="$(RepositoryEngineeringDir)targets\PackageProject.props"/>
+</Project>
diff --git a/src/Setup/DevDivVsix/Directory.Build.targets b/src/Setup/DevDivVsix/Directory.Build.targets
index 72ffa0dd4aaed..f4ce9a5063717 100644
--- a/src/Setup/DevDivVsix/Directory.Build.targets
+++ b/src/Setup/DevDivVsix/Directory.Build.targets
@@ -1,5 +1,5 @@
 <!-- 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>
-  <Import Project="..\..\..\Directory.Build.targets" />
+  <Import Project="$([MSBuild]::GetPathOfFileAbove('Directory.Build.targets', '$(MSBuildThisFileDirectory)../'))" />
   <Import Project="$(RepositoryEngineeringDir)targets\PackageProject.targets" Condition="'$(TargetFramework)' != ''"/>
 </Project>
diff --git a/src/Setup/Installer/Directory.Build.props b/src/Setup/Installer/Directory.Build.props
new file mode 100644
index 0000000000000..13fab30f50f0f
--- /dev/null
+++ b/src/Setup/Installer/Directory.Build.props
@@ -0,0 +1,5 @@
+<!-- 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>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove('Directory.Build.props', '$(MSBuildThisFileDirectory)../'))" />
+  <Import Project="$(RepositoryEngineeringDir)targets\PackageProject.props"/>
+</Project>
diff --git a/src/Setup/Installer/Directory.Build.targets b/src/Setup/Installer/Directory.Build.targets
index e059dfd9a3af6..e1dbd218d1d8b 100644
--- a/src/Setup/Installer/Directory.Build.targets
+++ b/src/Setup/Installer/Directory.Build.targets
@@ -1,5 +1,5 @@
 <!-- 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>
-  <Import Project="..\..\..\Directory.Build.targets" />
+  <Import Project="$([MSBuild]::GetPathOfFileAbove('Directory.Build.targets', '$(MSBuildThisFileDirectory)../'))" />
   <Import Project="$(RepositoryEngineeringDir)targets\PackageProject.targets" Condition="'$(TargetFramework)' != ''"/>
 </Project>
\ No newline at end of file

From bf2895f15b903834cea057cf88864f4fb28461b2 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Mon, 20 Dec 2021 10:01:48 -0800
Subject: [PATCH 137/444] Fix incremental build failure for package projects

These projects were expecting but not creating output binaries.
---
 eng/targets/PackageProject.props   | 1 +
 eng/targets/PackageProject.targets | 7 ++++++-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/eng/targets/PackageProject.props b/eng/targets/PackageProject.props
index 9368ce294f65f..c2d3e0f0fb35d 100644
--- a/eng/targets/PackageProject.props
+++ b/eng/targets/PackageProject.props
@@ -7,6 +7,7 @@
   <PropertyGroup>
     <ProduceReferenceAssembly>false</ProduceReferenceAssembly>
     <GenerateDocumentationFile>false</GenerateDocumentationFile>
+    <SkipCopyBuildProduct>true</SkipCopyBuildProduct>
 
     <!-- Remove once https://github.com/NuGet/Home/issues/8583 is fixed -->
     <NoWarn>$(NoWarn);NU5128</NoWarn>
diff --git a/eng/targets/PackageProject.targets b/eng/targets/PackageProject.targets
index dac70a7b1a079..a64f9bae14767 100644
--- a/eng/targets/PackageProject.targets
+++ b/eng/targets/PackageProject.targets
@@ -11,4 +11,9 @@
   <Target Name="CoreBuild" DependsOnTargets="ResolveProjectReferences">
     <MakeDir Directories="$(IntermediateOutputPath)" ContinueOnError="True"/>
   </Target>
-</Project>
\ No newline at end of file
+
+  <ItemGroup>
+    <!-- These projects will not create intermediate assemblies -->
+    <IntermediateAssembly Remove="@(IntermediateAssembly)"/>
+  </ItemGroup>
+</Project>

From dd7d3de8cd89de59237694f0343b119857f164bb Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Dec 2021 13:35:53 -0800
Subject: [PATCH 138/444] Allow null args

---
 .../CSharp/Extensions/ExpressionSyntaxExtensions.cs       | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ExpressionSyntaxExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ExpressionSyntaxExtensions.cs
index ac112a463f720..094b84b4f7d81 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ExpressionSyntaxExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ExpressionSyntaxExtensions.cs
@@ -203,13 +203,13 @@ public static bool IsInRefContext(this ExpressionSyntax expression)
         /// Returns true if this expression is in some <c>ref</c> keyword context.  If <see langword="true"/> then
         /// <paramref name="refParent"/> will be the node containing the <see langword="ref"/> keyword.
         /// </summary>
-        public static bool IsInRefContext(this ExpressionSyntax expression, [NotNullWhen(true)] out SyntaxNode? refParent)
+        public static bool IsInRefContext(this ExpressionSyntax? expression, [NotNullWhen(true)] out SyntaxNode? refParent)
         {
-            while (expression.Parent is ParenthesizedExpressionSyntax or PostfixUnaryExpressionSyntax(SyntaxKind.SuppressNullableWarningExpression))
+            while (expression?.Parent is ParenthesizedExpressionSyntax or PostfixUnaryExpressionSyntax(SyntaxKind.SuppressNullableWarningExpression))
                 expression = (ExpressionSyntax)expression.Parent;
 
-            if (expression.Parent is RefExpressionSyntax or
-                                     ArgumentSyntax { RefOrOutKeyword.RawKind: (int)SyntaxKind.RefKeyword })
+            if (expression?.Parent is RefExpressionSyntax or
+                                      ArgumentSyntax { RefOrOutKeyword.RawKind: (int)SyntaxKind.RefKeyword })
             {
                 refParent = expression.Parent;
                 return true;

From 49fe3355d5f1d8d24a28b42c3b4f6126e4bb51d0 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Dec 2021 13:36:22 -0800
Subject: [PATCH 139/444] NRT

---
 .../Compiler/CSharp/Extensions/ExpressionSyntaxExtensions.cs    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ExpressionSyntaxExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ExpressionSyntaxExtensions.cs
index 094b84b4f7d81..43a5fdbc698d4 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ExpressionSyntaxExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ExpressionSyntaxExtensions.cs
@@ -203,7 +203,7 @@ public static bool IsInRefContext(this ExpressionSyntax expression)
         /// Returns true if this expression is in some <c>ref</c> keyword context.  If <see langword="true"/> then
         /// <paramref name="refParent"/> will be the node containing the <see langword="ref"/> keyword.
         /// </summary>
-        public static bool IsInRefContext(this ExpressionSyntax? expression, [NotNullWhen(true)] out SyntaxNode? refParent)
+        public static bool IsInRefContext([NotNullWhen(true)] this ExpressionSyntax? expression, [NotNullWhen(true)] out SyntaxNode? refParent)
         {
             while (expression?.Parent is ParenthesizedExpressionSyntax or PostfixUnaryExpressionSyntax(SyntaxKind.SuppressNullableWarningExpression))
                 expression = (ExpressionSyntax)expression.Parent;

From 288782a960dee67d13d8fa4daeb0a798b961be33 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Dec 2021 14:31:38 -0800
Subject: [PATCH 140/444] Initial trial

---
 .../ConvertNamespaceTransform.cs              | 118 ++++++++++++++++--
 .../Wrapping/AbstractCodeActionComputer.cs    |   9 +-
 .../Indentation/IIndentationService.cs        |  15 +++
 3 files changed, 128 insertions(+), 14 deletions(-)

diff --git a/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs b/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs
index 3050716634ac4..51262b097164e 100644
--- a/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs
+++ b/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs
@@ -2,9 +2,11 @@
 // 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.IO.Pipes;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -14,8 +16,11 @@
 using Microsoft.CodeAnalysis.CSharp.Formatting;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Formatting;
+using Microsoft.CodeAnalysis.Indentation;
 using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
 #if CODE_STYLE
@@ -26,15 +31,114 @@ namespace Microsoft.CodeAnalysis.CSharp.ConvertNamespace
 {
     internal static class ConvertNamespaceTransform
     {
-        public static async Task<Document> ConvertAsync(
-            Document document, BaseNamespaceDeclarationSyntax baseNamespace, CancellationToken cancellationToken)
+        public static Task<Document> ConvertAsync(Document document, BaseNamespaceDeclarationSyntax baseNamespace, CancellationToken cancellationToken)
+            => baseNamespace switch
+            {
+                FileScopedNamespaceDeclarationSyntax fileScopedNamespace => ConvertFileScopedNamespaceAsync(document, fileScopedNamespace, cancellationToken),
+                NamespaceDeclarationSyntax namespaceDeclaration => ConvertNamespaceDeclarationAsync(document, namespaceDeclaration, cancellationToken),
+                _ => throw ExceptionUtilities.UnexpectedValue(baseNamespace.Kind()),
+            };
+
+        private static async Task<Document> ConvertNamespaceDeclarationAsync(Document document, NamespaceDeclarationSyntax namespaceDeclaration, CancellationToken cancellationToken)
+        {
+            // First, determine how much indentation we had inside the original block namespace. We'll attempt to remove
+            // that much indentation from each applicable line after we conver the block namespace to a file scoped
+            // namespace.
+            var indentation = await GetIndentationAsync(document, namespaceDeclaration, cancellationToken).ConfigureAwait(false);
+
+            // Next, actually replace the block namespace with the file scoped namespace.
+            var annotation = new SyntaxAnnotation();
+            document = await ReplaceWithFileScopedNamespaceAsync(document, namespaceDeclaration, annotation, cancellationToken).ConfigureAwait(false);
+
+            // Now, find the file scoped namespace in the updated doc and go and dedent every line if applicable.
+            if (indentation == null)
+                return document;
+
+            return await DedentNamespaceAsync(document, indentation, annotation, cancellationToken).ConfigureAwait(false);
+        }
+
+        private static async Task<Document> ReplaceWithFileScopedNamespaceAsync(
+            Document document, NamespaceDeclarationSyntax namespaceDeclaration, SyntaxAnnotation annotation, CancellationToken cancellationToken)
         {
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-            return document.WithSyntaxRoot(root.ReplaceNode(baseNamespace, Convert(baseNamespace)));
+            var converted = ConvertNamespaceDeclaration(namespaceDeclaration);
+            var updatedRoot = root.ReplaceNode(
+                namespaceDeclaration,
+                converted.WithAdditionalAnnotations(annotation));
+            return document.WithSyntaxRoot(updatedRoot);
+        }
+
+        private static async Task<string?> GetIndentationAsync(Document document, NamespaceDeclarationSyntax namespaceDeclaration, CancellationToken cancellationToken)
+        {
+            var indentationService = document.GetRequiredLanguageService<IIndentationService>();
+            var sourceText = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
+
+            var openBraceLine = sourceText.Lines.GetLineFromPosition(namespaceDeclaration.OpenBraceToken.SpanStart).LineNumber;
+            var closeBraceLine = sourceText.Lines.GetLineFromPosition(namespaceDeclaration.CloseBraceToken.SpanStart).LineNumber;
+            if (openBraceLine == closeBraceLine)
+                return null;
+
+            var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
+            var style = options.GetOption(FormattingOptions.SmartIndent, document.Project.Language);
+
+            var indentation = indentationService.GetIndentation(document, openBraceLine + 1, style, cancellationToken);
+
+            var useTabs = options.GetOption(FormattingOptions.UseTabs);
+            var tabSize = options.GetOption(FormattingOptions.TabSize);
+
+            return indentation.GetIndentationString(sourceText, useTabs, tabSize);
+        }
+
+        private static async Task<Document> DedentNamespaceAsync(
+            Document document, string indentation, SyntaxAnnotation annotation, CancellationToken cancellationToken)
+        {
+            var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
+            var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var text = await root.SyntaxTree.GetTextAsync(cancellationToken).ConfigureAwait(false);
+
+            var fileScopedNamespace = (FileScopedNamespaceDeclarationSyntax)root.GetAnnotatedNodes(annotation).Single();
+            var semicolonLine = text.Lines.GetLineFromPosition(fileScopedNamespace.SemicolonToken.SpanStart).LineNumber;
+
+            using var _ = ArrayBuilder<TextChange>.GetInstance(out var changes);
+            for (var line = semicolonLine + 1; line < text.Lines.Count; line++)
+                changes.AddIfNotNull(TryDedentLine(syntaxTree, text, indentation, text.Lines[line], cancellationToken));
+
+            var dedentedText = text.WithChanges(changes);
+            return document.WithText(dedentedText);
+        }
+
+        private static TextChange? TryDedentLine(
+            SyntaxTree tree, SourceText text, string indentation, TextLine textLine, CancellationToken cancellationToken)
+        {
+            // if this line is inside a string-literal or interpolated-text-content, then we definitely do not want to
+            // touch what is inside there.  Note: this will not apply to raw-string literals, which can potentially be
+            // dedented safely depending on the position of their close terminator.
+            if (tree.IsEntirelyWithinStringLiteral(textLine.Span.Start, cancellationToken))
+                return null;
+
+            // Determine the amount of indentation this text line starts with.
+            var commonIndentation = 0;
+            while (commonIndentation < indentation.Length && commonIndentation < textLine.Span.Length)
+            {
+                if (indentation[commonIndentation] != text[textLine.Start + commonIndentation])
+                    break;
+
+                commonIndentation++;
+            }
+
+            return new TextChange(new TextSpan(textLine.Start, commonIndentation), newText: "");
+        }
+
+        private static async Task<Document> ConvertFileScopedNamespaceAsync(
+            Document document, FileScopedNamespaceDeclarationSyntax fileScopedNamespace, CancellationToken cancellationToken)
+        {
+            var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            return document.WithSyntaxRoot(root.ReplaceNode(fileScopedNamespace, ConvertFileScopedNamespace(fileScopedNamespace)));
         }
 
         public static BaseNamespaceDeclarationSyntax Convert(BaseNamespaceDeclarationSyntax baseNamespace)
         {
+
             return baseNamespace switch
             {
                 FileScopedNamespaceDeclarationSyntax fileScopedNamespace => ConvertFileScopedNamespace(fileScopedNamespace),
@@ -68,7 +172,7 @@ private static FileScopedNamespaceDeclarationSyntax ConvertNamespaceDeclaration(
         {
             // We move leading and trailing trivia on the open brace to just be trailing trivia on the semicolon, so we preserve
             // comments etc. logically at the top of the file.
-            var semiColon = SyntaxFactory.Token(SyntaxKind.SemicolonToken);
+            var semiColon = SyntaxFactory.Token(SyntaxKind.SemicolonToken).WithoutTrivia();
 
             if (namespaceDeclaration.Name.GetTrailingTrivia().Any(t => t.IsSingleOrMultiLineComment()))
             {
@@ -90,7 +194,7 @@ private static FileScopedNamespaceDeclarationSyntax ConvertNamespaceDeclaration(
                 semiColon,
                 namespaceDeclaration.Externs,
                 namespaceDeclaration.Usings,
-                namespaceDeclaration.Members).WithAdditionalAnnotations(Formatter.Annotation);
+                namespaceDeclaration.Members);
 
             // Ensure there's a blank line between the namespace line and the first body member.
             var firstBodyToken = fileScopedNamespace.SemicolonToken.GetNextToken();
@@ -99,7 +203,7 @@ private static FileScopedNamespaceDeclarationSyntax ConvertNamespaceDeclaration(
             {
                 fileScopedNamespace = fileScopedNamespace.ReplaceToken(
                     firstBodyToken,
-                    firstBodyToken.WithPrependedLeadingTrivia(SyntaxFactory.ElasticCarriageReturnLineFeed));
+                    firstBodyToken.WithPrependedLeadingTrivia(SyntaxFactory.CarriageReturnLineFeed));
             }
 
             // Copy leading trivia from the close brace to the end of the file scoped namespace (which means after all of the members)
@@ -107,7 +211,7 @@ private static FileScopedNamespaceDeclarationSyntax ConvertNamespaceDeclaration(
             {
                 // Ensure there is one blank line before the trivia
                 fileScopedNamespace = fileScopedNamespace
-                    .WithAppendedTrailingTrivia(SyntaxFactory.ElasticCarriageReturnLineFeed)
+                    .WithAppendedTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed)
                     .WithAppendedTrailingTrivia(namespaceDeclaration.CloseBraceToken.LeadingTrivia.WithoutLeadingBlankLines());
             }
 
diff --git a/src/Features/Core/Portable/Wrapping/AbstractCodeActionComputer.cs b/src/Features/Core/Portable/Wrapping/AbstractCodeActionComputer.cs
index c4bd517cb51cf..ae5877e62ff21 100644
--- a/src/Features/Core/Portable/Wrapping/AbstractCodeActionComputer.cs
+++ b/src/Features/Core/Portable/Wrapping/AbstractCodeActionComputer.cs
@@ -12,6 +12,7 @@
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Formatting;
+using Microsoft.CodeAnalysis.Indentation;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
@@ -104,13 +105,7 @@ protected string GetSmartIndentationAfter(SyntaxNodeOrToken nodeOrToken)
                     FormattingOptions.IndentStyle.Smart,
                     CancellationToken);
 
-                var baseLine = newSourceText.Lines.GetLineFromPosition(desiredIndentation.BasePosition);
-                var baseOffsetInLine = desiredIndentation.BasePosition - baseLine.Start;
-
-                var indent = baseOffsetInLine + desiredIndentation.Offset;
-
-                var indentString = indent.CreateIndentationString(UseTabs, TabSize);
-                return indentString;
+                return desiredIndentation.GetIndentationString(newSourceText, UseTabs, TabSize);
             }
 
             /// <summary>
diff --git a/src/Workspaces/Core/Portable/Indentation/IIndentationService.cs b/src/Workspaces/Core/Portable/Indentation/IIndentationService.cs
index 0de1e4a7535d2..f8b6460499ef4 100644
--- a/src/Workspaces/Core/Portable/Indentation/IIndentationService.cs
+++ b/src/Workspaces/Core/Portable/Indentation/IIndentationService.cs
@@ -5,6 +5,7 @@
 using System.Threading;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Indentation
@@ -63,4 +64,18 @@ public static IndentationResult GetIndentation(
             return service.GetIndentation(document, lineNumber, style, cancellationToken);
         }
     }
+
+    internal static class IndentationResultExtensions
+    {
+        public static string GetIndentationString(this IndentationResult indentationResult, SourceText sourceText, bool useTabs, int tabSize)
+        {
+            var baseLine = sourceText.Lines.GetLineFromPosition(indentationResult.BasePosition);
+            var baseOffsetInLine = indentationResult.BasePosition - baseLine.Start;
+
+            var indent = baseOffsetInLine + indentationResult.Offset;
+
+            var indentString = indent.CreateIndentationString(useTabs, tabSize);
+            return indentString;
+        }
+    }
 }

From 0ec375fa8a4ccfe4ee5ed0dc59c014d3a4bb3185 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Dec 2021 14:42:11 -0800
Subject: [PATCH 141/444] Further work

---
 .../ConvertNamespace/ConvertNamespaceCodeFixProvider.cs  | 9 +++++----
 .../ConvertNamespace/ConvertNamespaceTransform.cs        | 1 -
 .../ConvertNamespace/ConvertNamespaceRefactoringTests.cs | 8 ++++----
 .../Indentation/AbstractIndentationService.Indenter.cs   | 2 +-
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceCodeFixProvider.cs
index f0777a097d2c4..23f3c9dd11369 100644
--- a/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceCodeFixProvider.cs
@@ -55,17 +55,18 @@ public override Task RegisterCodeFixesAsync(CodeFixContext context)
             return Task.CompletedTask;
         }
 
-        protected override Task FixAllAsync(
+        protected override async Task FixAllAsync(
             Document document, ImmutableArray<Diagnostic> diagnostics,
             SyntaxEditor editor, CancellationToken cancellationToken)
         {
             var diagnostic = diagnostics.First();
 
             var namespaceDecl = (BaseNamespaceDeclarationSyntax)diagnostic.AdditionalLocations[0].FindNode(cancellationToken);
-            var converted = Convert(namespaceDecl);
+            var converted = await ConvertAsync(document, namespaceDecl, cancellationToken).ConfigureAwait(false);
 
-            editor.ReplaceNode(namespaceDecl, converted);
-            return Task.CompletedTask;
+            editor.ReplaceNode(
+                editor.OriginalRoot,
+                await converted.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false));
         }
 
         private class MyCodeAction : CustomCodeActions.DocumentChangeAction
diff --git a/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs b/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs
index 51262b097164e..a55ccaea2c3a5 100644
--- a/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs
+++ b/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs
@@ -138,7 +138,6 @@ private static async Task<Document> ConvertFileScopedNamespaceAsync(
 
         public static BaseNamespaceDeclarationSyntax Convert(BaseNamespaceDeclarationSyntax baseNamespace)
         {
-
             return baseNamespace switch
             {
                 FileScopedNamespaceDeclarationSyntax fileScopedNamespace => ConvertFileScopedNamespace(fileScopedNamespace),
diff --git a/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertNamespaceRefactoringTests.cs b/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertNamespaceRefactoringTests.cs
index feae3626badc2..dd270fb20db51 100644
--- a/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertNamespaceRefactoringTests.cs
+++ b/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertNamespaceRefactoringTests.cs
@@ -478,9 +478,9 @@ public async Task TextConvertToFileScopedWithCommentedOutContents()
                 FixedCode = @"
 namespace N;
 
-    // public class C
-    // {
-    // }
+// public class C
+// {
+// }
 ",
                 LanguageVersion = LanguageVersion.CSharp10,
                 Options =
@@ -513,7 +513,7 @@ public class C
 {
 }
 
-    // I'll probably write some more code here later
+// I'll probably write some more code here later
 ",
                 LanguageVersion = LanguageVersion.CSharp10,
                 Options =
diff --git a/src/Workspaces/Core/Portable/Indentation/AbstractIndentationService.Indenter.cs b/src/Workspaces/Core/Portable/Indentation/AbstractIndentationService.Indenter.cs
index e98912c2a2f39..796e7905ca082 100644
--- a/src/Workspaces/Core/Portable/Indentation/AbstractIndentationService.Indenter.cs
+++ b/src/Workspaces/Core/Portable/Indentation/AbstractIndentationService.Indenter.cs
@@ -171,7 +171,7 @@ public bool TryGetSmartTokenIndentation(out IndentationResult indentationResult)
 
                     var formatter = _service.CreateSmartTokenFormatter(this);
                     var changes = formatter.FormatTokenAsync(Document.Project.Solution.Workspace, token, CancellationToken)
-                                           .WaitAndGetResult(CancellationToken);
+                                           .WaitAndGetResult_CanCallOnBackground(CancellationToken);
 
                     var updatedSourceText = sourceText.WithChanges(changes);
                     if (LineToBeIndented.LineNumber < updatedSourceText.Lines.Count)

From a8553a0ec6536dbf71b7a6467fb48cd1af6e6dcb Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Dec 2021 15:25:26 -0800
Subject: [PATCH 142/444] Before trivia moving

---
 .../ConvertNamespaceTransform.cs              | 37 ++++++++-----
 .../ConvertNamespaceCommandHandler.cs         | 54 +++++++------------
 ...eclarationNewDocumentFormattingProvider.cs |  7 ++-
 3 files changed, 47 insertions(+), 51 deletions(-)

diff --git a/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs b/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs
index a55ccaea2c3a5..ad5c2539be7dc 100644
--- a/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs
+++ b/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs
@@ -31,15 +31,23 @@ namespace Microsoft.CodeAnalysis.CSharp.ConvertNamespace
 {
     internal static class ConvertNamespaceTransform
     {
-        public static Task<Document> ConvertAsync(Document document, BaseNamespaceDeclarationSyntax baseNamespace, CancellationToken cancellationToken)
-            => baseNamespace switch
+        public static async Task<Document> ConvertAsync(Document document, BaseNamespaceDeclarationSyntax baseNamespace, CancellationToken cancellationToken)
+        {
+            switch (baseNamespace)
             {
-                FileScopedNamespaceDeclarationSyntax fileScopedNamespace => ConvertFileScopedNamespaceAsync(document, fileScopedNamespace, cancellationToken),
-                NamespaceDeclarationSyntax namespaceDeclaration => ConvertNamespaceDeclarationAsync(document, namespaceDeclaration, cancellationToken),
-                _ => throw ExceptionUtilities.UnexpectedValue(baseNamespace.Kind()),
+                case FileScopedNamespaceDeclarationSyntax fileScopedNamespace:
+                    return await ConvertFileScopedNamespaceAsync(document, fileScopedNamespace, cancellationToken).ConfigureAwait(false);
+
+                case NamespaceDeclarationSyntax namespaceDeclaration:
+                    var (doc, _) = await ConvertNamespaceDeclarationAsync(document, namespaceDeclaration, cancellationToken).ConfigureAwait(false);
+                    return doc;
+
+                default:
+                    throw ExceptionUtilities.UnexpectedValue(baseNamespace.Kind());
             };
+        }
 
-        private static async Task<Document> ConvertNamespaceDeclarationAsync(Document document, NamespaceDeclarationSyntax namespaceDeclaration, CancellationToken cancellationToken)
+        public static async Task<(Document document, TextSpan semicolonSpan)> ConvertNamespaceDeclarationAsync(Document document, NamespaceDeclarationSyntax namespaceDeclaration, CancellationToken cancellationToken)
         {
             // First, determine how much indentation we had inside the original block namespace. We'll attempt to remove
             // that much indentation from each applicable line after we conver the block namespace to a file scoped
@@ -48,16 +56,16 @@ private static async Task<Document> ConvertNamespaceDeclarationAsync(Document do
 
             // Next, actually replace the block namespace with the file scoped namespace.
             var annotation = new SyntaxAnnotation();
-            document = await ReplaceWithFileScopedNamespaceAsync(document, namespaceDeclaration, annotation, cancellationToken).ConfigureAwait(false);
+            var (updatedDocument, semicolonSpan) = await ReplaceWithFileScopedNamespaceAsync(document, namespaceDeclaration, annotation, cancellationToken).ConfigureAwait(false);
 
             // Now, find the file scoped namespace in the updated doc and go and dedent every line if applicable.
             if (indentation == null)
-                return document;
+                return (updatedDocument, semicolonSpan);
 
-            return await DedentNamespaceAsync(document, indentation, annotation, cancellationToken).ConfigureAwait(false);
+            return await DedentNamespaceAsync(updatedDocument, indentation, annotation, cancellationToken).ConfigureAwait(false);
         }
 
-        private static async Task<Document> ReplaceWithFileScopedNamespaceAsync(
+        private static async Task<(Document document, TextSpan semicolonSpan)> ReplaceWithFileScopedNamespaceAsync(
             Document document, NamespaceDeclarationSyntax namespaceDeclaration, SyntaxAnnotation annotation, CancellationToken cancellationToken)
         {
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
@@ -65,7 +73,8 @@ private static async Task<Document> ReplaceWithFileScopedNamespaceAsync(
             var updatedRoot = root.ReplaceNode(
                 namespaceDeclaration,
                 converted.WithAdditionalAnnotations(annotation));
-            return document.WithSyntaxRoot(updatedRoot);
+            var fileScopedNamespace = (FileScopedNamespaceDeclarationSyntax)updatedRoot.GetAnnotatedNodes(annotation).Single();
+            return (document.WithSyntaxRoot(updatedRoot), fileScopedNamespace.SemicolonToken.Span);
         }
 
         private static async Task<string?> GetIndentationAsync(Document document, NamespaceDeclarationSyntax namespaceDeclaration, CancellationToken cancellationToken)
@@ -89,7 +98,7 @@ private static async Task<Document> ReplaceWithFileScopedNamespaceAsync(
             return indentation.GetIndentationString(sourceText, useTabs, tabSize);
         }
 
-        private static async Task<Document> DedentNamespaceAsync(
+        private static async Task<(Document document, TextSpan semicolonSpan)> DedentNamespaceAsync(
             Document document, string indentation, SyntaxAnnotation annotation, CancellationToken cancellationToken)
         {
             var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
@@ -104,7 +113,7 @@ private static async Task<Document> DedentNamespaceAsync(
                 changes.AddIfNotNull(TryDedentLine(syntaxTree, text, indentation, text.Lines[line], cancellationToken));
 
             var dedentedText = text.WithChanges(changes);
-            return document.WithText(dedentedText);
+            return (document.WithText(dedentedText), fileScopedNamespace.SemicolonToken.Span);
         }
 
         private static TextChange? TryDedentLine(
@@ -136,7 +145,7 @@ private static async Task<Document> ConvertFileScopedNamespaceAsync(
             return document.WithSyntaxRoot(root.ReplaceNode(fileScopedNamespace, ConvertFileScopedNamespace(fileScopedNamespace)));
         }
 
-        public static BaseNamespaceDeclarationSyntax Convert(BaseNamespaceDeclarationSyntax baseNamespace)
+        private static BaseNamespaceDeclarationSyntax Convert(BaseNamespaceDeclarationSyntax baseNamespace)
         {
             return baseNamespace switch
             {
diff --git a/src/EditorFeatures/CSharp/ConvertNamespace/ConvertNamespaceCommandHandler.cs b/src/EditorFeatures/CSharp/ConvertNamespace/ConvertNamespaceCommandHandler.cs
index f18338c3709f3..3b0cba7fa8cf0 100644
--- a/src/EditorFeatures/CSharp/ConvertNamespace/ConvertNamespaceCommandHandler.cs
+++ b/src/EditorFeatures/CSharp/ConvertNamespace/ConvertNamespaceCommandHandler.cs
@@ -26,6 +26,7 @@
 using Microsoft.VisualStudio.Text.Editor.Commanding.Commands;
 using Microsoft.VisualStudio.Text.Operations;
 using Microsoft.VisualStudio.Utilities;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.CompleteStatement
 {
@@ -39,11 +40,6 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.CompleteStatement
     [Order(After = PredefinedCompletionNames.CompletionCommandHandler)]
     internal sealed class ConvertNamespaceCommandHandler : IChainedCommandHandler<TypeCharCommandArgs>
     {
-        /// <summary>
-        /// Annotation used so we can find the semicolon after formatting so that we can properly place the caret.
-        /// </summary>
-        private static readonly SyntaxAnnotation s_annotation = new();
-
         /// <summary>
         /// A fake option set where the 'use file scoped' namespace option is on.  That way we can call into the helpers
         /// and have the results come back positive for converting to file-scoped regardless of the current option
@@ -79,7 +75,7 @@ public CommandState GetCommandState(TypeCharCommandArgs args, Func<CommandState>
         public void ExecuteCommand(TypeCharCommandArgs args, Action nextCommandHandler, CommandExecutionContext executionContext)
         {
             // Attempt to convert the block-namespace to a file-scoped namespace if we're at the right location.
-            var convertedRoot = ConvertNamespace(args, executionContext);
+            var (convertedText, semicolonSpan) = ConvertNamespace(args, executionContext);
 
             // No matter if we succeeded or not, insert the semicolon.  This way, when we convert, the user can still
             // hit ctrl-z to get back to the code with just the semicolon inserted.
@@ -87,7 +83,7 @@ public void ExecuteCommand(TypeCharCommandArgs args, Action nextCommandHandler,
 
             // If we weren't on a block namespace (or couldn't convert it for some reason), then bail out after
             // inserting the semicolon.
-            if (convertedRoot == null)
+            if (convertedText == null)
                 return;
 
             // Otherwise, make a transaction for the edit and replace the buffer with the final text.
@@ -95,14 +91,12 @@ public void ExecuteCommand(TypeCharCommandArgs args, Action nextCommandHandler,
                 this.DisplayName, args.TextView, _textUndoHistoryRegistry, _editorOperationsFactoryService);
 
             var edit = args.SubjectBuffer.CreateEdit(EditOptions.DefaultMinimalChange, reiteratedVersionNumber: null, editTag: null);
-            edit.Replace(new Span(0, args.SubjectBuffer.CurrentSnapshot.Length), convertedRoot.ToFullString());
+            edit.Replace(new Span(0, args.SubjectBuffer.CurrentSnapshot.Length), convertedText.ToString());
 
             edit.Apply();
 
-            // Attempt to place the caret right after the semicolon of the file-scoped namespace.
-            var annotatedToken = convertedRoot.GetAnnotatedTokens(s_annotation).FirstOrDefault();
-            if (annotatedToken != default)
-                args.TextView.Caret.MoveTo(new SnapshotPoint(args.SubjectBuffer.CurrentSnapshot, annotatedToken.Span.End));
+            // Place the caret right after the semicolon of the file-scoped namespace.
+            args.TextView.Caret.MoveTo(new SnapshotPoint(args.SubjectBuffer.CurrentSnapshot, semicolonSpan.End));
 
             transaction?.Complete();
         }
@@ -111,25 +105,25 @@ public void ExecuteCommand(TypeCharCommandArgs args, Action nextCommandHandler,
         /// Returns the updated file contents if semicolon is typed after a block-scoped namespace name that can be
         /// converted.
         /// </summary>
-        private CompilationUnitSyntax? ConvertNamespace(
+        private (SourceText? convertedText, TextSpan semicolonSpan) ConvertNamespace(
             TypeCharCommandArgs args,
             CommandExecutionContext executionContext)
         {
             if (args.TypedChar != ';' || !args.TextView.Selection.IsEmpty)
-                return null;
+                return default;
 
             if (!_globalOptions.GetOption(FeatureOnOffOptions.AutomaticallyCompleteStatementOnSemicolon))
-                return null;
+                return default;
 
             var subjectBuffer = args.SubjectBuffer;
             var caretOpt = args.TextView.GetCaretPoint(subjectBuffer);
             if (!caretOpt.HasValue)
-                return null;
+                return default;
 
             var caret = caretOpt.Value.Position;
             var document = subjectBuffer.CurrentSnapshot.GetOpenDocumentInCurrentContextWithChanges();
             if (document == null)
-                return null;
+                return default;
 
             var cancellationToken = executionContext.OperationContext.UserCancellationToken;
             var root = (CompilationUnitSyntax)document.GetRequiredSyntaxRootSynchronously(cancellationToken);
@@ -137,39 +131,29 @@ public void ExecuteCommand(TypeCharCommandArgs args, Action nextCommandHandler,
             // User has to be *after* an identifier token.
             var token = root.FindToken(caret);
             if (token.Kind() != SyntaxKind.IdentifierToken)
-                return null;
+                return default;
 
             if (caret < token.Span.End ||
                 caret >= token.FullSpan.End)
             {
-                return null;
+                return default;
             }
 
             var namespaceDecl = token.GetRequiredParent().GetAncestor<NamespaceDeclarationSyntax>();
             if (namespaceDecl == null)
-                return null;
+                return default;
 
             // That identifier token has to be the last part of a namespace name.
             if (namespaceDecl.Name.GetLastToken() != token)
-                return null;
+                return default;
 
             // Pass in our special options, and C#10 so that if we can convert this to file-scoped, we will.
             if (!ConvertNamespaceAnalysis.CanOfferUseFileScoped(s_optionSet, root, namespaceDecl, forAnalyzer: true, LanguageVersion.CSharp10))
-                return null;
-
-            var fileScopedNamespace = (FileScopedNamespaceDeclarationSyntax)ConvertNamespaceTransform.Convert(namespaceDecl);
-
-            // Place an annotation on the semicolon so that we can find it post-formatting to place the caret.
-            fileScopedNamespace = fileScopedNamespace.WithSemicolonToken(
-                fileScopedNamespace.SemicolonToken.WithAdditionalAnnotations(s_annotation));
-
-            var convertedRoot = root.ReplaceNode(namespaceDecl, fileScopedNamespace);
-            var formattedRoot = (CompilationUnitSyntax)Formatter.Format(
-                convertedRoot, Formatter.Annotation,
-                document.Project.Solution.Workspace,
-                options: null, rules: null, cancellationToken);
+                return default;
 
-            return formattedRoot;
+            var (converted, semicolonSpan) = ConvertNamespaceTransform.ConvertNamespaceDeclarationAsync(document, namespaceDecl, cancellationToken).WaitAndGetResult(cancellationToken);
+            var text = converted.GetTextSynchronously(cancellationToken);
+            return (text, semicolonSpan);
         }
     }
 }
diff --git a/src/Features/CSharp/Portable/Formatting/CSharpNamespaceDeclarationNewDocumentFormattingProvider.cs b/src/Features/CSharp/Portable/Formatting/CSharpNamespaceDeclarationNewDocumentFormattingProvider.cs
index 8350fb94e6d1f..d2d8d33740221 100644
--- a/src/Features/CSharp/Portable/Formatting/CSharpNamespaceDeclarationNewDocumentFormattingProvider.cs
+++ b/src/Features/CSharp/Portable/Formatting/CSharpNamespaceDeclarationNewDocumentFormattingProvider.cs
@@ -32,8 +32,11 @@ public async Task<Document> FormatNewDocumentAsync(Document document, Document?
             var optionSet = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
             var root = (CompilationUnitSyntax)await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
-            var namespaces = GetNamespacesToReplace(document, root, optionSet);
-            return await document.ReplaceNodesAsync(namespaces, (oldNode, newNode) => ConvertNamespaceTransform.Convert((BaseNamespaceDeclarationSyntax)newNode), cancellationToken).ConfigureAwait(false);
+            var namespaces = GetNamespacesToReplace(document, root, optionSet).ToList();
+            if (namespaces.Count != 1)
+                return document;
+
+            return await ConvertNamespaceTransform.ConvertAsync(document, namespaces[0], cancellationToken).ConfigureAwait(false);
         }
 
         private static IEnumerable<BaseNamespaceDeclarationSyntax> GetNamespacesToReplace(Document document, CompilationUnitSyntax root, DocumentOptionSet optionSet)

From 7fe6edd3281fed836fe2f5df28be7449b97750b1 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Dec 2021 15:38:29 -0800
Subject: [PATCH 143/444] Update formatting

---
 .../ConvertNamespaceTransform.cs              | 49 ++++++-------------
 .../ConvertNamespaceCommandHandlerTests.cs    |  2 +-
 .../ConvertNamespaceRefactoringTests.cs       |  5 +-
 ...nvertToFileScopedNamespaceAnalyzerTests.cs |  4 +-
 4 files changed, 21 insertions(+), 39 deletions(-)

diff --git a/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs b/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs
index ad5c2539be7dc..b4f5cda640536 100644
--- a/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs
+++ b/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs
@@ -145,16 +145,6 @@ private static async Task<Document> ConvertFileScopedNamespaceAsync(
             return document.WithSyntaxRoot(root.ReplaceNode(fileScopedNamespace, ConvertFileScopedNamespace(fileScopedNamespace)));
         }
 
-        private static BaseNamespaceDeclarationSyntax Convert(BaseNamespaceDeclarationSyntax baseNamespace)
-        {
-            return baseNamespace switch
-            {
-                FileScopedNamespaceDeclarationSyntax fileScopedNamespace => ConvertFileScopedNamespace(fileScopedNamespace),
-                NamespaceDeclarationSyntax namespaceDeclaration => ConvertNamespaceDeclaration(namespaceDeclaration),
-                _ => throw ExceptionUtilities.UnexpectedValue(baseNamespace.Kind()),
-            };
-        }
-
         private static bool HasLeadingBlankLine(
             SyntaxToken token, out SyntaxToken withoutBlankLine)
         {
@@ -178,37 +168,35 @@ private static bool HasLeadingBlankLine(
 
         private static FileScopedNamespaceDeclarationSyntax ConvertNamespaceDeclaration(NamespaceDeclarationSyntax namespaceDeclaration)
         {
-            // We move leading and trailing trivia on the open brace to just be trailing trivia on the semicolon, so we preserve
-            // comments etc. logically at the top of the file.
             var semiColon = SyntaxFactory.Token(SyntaxKind.SemicolonToken).WithoutTrivia();
 
-            if (namespaceDeclaration.Name.GetTrailingTrivia().Any(t => t.IsSingleOrMultiLineComment()))
-            {
-                semiColon = semiColon.WithTrailingTrivia(namespaceDeclaration.Name.GetTrailingTrivia())
-                                     .WithAppendedTrailingTrivia(namespaceDeclaration.OpenBraceToken.LeadingTrivia);
-            }
-            else
-            {
-                semiColon = semiColon.WithTrailingTrivia(namespaceDeclaration.OpenBraceToken.LeadingTrivia);
-            }
-
-            semiColon = semiColon.WithAppendedTrailingTrivia(namespaceDeclaration.OpenBraceToken.TrailingTrivia);
-
+            // Move trivia after the original name token to now be after the new semicolon token.
             var fileScopedNamespace = SyntaxFactory.FileScopedNamespaceDeclaration(
                 namespaceDeclaration.AttributeLists,
                 namespaceDeclaration.Modifiers,
                 namespaceDeclaration.NamespaceKeyword,
                 namespaceDeclaration.Name.WithoutTrailingTrivia(),
-                semiColon,
+                semiColon.WithTrailingTrivia(namespaceDeclaration.Name.GetTrailingTrivia()),
                 namespaceDeclaration.Externs,
                 namespaceDeclaration.Usings,
                 namespaceDeclaration.Members);
 
-            // Ensure there's a blank line between the namespace line and the first body member.
             var firstBodyToken = fileScopedNamespace.SemicolonToken.GetNextToken();
-            if (firstBodyToken.Kind() != SyntaxKind.EndOfFileToken &&
+
+            // If the open-brace token has any special trivia, then move them to before the first member in the namespace.
+            if (namespaceDeclaration.OpenBraceToken.LeadingTrivia.Any(t => t.IsSingleOrMultiLineComment() || t.IsDirective) ||
+                namespaceDeclaration.OpenBraceToken.TrailingTrivia.Any(t => t.IsSingleOrMultiLineComment() || t.IsDirective))
+            {
+                fileScopedNamespace = fileScopedNamespace.ReplaceToken(
+                    firstBodyToken,
+                    firstBodyToken.WithPrependedLeadingTrivia(namespaceDeclaration.OpenBraceToken.GetAllTrivia()));
+
+            }
+            else if (firstBodyToken.Kind() != SyntaxKind.EndOfFileToken &&
                 !HasLeadingBlankLine(firstBodyToken, out _))
             {
+                // Otherwise, ensure there's a blank line between the namespace line and the first body member.
+
                 fileScopedNamespace = fileScopedNamespace.ReplaceToken(
                     firstBodyToken,
                     firstBodyToken.WithPrependedLeadingTrivia(SyntaxFactory.CarriageReturnLineFeed));
@@ -216,12 +204,7 @@ private static FileScopedNamespaceDeclarationSyntax ConvertNamespaceDeclaration(
 
             // Copy leading trivia from the close brace to the end of the file scoped namespace (which means after all of the members)
             if (namespaceDeclaration.CloseBraceToken.HasLeadingTrivia)
-            {
-                // Ensure there is one blank line before the trivia
-                fileScopedNamespace = fileScopedNamespace
-                    .WithAppendedTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed)
-                    .WithAppendedTrailingTrivia(namespaceDeclaration.CloseBraceToken.LeadingTrivia.WithoutLeadingBlankLines());
-            }
+                fileScopedNamespace = fileScopedNamespace.WithAppendedTrailingTrivia(namespaceDeclaration.CloseBraceToken.LeadingTrivia);
 
             return fileScopedNamespace;
         }
diff --git a/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertNamespaceCommandHandlerTests.cs b/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertNamespaceCommandHandlerTests.cs
index 738bbb1a11c82..1b64a0d0d23ed 100644
--- a/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertNamespaceCommandHandlerTests.cs
+++ b/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertNamespaceCommandHandlerTests.cs
@@ -193,7 +193,7 @@ class C
 
             testState.SendTypeChar(';');
             testState.AssertCodeIs(
-@"namespace A.B;
+@"namespace A.B;  
 
 class C
 {
diff --git a/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertNamespaceRefactoringTests.cs b/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertNamespaceRefactoringTests.cs
index dd270fb20db51..a9b442fcb4125 100644
--- a/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertNamespaceRefactoringTests.cs
+++ b/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertNamespaceRefactoringTests.cs
@@ -417,8 +417,8 @@ class C
 }
 ",
                 FixedCode = @"
-namespace $$N; // comment
-
+namespace $$N;
+// comment
 class C
 {
 }
@@ -477,7 +477,6 @@ public async Task TextConvertToFileScopedWithCommentedOutContents()
 ",
                 FixedCode = @"
 namespace N;
-
 // public class C
 // {
 // }
diff --git a/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertToFileScopedNamespaceAnalyzerTests.cs b/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertToFileScopedNamespaceAnalyzerTests.cs
index 532c4c132d8b1..1d29d044b7cbd 100644
--- a/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertToFileScopedNamespaceAnalyzerTests.cs
+++ b/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertToFileScopedNamespaceAnalyzerTests.cs
@@ -347,8 +347,8 @@ class C
 }
 ",
                 FixedCode = @"
-namespace $$N; // comment
-
+namespace $$N;
+// comment
 class C
 {
 }

From 9897eb2c828348d3d4bde1aee82090d0675cc507 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Dec 2021 15:55:30 -0800
Subject: [PATCH 144/444] Update tests

---
 .../ConvertNamespaceTransform.cs              |  15 +-
 .../ConvertNamespaceCommandHandlerTests.cs    |  30 +-
 .../ConvertNamespaceRefactoringTests.cs       |   1 +
 ...nvertToFileScopedNamespaceAnalyzerTests.cs | 285 ++++++++++++++++++
 4 files changed, 311 insertions(+), 20 deletions(-)

diff --git a/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs b/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs
index b4f5cda640536..75a837fc73eb8 100644
--- a/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs
+++ b/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs
@@ -190,21 +190,24 @@ private static FileScopedNamespaceDeclarationSyntax ConvertNamespaceDeclaration(
                 fileScopedNamespace = fileScopedNamespace.ReplaceToken(
                     firstBodyToken,
                     firstBodyToken.WithPrependedLeadingTrivia(namespaceDeclaration.OpenBraceToken.GetAllTrivia()));
+                firstBodyToken = fileScopedNamespace.SemicolonToken.GetNextNonZeroWidthTokenOrEndOfFile();
 
             }
-            else if (firstBodyToken.Kind() != SyntaxKind.EndOfFileToken &&
-                !HasLeadingBlankLine(firstBodyToken, out _))
-            {
-                // Otherwise, ensure there's a blank line between the namespace line and the first body member.
 
+            // Otherwise, ensure there's a blank line between the namespace line and the first body member. Don't bother
+            // with this though if we already separated things by moving a pp directive (like a #else) from the open brace
+            // to the first token.
+            if (firstBodyToken.Kind() != SyntaxKind.EndOfFileToken &&
+                !HasLeadingBlankLine(firstBodyToken, out _) &&
+                !namespaceDeclaration.OpenBraceToken.LeadingTrivia.Any(t => t.IsDirective))
+            {
                 fileScopedNamespace = fileScopedNamespace.ReplaceToken(
                     firstBodyToken,
                     firstBodyToken.WithPrependedLeadingTrivia(SyntaxFactory.CarriageReturnLineFeed));
             }
 
             // Copy leading trivia from the close brace to the end of the file scoped namespace (which means after all of the members)
-            if (namespaceDeclaration.CloseBraceToken.HasLeadingTrivia)
-                fileScopedNamespace = fileScopedNamespace.WithAppendedTrailingTrivia(namespaceDeclaration.CloseBraceToken.LeadingTrivia);
+            fileScopedNamespace = fileScopedNamespace.WithAppendedTrailingTrivia(namespaceDeclaration.CloseBraceToken.LeadingTrivia);
 
             return fileScopedNamespace;
         }
diff --git a/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertNamespaceCommandHandlerTests.cs b/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertNamespaceCommandHandlerTests.cs
index 1b64a0d0d23ed..42e05bdf1de6d 100644
--- a/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertNamespaceCommandHandlerTests.cs
+++ b/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertNamespaceCommandHandlerTests.cs
@@ -44,7 +44,9 @@ public static XElement GetWorkspaceXml(string markup)
 
             internal void AssertCodeIs(string expectedCode)
             {
-                Assert.Equal(expectedCode, TextView.TextSnapshot.GetText());
+                MarkupTestFile.GetPosition(expectedCode, out var massaged, out int caretPosition);
+                Assert.Equal(massaged, TextView.TextSnapshot.GetText());
+                Assert.Equal(caretPosition, TextView.Caret.Position.BufferPosition.Position);
             }
 
             public void SendTypeChar(char ch)
@@ -64,7 +66,7 @@ class C
 
             testState.SendTypeChar(';');
             testState.AssertCodeIs(
-@"namespace N;
+@"namespace N;$$
 
 class C
 {
@@ -88,7 +90,7 @@ class C
 
             testState.SendTypeChar(';');
             testState.AssertCodeIs(
-@"namespace N;
+@"namespace N;$$
 {
     class C
     {
@@ -109,7 +111,7 @@ class C
 
             testState.SendTypeChar(';');
             testState.AssertCodeIs(
-@"namespace A.B;
+@"namespace A.B;$$
 
 class C
 {
@@ -130,7 +132,7 @@ class C
 
             testState.SendTypeChar(';');
             testState.AssertCodeIs(
-@"namespace A.;B
+@"namespace A.;$$B
 {
     class C
     {
@@ -151,7 +153,7 @@ class C
 
             testState.SendTypeChar(';');
             testState.AssertCodeIs(
-@"namespace A;.B
+@"namespace A;$$.B
 {
     class C
     {
@@ -172,7 +174,7 @@ class C
 
             testState.SendTypeChar(';');
             testState.AssertCodeIs(
-@"namespace ;A.B
+@"namespace ;$$A.B
 {
     class C
     {
@@ -193,7 +195,7 @@ class C
 
             testState.SendTypeChar(';');
             testState.AssertCodeIs(
-@"namespace A.B;  
+@"namespace A.B;$$  
 
 class C
 {
@@ -214,7 +216,7 @@ class C
 
             testState.SendTypeChar(';');
             testState.AssertCodeIs(
-@"namespace ;N
+@"namespace ;$$N
 {
     class C
     {
@@ -238,7 +240,7 @@ class C
 
             testState.SendTypeChar(';');
             testState.AssertCodeIs(
-@"namespace N;
+@"namespace N;$$
 {
     namespace N2
     {
@@ -266,7 +268,7 @@ class C
 
             testState.SendTypeChar(';');
             testState.AssertCodeIs(
-@"namespace N;
+@"namespace N;$$
 {
 }
 
@@ -299,7 +301,7 @@ class C
 using A;
 using B;
 
-namespace N;
+namespace N;$$
 
 class C
 {
@@ -325,7 +327,7 @@ class C
             testState.SendTypeChar(';');
             testState.AssertCodeIs(
 @"
-namespace N;
+namespace N;$$
 
 using A;
 using B;
@@ -349,7 +351,7 @@ class C
 
             testState.SendTypeChar(';');
             testState.AssertCodeIs(
-@"namespace N; // Goo
+@"namespace N;$$ // Goo
 
 class C
 {
diff --git a/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertNamespaceRefactoringTests.cs b/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertNamespaceRefactoringTests.cs
index a9b442fcb4125..45f83851ce2c2 100644
--- a/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertNamespaceRefactoringTests.cs
+++ b/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertNamespaceRefactoringTests.cs
@@ -418,6 +418,7 @@ class C
 ",
                 FixedCode = @"
 namespace $$N;
+
 // comment
 class C
 {
diff --git a/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertToFileScopedNamespaceAnalyzerTests.cs b/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertToFileScopedNamespaceAnalyzerTests.cs
index 1d29d044b7cbd..9af05a7576de7 100644
--- a/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertToFileScopedNamespaceAnalyzerTests.cs
+++ b/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertToFileScopedNamespaceAnalyzerTests.cs
@@ -348,6 +348,7 @@ class C
 ",
                 FixedCode = @"
 namespace $$N;
+
 // comment
 class C
 {
@@ -391,6 +392,290 @@ class C
             }.RunAsync();
         }
 
+        [Fact]
+        public async Task TestConvertToFileScopedWithDocComment()
+        {
+            await new VerifyCS.Test
+            {
+                TestCode = @"
+[|namespace N|]
+{
+    /// <summary/>
+    class C
+    {
+    }
+}
+",
+                FixedCode = @"
+namespace $$N;
+
+/// <summary/>
+class C
+{
+}
+",
+                LanguageVersion = LanguageVersion.CSharp10,
+                Options =
+                {
+                    { CSharpCodeStyleOptions.NamespaceDeclarations, NamespaceDeclarationPreference.FileScoped }
+                }
+            }.RunAsync();
+        }
+
+        [Fact]
+        public async Task TestConvertToFileScopedWithPPDirective1()
+        {
+            await new VerifyCS.Test
+            {
+                TestCode = @"
+[|namespace N|]
+{
+#if X
+    class C
+    {
+    }
+#else
+    class C
+    {
+    }
+#endif
+}
+",
+                FixedCode = @"
+namespace $$N;
+
+#if X
+class C
+{
+}
+#else
+class C
+{
+}
+#endif
+",
+                LanguageVersion = LanguageVersion.CSharp10,
+                Options =
+                {
+                    { CSharpCodeStyleOptions.NamespaceDeclarations, NamespaceDeclarationPreference.FileScoped }
+                }
+            }.RunAsync();
+        }
+
+        [Fact]
+        public async Task TestConvertToFileScopedWithBlockComment()
+        {
+            await new VerifyCS.Test
+            {
+                TestCode = @"
+[|namespace N|]
+{
+    /* x
+     * x
+     */
+    class C
+    {
+    }
+}
+",
+                FixedCode = @"
+namespace $$N;
+
+/* x
+ * x
+ */
+class C
+{
+}
+",
+                LanguageVersion = LanguageVersion.CSharp10,
+                Options =
+                {
+                    { CSharpCodeStyleOptions.NamespaceDeclarations, NamespaceDeclarationPreference.FileScoped }
+                }
+            }.RunAsync();
+        }
+
+        [Fact]
+        public async Task TestConvertToFileScopedWithBlockComment2()
+        {
+            await new VerifyCS.Test
+            {
+                TestCode = @"
+[|namespace N|]
+{
+    /* x
+       x
+     */
+    class C
+    {
+    }
+}
+",
+                FixedCode = @"
+namespace $$N;
+
+/* x
+   x
+ */
+class C
+{
+}
+",
+                LanguageVersion = LanguageVersion.CSharp10,
+                Options =
+                {
+                    { CSharpCodeStyleOptions.NamespaceDeclarations, NamespaceDeclarationPreference.FileScoped }
+                }
+            }.RunAsync();
+        }
+
+        [Fact]
+        public async Task TestConvertToFileScopedWithMultilineString()
+        {
+            await new VerifyCS.Test
+            {
+                TestCode = @"
+[|namespace N|]
+{
+    class C
+    {
+        void M()
+        {
+            System.Console.WriteLine(@""
+    a
+        b
+            c
+                d
+                    e
+                        "");
+        }
+    }
+}
+",
+                FixedCode = @"
+namespace $$N;
+
+class C
+{
+    void M()
+    {
+        System.Console.WriteLine(@""
+    a
+        b
+            c
+                d
+                    e
+                        "");
+    }
+}
+",
+                LanguageVersion = LanguageVersion.CSharp10,
+                Options =
+                {
+                    { CSharpCodeStyleOptions.NamespaceDeclarations, NamespaceDeclarationPreference.FileScoped }
+                }
+            }.RunAsync();
+        }
+
+        [Fact]
+        public async Task TestConvertToFileScopedWithMultilineString2()
+        {
+            await new VerifyCS.Test
+            {
+                TestCode = @"
+[|namespace N|]
+{
+    class C
+    {
+        void M()
+        {
+            System.Console.WriteLine($@""
+    a
+        b
+            c{1 + 1}
+                d
+                    e
+                        "");
+        }
+    }
+}
+",
+                FixedCode = @"
+namespace $$N;
+
+class C
+{
+    void M()
+    {
+        System.Console.WriteLine($@""
+    a
+        b
+            c{1 + 1}
+                d
+                    e
+                        "");
+    }
+}
+",
+                LanguageVersion = LanguageVersion.CSharp10,
+                Options =
+                {
+                    { CSharpCodeStyleOptions.NamespaceDeclarations, NamespaceDeclarationPreference.FileScoped }
+                }
+            }.RunAsync();
+        }
+
+        [Fact]
+        public async Task TestConvertToFileScopedWithMultilineString3()
+        {
+            await new VerifyCS.Test
+            {
+                TestCode = @"
+[|namespace N|]
+{
+    class C
+    {
+        void M()
+        {
+            System.Console.WriteLine($@""
+    a
+        b
+            c{
+                1 + 1
+             }d
+                    e
+                        "");
+        }
+    }
+}
+",
+                FixedCode = @"
+namespace $$N;
+
+class C
+{
+    void M()
+    {
+        System.Console.WriteLine($@""
+    a
+        b
+            c{
+            1 + 1
+         }d
+                    e
+                        "");
+    }
+}
+",
+                LanguageVersion = LanguageVersion.CSharp10,
+                Options =
+                {
+                    { CSharpCodeStyleOptions.NamespaceDeclarations, NamespaceDeclarationPreference.FileScoped }
+                }
+            }.RunAsync();
+        }
+
         #endregion
     }
 }

From 0cc31fa29a8a633aa1ba92bbab34e86aa96ee8d8 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Dec 2021 16:03:32 -0800
Subject: [PATCH 145/444] Add tests

---
 ...nvertToFileScopedNamespaceAnalyzerTests.cs | 40 +++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertToFileScopedNamespaceAnalyzerTests.cs b/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertToFileScopedNamespaceAnalyzerTests.cs
index 9af05a7576de7..2e1d7d2ee8b01 100644
--- a/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertToFileScopedNamespaceAnalyzerTests.cs
+++ b/src/EditorFeatures/CSharpTest/ConvertNamespace/ConvertToFileScopedNamespaceAnalyzerTests.cs
@@ -676,6 +676,46 @@ void M()
             }.RunAsync();
         }
 
+        [Fact]
+        public async Task TestConvertToFileScopedSingleLineNamespace1()
+        {
+            await new VerifyCS.Test
+            {
+                TestCode = @"
+[|namespace N|] { class C { } }
+",
+                FixedCode = @"
+namespace $$N; 
+class C { } ",
+                LanguageVersion = LanguageVersion.CSharp10,
+                Options =
+                {
+                    { CSharpCodeStyleOptions.NamespaceDeclarations, NamespaceDeclarationPreference.FileScoped }
+                }
+            }.RunAsync();
+        }
+
+        [Fact]
+        public async Task TestConvertToFileScopedSingleLineNamespace2()
+        {
+            await new VerifyCS.Test
+            {
+                TestCode = @"
+[|namespace N|]
+{ class C { } }
+",
+                FixedCode = @"
+namespace $$N;
+
+class C { } ",
+                LanguageVersion = LanguageVersion.CSharp10,
+                Options =
+                {
+                    { CSharpCodeStyleOptions.NamespaceDeclarations, NamespaceDeclarationPreference.FileScoped }
+                }
+            }.RunAsync();
+        }
+
         #endregion
     }
 }

From 6b8bf3bfebd03e5936a4c7929355592ae9c8de1b Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrus.najmabadi@gmail.com>
Date: Mon, 20 Dec 2021 19:09:34 -0500
Subject: [PATCH 146/444] Update
 src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs

---
 .../CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs      | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs b/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs
index 75a837fc73eb8..b8f4dc29bfe80 100644
--- a/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs
+++ b/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs
@@ -191,7 +191,6 @@ private static FileScopedNamespaceDeclarationSyntax ConvertNamespaceDeclaration(
                     firstBodyToken,
                     firstBodyToken.WithPrependedLeadingTrivia(namespaceDeclaration.OpenBraceToken.GetAllTrivia()));
                 firstBodyToken = fileScopedNamespace.SemicolonToken.GetNextNonZeroWidthTokenOrEndOfFile();
-
             }
 
             // Otherwise, ensure there's a blank line between the namespace line and the first body member. Don't bother

From e01c2352135e06927be8bf3bcbd737251e991729 Mon Sep 17 00:00:00 2001
From: Fred Silberberg <frsilb@microsoft.com>
Date: Mon, 20 Dec 2021 17:04:43 -0800
Subject: [PATCH 147/444] Remove unused message argument (#58432)

While adjusting this code in the required-members branch I noticed the parameter is unused by the error message, so I did a small refactoring in main to clean that up.
---
 .../Source/SourceMemberContainerSymbol.cs     |  2 +-
 .../Test/Semantic/Semantics/RecordTests.cs    | 50 +++++++++----------
 2 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs
index b2d1803e41124..df51a3425bc4f 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs
@@ -453,7 +453,7 @@ internal static void ReportReservedTypeName(string? name, CSharpCompilation comp
             {
                 if (compilation.LanguageVersion >= MessageID.IDS_FeatureRecords.RequiredVersion())
                 {
-                    diagnostics.Add(ErrorCode.WRN_RecordNamedDisallowed, location, name);
+                    diagnostics.Add(ErrorCode.WRN_RecordNamedDisallowed, location);
                 }
             }
             else if (IsReservedTypeName(name))
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/RecordTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/RecordTests.cs
index 45b519df6a5bd..1e78065f9d519 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/RecordTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/RecordTests.cs
@@ -2854,7 +2854,7 @@ record M(record r) => r;
             comp.VerifyDiagnostics(
                 // (2,7): warning CS8860: Types and aliases should not be named 'record'.
                 // class record { }
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(2, 7),
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(2, 7),
                 // (6,24): error CS1514: { expected
                 //     record M(record r) => r;
                 Diagnostic(ErrorCode.ERR_LbraceExpected, "=>").WithLocation(6, 24),
@@ -2886,7 +2886,7 @@ struct record { }
             comp.VerifyDiagnostics(
                 // (2,8): warning CS8860: Types and aliases should not be named 'record'.
                 // struct record { }
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(2, 8)
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(2, 8)
                 );
         }
 
@@ -2900,7 +2900,7 @@ interface record { }
             comp.VerifyDiagnostics(
                 // (2,11): warning CS8860: Types and aliases should not be named 'record'.
                 // interface record { }
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(2, 11)
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(2, 11)
                 );
         }
 
@@ -2914,7 +2914,7 @@ enum record { }
             comp.VerifyDiagnostics(
                 // (2,6): warning CS8860: Types and aliases should not be named 'record'.
                 // enum record { }
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(2, 6)
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(2, 6)
                 );
         }
 
@@ -2928,7 +2928,7 @@ public void TypeNamedRecord_Delegate()
             comp.VerifyDiagnostics(
                 // (2,15): warning CS8860: Types and aliases should not be named 'record'.
                 // delegate void record();
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(2, 15)
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(2, 15)
                 );
         }
 
@@ -2955,7 +2955,7 @@ public void TypeNamedRecord_Alias()
                 Diagnostic(ErrorCode.HDN_UnusedUsingDirective, "using record = System.Console;").WithLocation(2, 1),
                 // (2,7): warning CS8860: Types and aliases should not be named 'record'.
                 // using record = System.Console;
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(2, 7)
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(2, 7)
                 );
         }
 
@@ -2999,16 +2999,16 @@ void local<record>() // 4
             comp.VerifyDiagnostics(
                 // (2,9): warning CS8860: Types and aliases should not be named 'record'.
                 // class C<record> { } // 1
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(2, 9),
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(2, 9),
                 // (5,18): warning CS8860: Types and aliases should not be named 'record'.
                 //     class Nested<record> { } // 2
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(5, 18),
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(5, 18),
                 // (9,17): warning CS8860: Types and aliases should not be named 'record'.
                 //     void Method<record>() { } // 3
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(9, 17),
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(9, 17),
                 // (13,20): warning CS8860: Types and aliases should not be named 'record'.
                 //         void local<record>() // 4
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(13, 20)
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(13, 20)
                 );
         }
 
@@ -3078,31 +3078,31 @@ partial void Method4<record>() { } // 9
             comp.VerifyDiagnostics(
                 // (3,17): warning CS8860: Types and aliases should not be named 'record'.
                 // partial class C<record> { } // 1
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(3, 17),
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(3, 17),
                 // (5,17): warning CS8860: Types and aliases should not be named 'record'.
                 // partial class D<record> { } // 2
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(5, 17),
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(5, 17),
                 // (8,17): warning CS8860: Types and aliases should not be named 'record'.
                 // partial class D<record> { } // 3
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(8, 17),
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(8, 17),
                 // (9,17): warning CS8860: Types and aliases should not be named 'record'.
                 // partial class D<record> { } // 4
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(9, 17),
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(9, 17),
                 // (16,26): warning CS8860: Types and aliases should not be named 'record'.
                 //     partial class Nested<record> { } // 5
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(16, 26),
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(16, 26),
                 // (22,25): warning CS8860: Types and aliases should not be named 'record'.
                 //     partial void Method<record>() { } // 6
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(22, 25),
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(22, 25),
                 // (25,26): warning CS8860: Types and aliases should not be named 'record'.
                 //     partial void Method2<record>(); // 7
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(25, 26),
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(25, 26),
                 // (27,26): warning CS8860: Types and aliases should not be named 'record'.
                 //     partial void Method3<record>(); // 8
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(27, 26),
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(27, 26),
                 // (30,26): warning CS8860: Types and aliases should not be named 'record'.
                 //     partial void Method4<record>() { } // 9
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(30, 26)
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(30, 26)
                 );
         }
 
@@ -3116,7 +3116,7 @@ record record { }
             comp.VerifyDiagnostics(
                 // (2,8): warning CS8860: Types and aliases should not be named 'record'.
                 // record record { }
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(2, 8)
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(2, 8)
                 );
         }
 
@@ -3131,10 +3131,10 @@ partial class record { }
             comp.VerifyDiagnostics(
                 // (2,15): warning CS8860: Types and aliases should not be named 'record'.
                 // partial class record { }
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(2, 15),
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(2, 15),
                 // (3,15): warning CS8860: Types and aliases should not be named 'record'.
                 // partial class record { }
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(3, 15)
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(3, 15)
                 );
         }
 
@@ -3159,7 +3159,7 @@ partial class record { }
             comp.VerifyDiagnostics(
                 // (3,15): warning CS8860: Types and aliases should not be named 'record'.
                 // partial class record { }
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(3, 15)
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(3, 15)
                 );
         }
 
@@ -3174,7 +3174,7 @@ partial class @record { }
             comp.VerifyDiagnostics(
                 // (2,15): warning CS8860: Types and aliases should not be named 'record'.
                 // partial class record { }
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(2, 15)
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(2, 15)
                 );
         }
 
@@ -3213,7 +3213,7 @@ public static void Main()
             comp.VerifyEmitDiagnostics(
                 // (2,7): warning CS8860: Types and aliases should not be named 'record'.
                 // class record { }
-                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithArguments("record").WithLocation(2, 7)
+                Diagnostic(ErrorCode.WRN_RecordNamedDisallowed, "record").WithLocation(2, 7)
                 );
             CompileAndVerify(comp, expectedOutput: "RAN");
         }

From 05f8bf139ab09c48da9911f913f4f2ae90caf236 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Mon, 20 Dec 2021 10:41:29 -0800
Subject: [PATCH 148/444] Work around incremental build failure caused by not
 touching CopyUpToDateMarker

See dotnet/msbuild#7161
---
 eng/targets/Imports.targets | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/eng/targets/Imports.targets b/eng/targets/Imports.targets
index 57c34c2b6a7e4..8be4ad28b3138 100644
--- a/eng/targets/Imports.targets
+++ b/eng/targets/Imports.targets
@@ -368,4 +368,13 @@
       <Reference Remove="@(Reference)" Condition=" '%(FileName)' == 'Microsoft.VisualBasic' or '%(FileName)' == 'Microsoft.VisualBasic.Core' " />
     </ItemGroup>
   </Target>
+
+  <!-- Workaround for https://github.com/dotnet/msbuild/issues/7161 -->
+  <Target Name="WorkaroundDotnetMsbuild7161"
+          AfterTargets="_CopyFilesMarkedCopyLocal"
+          Condition="'$(BuildingInsideVisualStudio)' == 'true' AND '@(ReferenceCopyLocalPaths)' != ''">
+    <Touch Files="@(CopyUpToDateMarker)"
+           AlwaysCreate="true"
+           Condition="'@(ReferencesCopiedInThisBuild)' != ''"/>
+  </Target>
 </Project>

From 6d4210e8b1dde3f0a1c85fefd96964597a01c389 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Dec 2021 17:38:56 -0800
Subject: [PATCH 149/444] Fix

---
 .../SolutionState.CompilationTracker.CompilationTrackerState.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs
index 679d2f109c71a..e5ccf212e9807 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs
@@ -138,7 +138,7 @@ protected CompilationTrackerState(
 
                     // As a sanity check, we should never see the generated trees inside of the compilation that should not
                     // have generated trees.
-                    var compilation = compilationWithoutGeneratedDocuments?.GetValueOrNull();
+                    var compilation = compilationWithoutGeneratedDocuments;
 
                     if (compilation != null)
                     {

From 6d52178b543a3ff71dab518493734e0f13163008 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Dec 2021 17:41:45 -0800
Subject: [PATCH 150/444] Simplify further

---
 ...lutionState.CompilationTracker.CompilationTrackerState.cs | 5 +----
 .../Workspace/Solution/SolutionState.CompilationTracker.cs   | 2 --
 2 files changed, 1 insertion(+), 6 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs
index e5ccf212e9807..9c2d1f4aabe49 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.CompilationTrackerState.cs
@@ -261,12 +261,11 @@ private sealed class FinalState : CompilationTrackerState
 
                 private FinalState(
                     Compilation finalCompilation,
-                    Compilation compilationWithoutGeneratedFilesSource,
                     Compilation compilationWithoutGeneratedFiles,
                     bool hasSuccessfullyLoaded,
                     CompilationTrackerGeneratorInfo generatorInfo,
                     UnrootedSymbolSet unrootedSymbolSet)
-                    : base(compilationWithoutGeneratedFilesSource,
+                    : base(compilationWithoutGeneratedFiles,
                            generatorInfo.WithDocumentsAreFinal(true)) // when we're in a final state, we've ran generators and should not run again
                 {
                     Contract.ThrowIfNull(finalCompilation);
@@ -287,7 +286,6 @@ private FinalState(
                 /// <param name="metadataReferenceToProjectId">Not held onto</param>
                 public static FinalState Create(
                     Compilation finalCompilationSource,
-                    Compilation compilationWithoutGeneratedFilesSource,
                     Compilation compilationWithoutGeneratedFiles,
                     bool hasSuccessfullyLoaded,
                     CompilationTrackerGeneratorInfo generatorInfo,
@@ -303,7 +301,6 @@ public static FinalState Create(
 
                     return new FinalState(
                         finalCompilationSource,
-                        compilationWithoutGeneratedFilesSource,
                         compilationWithoutGeneratedFiles,
                         hasSuccessfullyLoaded,
                         generatorInfo,
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs
index a6ea2170d53f9..6eafed98ca82b 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs
@@ -206,7 +206,6 @@ public ICompilationTracker FreezePartialStateWithTree(SolutionState solution, Do
                 // As a policy, all partial-state projects are said to have incomplete references, since the state has no guarantees.
                 var finalState = FinalState.Create(
                     finalCompilationSource: compilationPair.CompilationWithGeneratedDocuments,
-                    compilationWithoutGeneratedFilesSource: compilationPair.CompilationWithoutGeneratedDocuments,
                     compilationWithoutGeneratedFiles: compilationPair.CompilationWithoutGeneratedDocuments,
                     hasSuccessfullyLoaded: false,
                     generatorInfo,
@@ -916,7 +915,6 @@ private async Task<CompilationInfo> FinalizeCompilationAsync(
                     var finalState = FinalState.Create(
                         compilationWithGenerators,
                         compilationWithoutGenerators,
-                        compilationWithoutGenerators,
                         hasSuccessfullyLoaded,
                         generatorInfo,
                         compilationWithGenerators,

From f4d26789ea0d2ef370ed8dc20c6115d389c6f98d Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Dec 2021 18:13:28 -0800
Subject: [PATCH 151/444] ove files

---
 src/Analyzers/CSharp/CodeFixes/CSharpCodeFixes.projitems     | 5 +++--
 .../ConvertNamespace/ConvertNamespaceCodeFixProvider.cs      | 0
 .../Portable}/ConvertNamespace/ConvertNamespaceTransform.cs  | 0
 3 files changed, 3 insertions(+), 2 deletions(-)
 rename src/{Analyzers/CSharp/CodeFixes => Features/CSharp/Portable}/ConvertNamespace/ConvertNamespaceCodeFixProvider.cs (100%)
 rename src/{Analyzers/CSharp/CodeFixes => Features/CSharp/Portable}/ConvertNamespace/ConvertNamespaceTransform.cs (100%)

diff --git a/src/Analyzers/CSharp/CodeFixes/CSharpCodeFixes.projitems b/src/Analyzers/CSharp/CodeFixes/CSharpCodeFixes.projitems
index bfdd9f0689a23..c58db92c96184 100644
--- a/src/Analyzers/CSharp/CodeFixes/CSharpCodeFixes.projitems
+++ b/src/Analyzers/CSharp/CodeFixes/CSharpCodeFixes.projitems
@@ -16,8 +16,6 @@
     <Compile Include="$(MSBuildThisFileDirectory)AddAccessibilityModifiers\CSharpAddAccessibilityModifiersCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)AddAccessibilityModifiers\CSharpAddAccessibilityModifiersService.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)AddBraces\CSharpAddBracesCodeFixProvider.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)ConvertNamespace\ConvertNamespaceCodeFixProvider.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)ConvertNamespace\ConvertNamespaceTransform.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ConvertTypeOfToNameOf\CSharpConvertTypeOfToNameOfCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ConvertSwitchStatementToExpression\ConvertSwitchStatementToExpressionCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ConvertSwitchStatementToExpression\ConvertSwitchStatementToExpressionCodeFixProvider.Rewriter.cs" />
@@ -78,4 +76,7 @@
   <ItemGroup Condition="'$(DefaultLanguageSourceExtension)' != '' AND '$(BuildingInsideVisualStudio)' != 'true'">
     <ExpectedCompile Include="$(MSBuildThisFileDirectory)**\*$(DefaultLanguageSourceExtension)" />
   </ItemGroup>
+  <ItemGroup>
+    <Folder Include="$(MSBuildThisFileDirectory)ConvertNamespace\" />
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceCodeFixProvider.cs b/src/Features/CSharp/Portable/ConvertNamespace/ConvertNamespaceCodeFixProvider.cs
similarity index 100%
rename from src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceCodeFixProvider.cs
rename to src/Features/CSharp/Portable/ConvertNamespace/ConvertNamespaceCodeFixProvider.cs
diff --git a/src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs b/src/Features/CSharp/Portable/ConvertNamespace/ConvertNamespaceTransform.cs
similarity index 100%
rename from src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs
rename to src/Features/CSharp/Portable/ConvertNamespace/ConvertNamespaceTransform.cs

From f6d8885211633acef230c4e7e2b577286c7017d7 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Dec 2021 18:16:28 -0800
Subject: [PATCH 152/444] Move file

---
 .../Portable}/Formatting/FormattingOptions.IndentStyle.cs     | 4 ----
 .../Compiler/Core/CompilerExtensions.projitems                | 1 -
 2 files changed, 5 deletions(-)
 rename src/Workspaces/{SharedUtilitiesAndExtensions/Compiler/Core => Core/Portable}/Formatting/FormattingOptions.IndentStyle.cs (85%)

diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/FormattingOptions.IndentStyle.cs b/src/Workspaces/Core/Portable/Formatting/FormattingOptions.IndentStyle.cs
similarity index 85%
rename from src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/FormattingOptions.IndentStyle.cs
rename to src/Workspaces/Core/Portable/Formatting/FormattingOptions.IndentStyle.cs
index c381b219d88ae..110cf8f24dcf8 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/FormattingOptions.IndentStyle.cs
+++ b/src/Workspaces/Core/Portable/Formatting/FormattingOptions.IndentStyle.cs
@@ -4,11 +4,7 @@
 
 namespace Microsoft.CodeAnalysis.Formatting
 {
-#if CODE_STYLE
-    internal static class FormattingOptions
-#else
     public static partial class FormattingOptions
-#endif
     {
         public enum IndentStyle
         {
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems
index 896e22e8878b3..31df451a34feb 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems
@@ -300,7 +300,6 @@
     <Compile Include="$(MSBuildThisFileDirectory)Formatting\Engine\TriviaDataWithList.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Formatting\FormattingDiagnosticIds.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Formatting\FormattingExtensions.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Formatting\FormattingOptions.IndentStyle.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Formatting\FormattingOptions2.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Formatting\IFormattingResult.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Formatting\ISyntaxFormattingService.cs" />

From c064f9efdf0211bd8acdb89bec1ee2a3196d0849 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Dec 2021 18:49:41 -0800
Subject: [PATCH 153/444] Fix tests

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

diff --git a/src/Workspaces/CoreTest/SolutionTests/SolutionWithSourceGeneratorTests.cs b/src/Workspaces/CoreTest/SolutionTests/SolutionWithSourceGeneratorTests.cs
index d91bc55c6c2d5..4eb65cbf75144 100644
--- a/src/Workspaces/CoreTest/SolutionTests/SolutionWithSourceGeneratorTests.cs
+++ b/src/Workspaces/CoreTest/SolutionTests/SolutionWithSourceGeneratorTests.cs
@@ -343,7 +343,7 @@ public async Task RequestingGeneratedDocumentsTwiceGivesSameInstance()
             // finalizing a compilation more than once doesn't recreate things incorrectly or run the generator more than once.
             generatorRan = false;
             var compilationReference = ObjectReference.CreateFromFactory(() => project.GetCompilationAsync().Result);
-            compilationReference.AssertReleased();
+            compilationReference.AssertHeld();
             var secondCompilation = await project.GetRequiredCompilationAsync(CancellationToken.None);
 
             var generatedDocumentSecondTime = Assert.Single(await project.GetSourceGeneratedDocumentsAsync());
@@ -705,7 +705,7 @@ public async Task ForkAfterFreezeNoLongerRunsGeneratorsEvenIfCompilationFallsAwa
             Assert.True(generatorRan);
             generatorRan = false;
 
-            compilationReference.AssertReleased();
+            compilationReference.AssertHeld();
 
             var document = project.Documents.Single().WithFrozenPartialSemantics(CancellationToken.None);
 
@@ -729,7 +729,7 @@ public async Task ChangesToAdditionalFilesCorrectlyAppliedEvenIfCompilationFalls
                 .AddAdditionalDocument("Test.txt", "Hello, world!").Project;
 
             var compilationReference = ObjectReference.CreateFromFactory(() => project.GetRequiredCompilationAsync(CancellationToken.None).Result);
-            compilationReference.AssertReleased();
+            compilationReference.AssertHeld();
 
             var projectWithoutAdditionalFiles = project.RemoveAdditionalDocument(project.AdditionalDocumentIds.Single());
             Assert.Empty((await projectWithoutAdditionalFiles.GetRequiredCompilationAsync(CancellationToken.None)).SyntaxTrees);

From 63d6adb956f9dfcfd4d06cf7bbe528860ad100d4 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 20 Dec 2021 19:15:55 -0800
Subject: [PATCH 154/444] lint

---
 .../Portable/ConvertNamespace/ConvertNamespaceTransform.cs      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Features/CSharp/Portable/ConvertNamespace/ConvertNamespaceTransform.cs b/src/Features/CSharp/Portable/ConvertNamespace/ConvertNamespaceTransform.cs
index b8f4dc29bfe80..ca9ee3864ee40 100644
--- a/src/Features/CSharp/Portable/ConvertNamespace/ConvertNamespaceTransform.cs
+++ b/src/Features/CSharp/Portable/ConvertNamespace/ConvertNamespaceTransform.cs
@@ -44,7 +44,7 @@ public static async Task<Document> ConvertAsync(Document document, BaseNamespace
 
                 default:
                     throw ExceptionUtilities.UnexpectedValue(baseNamespace.Kind());
-            };
+            }
         }
 
         public static async Task<(Document document, TextSpan semicolonSpan)> ConvertNamespaceDeclarationAsync(Document document, NamespaceDeclarationSyntax namespaceDeclaration, CancellationToken cancellationToken)

From af2d2e353b8a696e052536c1825081a962da148f Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Tue, 21 Dec 2021 13:01:47 -0800
Subject: [PATCH 155/444] Apply trait to containing type

---
 .../ProximityExpressionsGetterTests.cs        | 107 +++++++++---------
 1 file changed, 54 insertions(+), 53 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/Debugging/ProximityExpressionsGetterTests.cs b/src/EditorFeatures/CSharpTest/Debugging/ProximityExpressionsGetterTests.cs
index 6865676c9edb9..41d33ef32387b 100644
--- a/src/EditorFeatures/CSharpTest/Debugging/ProximityExpressionsGetterTests.cs
+++ b/src/EditorFeatures/CSharpTest/Debugging/ProximityExpressionsGetterTests.cs
@@ -22,6 +22,7 @@
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests.Debugging
 {
     [UseExportProvider]
+    [Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
     public partial class ProximityExpressionsGetterTests
     {
         private static string s_lazyTestFileContent;
@@ -44,7 +45,7 @@ private static SyntaxTree GetTree()
         private static SyntaxTree GetTreeFromCode(string code)
             => SyntaxFactory.ParseSyntaxTree(code);
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public void TestWithinStatement_1()
         {
             var tree = GetTreeFromCode(@"using System;
@@ -106,42 +107,42 @@ await TestProximityExpressionGetterAsync(input, async (getter, semanticSnapshot,
             });
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task TestTryDo1()
             => await TestTryDoAsync("class Class { void Method() { string local;$$ } }", "local", "this");
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task TestNoParentToken()
             => await TestTryDoAsync("$$");
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task TestIsValid1()
             => await TestIsValidAsync("class Class { void Method() { string local;$$ } }", "local", true);
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task TestIsValidWithDiagnostics()
         {
             // local doesn't exist in this context
             await TestIsValidAsync("class Class { void Method() { string local; } $$}", "local", false);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task TestIsValidReferencingLocalBeforeDeclaration()
             => await TestIsValidAsync("class Class { void Method() { $$int i; int j; } }", "j", false);
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task TestIsValidReferencingUndefinedVariable()
             => await TestIsValidAsync("class Class { void Method() { $$int i; int j; } }", "k", false);
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task TestIsValidNoTypeSymbol()
             => await TestIsValidAsync("namespace Namespace$$ { }", "goo", false);
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task TestIsValidLocalAfterPosition()
             => await TestIsValidAsync("class Class { void Method() { $$ int i; string local; } }", "local", false);
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task TestThis()
         {
             await TestTryDoAsync(@"
@@ -155,7 +156,7 @@ public Class() : this(true)
 }", "this");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task TestArrayCreationExpression()
         {
             await TestTryDoAsync(@"
@@ -168,7 +169,7 @@ void Method()
 }", "i", "this");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task TestPostfixUnaryExpressionSyntax()
         {
             await TestTryDoAsync(@"
@@ -182,7 +183,7 @@ void Method()
 }", "i", "this");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task TestLabeledStatement()
         {
             await TestTryDoAsync(@"
@@ -196,7 +197,7 @@ void Method()
 }", "i", "this");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task TestThrowStatement()
         {
             await TestTryDoAsync(@"
@@ -210,7 +211,7 @@ static void Method()
 }", "e");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task TestDoStatement()
         {
             await TestTryDoAsync(@"
@@ -223,7 +224,7 @@ static void Method()
 }");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task TestLockStatement()
         {
             await TestTryDoAsync(@"
@@ -236,7 +237,7 @@ static void Method()
 }");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task TestWhileStatement()
         {
             await TestTryDoAsync(@"
@@ -249,7 +250,7 @@ static void Method()
 }", "DateTime", "DateTime.Now");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task TestForStatementWithDeclarators()
         {
             await TestTryDoAsync(@"
@@ -262,7 +263,7 @@ static void Method()
 }", "i");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task TestForStatementWithInitializers()
         {
             await TestTryDoAsync(@"
@@ -276,7 +277,7 @@ static void Method()
 }", "i");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task TestUsingStatement()
         {
             await TestTryDoAsync(@"
@@ -289,7 +290,7 @@ void Method()
 }", "this");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         [WorkItem(538879, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538879")]
         public async Task TestValueInPropertySetter()
         {
@@ -304,7 +305,7 @@ string Name
 }", "this", "value");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         [WorkItem(48504, "https://github.com/dotnet/roslyn/issues/48504")]
         public async Task TestValueInPropertyInit()
         {
@@ -319,7 +320,7 @@ string Name
 }", "this", "value");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task TestValueInEventAdd()
         {
             await TestTryDoAsync(@"
@@ -333,7 +334,7 @@ event Action Event
 }", "this", "value");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task TestValueInEventRemove()
         {
             await TestTryDoAsync(@"
@@ -347,7 +348,7 @@ event Action Event
 }", "this", "value");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         [WorkItem(538880, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538880")]
         public async Task TestValueInIndexerSetter()
         {
@@ -362,7 +363,7 @@ string this[int index]
 }", "index", "this", "value");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         [WorkItem(538881, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538881")]
         public async Task TestCatchBlock()
         {
@@ -377,7 +378,7 @@ void Method()
 }", "ex", "this");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         [WorkItem(538881, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538881")]
         public async Task TestCatchBlockEmpty_OpenBrace()
         {
@@ -392,7 +393,7 @@ void Method()
 }", "ex", "this");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task TestCatchBlockEmpty_CloseBrace()
         {
             await TestTryDoAsync(@"
@@ -406,7 +407,7 @@ void Method()
 }", "this");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         [WorkItem(538874, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538874")]
         public async Task TestObjectCreation()
         {
@@ -420,7 +421,7 @@ void Method()
 }", "a", "new Bar(a).Baz", "Goo", "this");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         [WorkItem(538874, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538874")]
         public async Task Test2()
         {
@@ -439,7 +440,7 @@ void Method()
 }", "D.x", false);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         [WorkItem(538890, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538890")]
         public async Task TestArrayCreation()
         {
@@ -455,7 +456,7 @@ void Method()
         }
 
         [WorkItem(751141, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/751141")]
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task Bug751141()
         {
             await TestTryDoAsync(@"
@@ -476,7 +477,7 @@ void M()
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task ForLoopExpressionsInFirstStatementOfLoop1()
         {
             await TestTryDoAsync(@"class Program
@@ -492,7 +493,7 @@ static void Main(string[] args)
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task ForLoopExpressionsInFirstStatementOfLoop2()
         {
             await TestTryDoAsync(@"class Program
@@ -511,7 +512,7 @@ static void Main(string[] args)
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task ForLoopExpressionsInFirstStatementOfLoop3()
         {
             await TestTryDoAsync(@"class Program
@@ -530,7 +531,7 @@ static void Main(string[] args)
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task ForLoopExpressionsInFirstStatementOfLoop4()
         {
             await TestTryDoAsync(@"class Program
@@ -546,7 +547,7 @@ static void Main(string[] args)
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task ForEachLoopExpressionsInFirstStatementOfLoop1()
         {
             await TestTryDoAsync(@"class Program
@@ -562,7 +563,7 @@ static void Main(string[] args)
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task ForEachLoopExpressionsInFirstStatementOfLoop2()
         {
             await TestTryDoAsync(@"class Program
@@ -576,7 +577,7 @@ static void Main(string[] args)
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task ExpressionsAfterForLoop1()
         {
             await TestTryDoAsync(@"class Program
@@ -597,7 +598,7 @@ static void Main(string[] args)
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task ExpressionsAfterForLoop2()
         {
             await TestTryDoAsync(@"class Program
@@ -618,7 +619,7 @@ static void Main(string[] args)
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task ExpressionsAfterForEachLoop()
         {
             await TestTryDoAsync(@"class Program
@@ -639,7 +640,7 @@ static void Main(string[] args)
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task ExpressionsAfterNestedForLoop()
         {
             await TestTryDoAsync(@"class Program
@@ -665,7 +666,7 @@ static void Main(string[] args)
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task ExpressionsAfterCheckedStatement()
         {
             await TestTryDoAsync(@"class Program
@@ -686,7 +687,7 @@ static void Main(string[] args)
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task ExpressionsAfterUncheckedStatement()
         {
             await TestTryDoAsync(@"class Program
@@ -707,7 +708,7 @@ static void Main(string[] args)
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task ExpressionsAfterIfStatement()
         {
             await TestTryDoAsync(@"class Program
@@ -728,7 +729,7 @@ static void Main(string[] args)
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task ExpressionsAfterIfStatementWithElse()
         {
             await TestTryDoAsync(@"class Program
@@ -754,7 +755,7 @@ static void Main(string[] args)
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task ExpressionsAfterLockStatement()
         {
             await TestTryDoAsync(@"class Program
@@ -775,7 +776,7 @@ static void Main(string[] args)
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task ExpressionsAfterSwitchStatement()
         {
             await TestTryDoAsync(@"class Program
@@ -806,7 +807,7 @@ static void Main(string[] args)
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task ExpressionsAfterTryStatement()
         {
             await TestTryDoAsync(@"class Program
@@ -837,7 +838,7 @@ static void Main(string[] args)
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task ExpressionsAfterTryStatementWithFinally()
         {
             await TestTryDoAsync(@"class Program
@@ -872,7 +873,7 @@ static void Main(string[] args)
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task ExpressionsAfterUsingStatement()
         {
             await TestTryDoAsync(@"class Program
@@ -893,7 +894,7 @@ static void Main(string[] args)
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task ExpressionsAfterWhileStatement()
         {
             await TestTryDoAsync(@"class Program
@@ -914,7 +915,7 @@ static void Main(string[] args)
         }
 
         [WorkItem(778215, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/778215")]
-        [Fact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
+        [Fact]
         public async Task ExpressionsInParenthesizedExpressions()
         {
             await TestTryDoAsync(@"class Program

From 2dab552234983b459d61af26f3871ec57ba46967 Mon Sep 17 00:00:00 2001
From: David Wengier <david.wengier@microsoft.com>
Date: Wed, 22 Dec 2021 08:44:57 +1100
Subject: [PATCH 156/444] Use ElasticSpace instead of ElasticZeroSpace (#58152)

---
 ...veUnnecessaryExpressionParenthesesTests.cs | 28 ++++++++++++++++++-
 .../AbstractChangeSignatureService.cs         |  7 -----
 .../CodeGeneration/CSharpSyntaxGenerator.cs   |  9 ++----
 .../Core/Portable/Editing/SyntaxGenerator.cs  |  2 +-
 .../TriviaDataFactory.CodeShapeAnalyzer.cs    | 12 ++++++++
 .../VisualBasicSyntaxGenerator.vb             |  8 ++----
 6 files changed, 44 insertions(+), 22 deletions(-)

diff --git a/src/Analyzers/CSharp/Tests/RemoveUnnecessaryParentheses/RemoveUnnecessaryExpressionParenthesesTests.cs b/src/Analyzers/CSharp/Tests/RemoveUnnecessaryParentheses/RemoveUnnecessaryExpressionParenthesesTests.cs
index 834a99db1e4e4..35ab81a00acf0 100644
--- a/src/Analyzers/CSharp/Tests/RemoveUnnecessaryParentheses/RemoveUnnecessaryExpressionParenthesesTests.cs
+++ b/src/Analyzers/CSharp/Tests/RemoveUnnecessaryParentheses/RemoveUnnecessaryExpressionParenthesesTests.cs
@@ -2120,7 +2120,7 @@ void M()
 {
     void M()
     {
-#ifA || B
+#if A || B
 #endif
     }
 }",
@@ -2151,6 +2151,32 @@ void M()
 offeredWhenRequireForClarityIsEnabled: true, index: 1);
         }
 
+        [WorkItem(57768, "https://github.com/dotnet/roslyn/issues/57768")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryParentheses)]
+        public async Task TestParensAroundPPDirective3()
+        {
+            await TestAsync(
+@"class C
+{
+    void M()
+    {
+#if C
+#elif$$(A || B)
+#endif
+    }
+}",
+@"class C
+{
+    void M()
+    {
+#if C
+#elif A || B
+#endif
+    }
+}",
+offeredWhenRequireForClarityIsEnabled: true);
+        }
+
         [WorkItem(29454, "https://github.com/dotnet/roslyn/issues/29454")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryParentheses)]
         public async Task TestMissingForPreIncrement()
diff --git a/src/Features/Core/Portable/ChangeSignature/AbstractChangeSignatureService.cs b/src/Features/Core/Portable/ChangeSignature/AbstractChangeSignatureService.cs
index 0c6c0f5ce1817..b27637de58c64 100644
--- a/src/Features/Core/Portable/ChangeSignature/AbstractChangeSignatureService.cs
+++ b/src/Features/Core/Portable/ChangeSignature/AbstractChangeSignatureService.cs
@@ -950,7 +950,6 @@ protected ImmutableArray<SyntaxTrivia> GetPermutedDocCommentTrivia(Document docu
         {
             var updatedLeadingTrivia = ImmutableArray.CreateBuilder<SyntaxTrivia>();
             var index = 0;
-            SyntaxTrivia lastWhiteSpaceTrivia = default;
 
             var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
 
@@ -958,11 +957,6 @@ protected ImmutableArray<SyntaxTrivia> GetPermutedDocCommentTrivia(Document docu
             {
                 if (!trivia.HasStructure)
                 {
-                    if (syntaxFacts.IsWhitespaceTrivia(trivia))
-                    {
-                        lastWhiteSpaceTrivia = trivia;
-                    }
-
                     updatedLeadingTrivia.Add(trivia);
                     continue;
                 }
@@ -1015,7 +1009,6 @@ protected ImmutableArray<SyntaxTrivia> GetPermutedDocCommentTrivia(Document docu
                 var extraDocComments = Generator.DocumentationCommentTrivia(
                     extraNodeList,
                     node.GetTrailingTrivia(),
-                    lastWhiteSpaceTrivia,
                     document.Project.Solution.Options.GetOption(FormattingOptions.NewLine, document.Project.Language));
                 var newTrivia = Generator.Trivia(extraDocComments);
 
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs
index beb2041b9e5cf..8468718b34530 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs
@@ -80,7 +80,7 @@ internal override SyntaxTrivia Trivia(SyntaxNode node)
             throw ExceptionUtilities.UnexpectedValue(node.Kind());
         }
 
-        internal override SyntaxNode DocumentationCommentTrivia(IEnumerable<SyntaxNode> nodes, SyntaxTriviaList trailingTrivia, SyntaxTrivia lastWhitespaceTrivia, string endOfLineString)
+        internal override SyntaxNode DocumentationCommentTrivia(IEnumerable<SyntaxNode> nodes, SyntaxTriviaList trailingTrivia, string endOfLineString)
         {
             var docTrivia = SyntaxFactory.DocumentationCommentTrivia(
                 SyntaxKind.MultiLineDocumentationCommentTrivia,
@@ -90,12 +90,7 @@ internal override SyntaxNode DocumentationCommentTrivia(IEnumerable<SyntaxNode>
             docTrivia = docTrivia.WithLeadingTrivia(SyntaxFactory.DocumentationCommentExterior("/// "))
                 .WithTrailingTrivia(trailingTrivia);
 
-            if (lastWhitespaceTrivia == default)
-                return docTrivia.WithTrailingTrivia(SyntaxFactory.EndOfLine(endOfLineString));
-
-            return docTrivia.WithTrailingTrivia(
-                SyntaxFactory.EndOfLine(endOfLineString),
-                lastWhitespaceTrivia);
+            return docTrivia.WithTrailingTrivia(SyntaxFactory.EndOfLine(endOfLineString));
         }
 
         internal override SyntaxNode DocumentationCommentTriviaWithUpdatedContent(SyntaxTrivia trivia, IEnumerable<SyntaxNode> content)
diff --git a/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs b/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs
index 55b0c1a5d72c1..a1f5de87e5a8b 100644
--- a/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs
+++ b/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs
@@ -2194,7 +2194,7 @@ internal SyntaxNode AddParentheses(SyntaxNode expression, bool includeElasticTri
 
         internal abstract SyntaxTrivia Trivia(SyntaxNode node);
 
-        internal abstract SyntaxNode DocumentationCommentTrivia(IEnumerable<SyntaxNode> nodes, SyntaxTriviaList trailingTrivia, SyntaxTrivia lastWhitespaceTrivia, string endOfLineString);
+        internal abstract SyntaxNode DocumentationCommentTrivia(IEnumerable<SyntaxNode> nodes, SyntaxTriviaList trailingTrivia, string endOfLineString);
 
         internal abstract SyntaxNode DocumentationCommentTriviaWithUpdatedContent(SyntaxTrivia trivia, IEnumerable<SyntaxNode> content);
 
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/TriviaDataFactory.CodeShapeAnalyzer.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/TriviaDataFactory.CodeShapeAnalyzer.cs
index 5f468dba68861..536bd3bab7a43 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/TriviaDataFactory.CodeShapeAnalyzer.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/TriviaDataFactory.CodeShapeAnalyzer.cs
@@ -106,6 +106,18 @@ private bool UseIndentation
 
             private static bool OnElastic(SyntaxTrivia trivia)
             {
+                // if this is structured trivia then we need to check for elastic trivia in any descendant
+                if (trivia.GetStructure() is { ContainsAnnotations: true } structure)
+                {
+                    foreach (var t in structure.DescendantTrivia())
+                    {
+                        if (t.IsElastic())
+                        {
+                            return true;
+                        }
+                    }
+                }
+
                 // if it contains elastic trivia, always format
                 return trivia.IsElastic();
             }
diff --git a/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb b/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb
index 7778dff6bc081..27fc75c4dd436 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb
@@ -65,16 +65,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Throw ExceptionUtilities.UnexpectedValue(node.Kind())
         End Function
 
-        Friend Overrides Function DocumentationCommentTrivia(nodes As IEnumerable(Of SyntaxNode), trailingTrivia As SyntaxTriviaList, lastWhitespaceTrivia As SyntaxTrivia, endOfLineString As String) As SyntaxNode
+        Friend Overrides Function DocumentationCommentTrivia(nodes As IEnumerable(Of SyntaxNode), trailingTrivia As SyntaxTriviaList, endOfLineString As String) As SyntaxNode
             Dim node = SyntaxFactory.DocumentationCommentTrivia(SyntaxFactory.List(nodes))
             node = node.WithLeadingTrivia(SyntaxFactory.DocumentationCommentExteriorTrivia("''' ")).
                     WithTrailingTrivia(node.GetTrailingTrivia())
 
-            If lastWhitespaceTrivia = Nothing Then
-                Return node.WithTrailingTrivia(SyntaxFactory.EndOfLine(endOfLineString))
-            End If
-
-            Return node.WithTrailingTrivia(SyntaxFactory.EndOfLine(endOfLineString), lastWhitespaceTrivia)
+            Return node.WithTrailingTrivia(SyntaxFactory.EndOfLine(endOfLineString))
         End Function
 
         Friend Overrides Function DocumentationCommentTriviaWithUpdatedContent(trivia As SyntaxTrivia, content As IEnumerable(Of SyntaxNode)) As SyntaxNode

From 98ff5282844271c0cfbdac9a88d38d66f8e698a0 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Tue, 21 Dec 2021 13:38:45 -0800
Subject: [PATCH 157/444] Add helper method TestTryDoInMainAsync

---
 .../ProximityExpressionsGetterTests.cs        | 596 ++++++++----------
 1 file changed, 249 insertions(+), 347 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/Debugging/ProximityExpressionsGetterTests.cs b/src/EditorFeatures/CSharpTest/Debugging/ProximityExpressionsGetterTests.cs
index 41d33ef32387b..70c95b5cdce73 100644
--- a/src/EditorFeatures/CSharpTest/Debugging/ProximityExpressionsGetterTests.cs
+++ b/src/EditorFeatures/CSharpTest/Debugging/ProximityExpressionsGetterTests.cs
@@ -84,6 +84,19 @@ private static async Task TestProximityExpressionGetterAsync(
             await continuation(proximityExpressionsGetter, document, caretPosition);
         }
 
+        private static async Task TestTryDoInMainAsync(string body, params string[] expectedTerms)
+        {
+            var input = $@"class Program
+{{
+    static void Main(string[] args)
+    {{
+{string.Join(Environment.NewLine, body.ReplaceLineEndings("\n").Split('\n').Select(line => line == "" ? line : $"        {line}"))}
+    }}
+}}";
+
+            await TestTryDoAsync(input, expectedTerms);
+        }
+
         private static async Task TestTryDoAsync(string input, params string[] expectedTerms)
         {
             await TestProximityExpressionGetterAsync(input, async (getter, document, position) =>
@@ -167,6 +180,10 @@ void Method()
         int[] i = new int[] { 3 }$$;
     }
 }", "i", "this");
+
+            await TestTryDoInMainAsync(@"
+int[] i = new int[] { 3 }$$;
+", "i", "args");
         }
 
         [Fact]
@@ -181,6 +198,10 @@ void Method()
         i++$$;
     }
 }", "i", "this");
+
+            await TestTryDoInMainAsync(@"int i = 3;
+i++$$;
+", "i");
         }
 
         [Fact]
@@ -195,86 +216,54 @@ void Method()
         label2$$: i++;
     }
 }", "i", "this");
+
+            await TestTryDoInMainAsync(@"label: int i = 3;
+label2$$: i++;
+", "i");
         }
 
         [Fact]
         public async Task TestThrowStatement()
         {
-            await TestTryDoAsync(@"
-class Class 
-{
-    static void Method()
-    {
-        e = new Exception();
-        thr$$ow e;
-    }
-}", "e");
+            await TestTryDoInMainAsync(@"e = new Exception();
+thr$$ow e;
+", "e");
         }
 
         [Fact]
         public async Task TestDoStatement()
         {
-            await TestTryDoAsync(@"
-class Class 
-{
-    static void Method()
-    {
-        do$$ { } while (true);
-    }
-}");
+            await TestTryDoInMainAsync(@"do$$ { } while (true);
+", "args");
         }
 
         [Fact]
         public async Task TestLockStatement()
         {
-            await TestTryDoAsync(@"
-class Class 
-{
-    static void Method()
-    {
-        lock(typeof(Cl$$ass)) { };
-    }
-}");
+            await TestTryDoInMainAsync(@"lock(typeof(Cl$$ass)) { };
+", "args");
         }
 
         [Fact]
         public async Task TestWhileStatement()
         {
-            await TestTryDoAsync(@"
-class Class 
-{
-    static void Method()
-    {
-        while(DateTime.Now <$$ DateTime.Now) { };
-    }
-}", "DateTime", "DateTime.Now");
+            await TestTryDoInMainAsync(@"while(DateTime.Now <$$ DateTime.Now) { };
+", "DateTime", "DateTime.Now", "args");
         }
 
         [Fact]
         public async Task TestForStatementWithDeclarators()
         {
-            await TestTryDoAsync(@"
-class Class 
-{
-    static void Method()
-    {
-        for(int i = 0; i < 10; i$$++) { }
-    }
-}", "i");
+            await TestTryDoInMainAsync(@"for(int i = 0; i < 10; i$$++) { }
+", "i", "args");
         }
 
         [Fact]
         public async Task TestForStatementWithInitializers()
         {
-            await TestTryDoAsync(@"
-class Class 
-{
-    static void Method()
-    {
-        int i = 0;
-        for(i = 1; i < 10; i$$++) { }
-    }
-}", "i");
+            await TestTryDoInMainAsync(@"int i = 0;
+for(i = 1; i < 10; i$$++) { }
+", "i");
         }
 
         [Fact]
@@ -288,6 +277,9 @@ void Method()
         using (FileStream fs = new FileStream($$)) { }
     }
 }", "this");
+
+            await TestTryDoInMainAsync(@"using (FileStream fs = new FileStream($$)) { }
+", "args");
         }
 
         [Fact]
@@ -376,6 +368,10 @@ void Method()
         catch(Exception ex) { int $$ }
     }
 }", "ex", "this");
+
+            await TestTryDoInMainAsync(@"try { }
+catch(Exception ex) { int $$ }
+", "ex");
         }
 
         [Fact]
@@ -391,6 +387,10 @@ void Method()
         catch(Exception ex) { $$ }
     }
 }", "ex", "this");
+
+            await TestTryDoInMainAsync(@"try { }
+catch(Exception ex) { $$ }
+", "ex");
         }
 
         [Fact]
@@ -405,6 +405,10 @@ void Method()
         catch(Exception ex) { } $$ 
     }
 }", "this");
+
+            await TestTryDoInMainAsync(@"try { }
+catch(Exception ex) { } $$ 
+");
         }
 
         [Fact]
@@ -419,6 +423,9 @@ void Method()
         $$Goo(new Bar(a).Baz);
     }
 }", "a", "new Bar(a).Baz", "Goo", "this");
+
+            await TestTryDoInMainAsync(@"$$Goo(new Bar(a).Baz);
+", "a", "new Bar(a).Baz", "Goo", "args");
         }
 
         [Fact]
@@ -480,457 +487,352 @@ void M()
         [Fact]
         public async Task ForLoopExpressionsInFirstStatementOfLoop1()
         {
-            await TestTryDoAsync(@"class Program
+            await TestTryDoInMainAsync(@"for(int i = 0; i < 5; i++)
 {
-    static void Main(string[] args)
-    {
-        for(int i = 0; i < 5; i++)
-        {
-            $$var x = 8;
-        }
-    }
-}", "i", "x");
+    $$var x = 8;
+}
+", "i", "x");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
         [Fact]
         public async Task ForLoopExpressionsInFirstStatementOfLoop2()
         {
-            await TestTryDoAsync(@"class Program
-{
-    static void Main(string[] args)
-    {
-        int i = 0, j = 0, k = 0, m = 0, n = 0;
+            await TestTryDoInMainAsync(@"int i = 0, j = 0, k = 0, m = 0, n = 0;
 
-        for(i = 0; j < 5; k++)
-        {
-            $$m = 8;
-            n = 7;
-        }
-    }
-}", "m", "i", "j", "k");
+for(i = 0; j < 5; k++)
+{
+    $$m = 8;
+    n = 7;
+}
+", "m", "i", "j", "k");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
         [Fact]
         public async Task ForLoopExpressionsInFirstStatementOfLoop3()
         {
-            await TestTryDoAsync(@"class Program
-{
-    static void Main(string[] args)
-    {
-        int i = 0, j = 0, k = 0, m = 0;
+            await TestTryDoInMainAsync(@"int i = 0, j = 0, k = 0, m = 0;
 
-        for(i = 0; j < 5; k++)
-        {
-            var m = 8;
-            $$var n = 7;
-        }
-    }
-}", "m", "n");
+for(i = 0; j < 5; k++)
+{
+    var m = 8;
+    $$var n = 7;
+}
+", "m", "n");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
         [Fact]
         public async Task ForLoopExpressionsInFirstStatementOfLoop4()
         {
-            await TestTryDoAsync(@"class Program
-{
-    static void Main(string[] args)
-    {
-        int i = 0, j = 0, k = 0, m = 0;
+            await TestTryDoInMainAsync(@"int i = 0, j = 0, k = 0, m = 0;
 
-        for(i = 0; j < 5; k++)
-            $$m = 8;
-    }
-}", "m", "i", "j", "k");
+for(i = 0; j < 5; k++)
+    $$m = 8;
+", "m", "i", "j", "k");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
         [Fact]
         public async Task ForEachLoopExpressionsInFirstStatementOfLoop1()
         {
-            await TestTryDoAsync(@"class Program
+            await TestTryDoInMainAsync(@"foreach (var x in new int[] { 1, 2, 3 })
 {
-    static void Main(string[] args)
-    {
-        foreach (var x in new int[] { 1, 2, 3 })
-        {
-            $$var z = 0;
-        }
-    }
-}", "x", "z");
+    $$var z = 0;
+}
+", "x", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
         [Fact]
         public async Task ForEachLoopExpressionsInFirstStatementOfLoop2()
         {
-            await TestTryDoAsync(@"class Program
-{
-    static void Main(string[] args)
-    {
-        foreach (var x in new int[] { 1, 2, 3 })
-            $$var z = 0;
-    }
-}", "x", "z");
+            await TestTryDoInMainAsync(@"foreach (var x in new int[] { 1, 2, 3 })
+    $$var z = 0;
+", "x", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
         [Fact]
         public async Task ExpressionsAfterForLoop1()
         {
-            await TestTryDoAsync(@"class Program
-{
-    static void Main(string[] args)
-    {
-        int a = 0, b = 0, c = 0, d = 0;
+            await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0;
 
-        for (a = 5; b < 1; b++)
-        {
-            c = 8;
-            d = 9; // included
-        }
+for (a = 5; b < 1; b++)
+{
+    c = 8;
+    d = 9; // included
+}
         
-        $$var z = 0;
-    }
-}", "a", "b", "d", "z");
+$$var z = 0;
+", "a", "b", "d", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
         [Fact]
         public async Task ExpressionsAfterForLoop2()
         {
-            await TestTryDoAsync(@"class Program
-{
-    static void Main(string[] args)
-    {
-        int a = 0, b = 0, c = 0;
+            await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0;
 
-        for (a = 5; b < 1; b++)
-        {
-            c = 8;
-            int d = 9; // not included
-        }
+for (a = 5; b < 1; b++)
+{
+    c = 8;
+    int d = 9; // not included
+}
         
-        $$var z = 0;
-    }
-}", "a", "b", "z");
+$$var z = 0;
+", "a", "b", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
         [Fact]
         public async Task ExpressionsAfterForEachLoop()
         {
-            await TestTryDoAsync(@"class Program
-{
-    static void Main(string[] args)
-    {
-        int a = 0, b = 0, c = 0, d = 0;
+            await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0;
 
-        foreach (var q in new int[] {1, 2, 3})
-        {
-            c = 8;
-            d = 9; // included
-        }
+foreach (var q in new int[] {1, 2, 3})
+{
+    c = 8;
+    d = 9; // included
+}
         
-        $$var z = 0;
-    }
-}", "q", "d", "z");
+$$var z = 0;
+", "q", "d", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
         [Fact]
         public async Task ExpressionsAfterNestedForLoop()
         {
-            await TestTryDoAsync(@"class Program
+            await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
+
+for (a = 5; b < 1; b++)
 {
-    static void Main(string[] args)
+    c = 8;
+    d = 9;
+    for (a = 7; b < 9; b--)
     {
-        int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
-
-        for (a = 5; b < 1; b++)
-        {
-            c = 8;
-            d = 9;
-            for (a = 7; b < 9; b--)
-            {
-                e = 8;
-                f = 10; // included
-            }
-        }
-        
-        $$var z = 0;
+        e = 8;
+        f = 10; // included
     }
-}", "a", "b", "f", "z");
+}
+        
+$$var z = 0;
+", "a", "b", "f", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
         [Fact]
         public async Task ExpressionsAfterCheckedStatement()
         {
-            await TestTryDoAsync(@"class Program
-{
-    static void Main(string[] args)
-    {
-        int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
+            await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
 
-        checked
-        {
-            a = 7;
-            b = 0; // included
-        }
+checked
+{
+    a = 7;
+    b = 0; // included
+}
         
-        $$var z = 0;
-    }
-}", "b", "z");
+$$var z = 0;
+", "b", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
         [Fact]
         public async Task ExpressionsAfterUncheckedStatement()
         {
-            await TestTryDoAsync(@"class Program
-{
-    static void Main(string[] args)
-    {
-        int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
+            await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
 
-        unchecked
-        {
-            a = 7;
-            b = 0; // included
-        }
+unchecked
+{
+    a = 7;
+    b = 0; // included
+}
         
-        $$var z = 0;
-    }
-}", "b", "z");
+$$var z = 0;
+", "b", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
         [Fact]
         public async Task ExpressionsAfterIfStatement()
         {
-            await TestTryDoAsync(@"class Program
-{
-    static void Main(string[] args)
-    {
-        int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
+            await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
 
-        if (a == 0)
-        {
-            c = 8; 
-            d = 9; // included
-        }
+if (a == 0)
+{
+    c = 8; 
+    d = 9; // included
+}
 
-        $$var z = 0;
-    }
-}", "a", "d", "z");
+$$var z = 0;
+", "a", "d", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
         [Fact]
         public async Task ExpressionsAfterIfStatementWithElse()
         {
-            await TestTryDoAsync(@"class Program
-{
-    static void Main(string[] args)
-    {
-        int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
+            await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
 
-        if (a == 0)
-        {
-            c = 8; 
-            d = 9; // included
-        }
-        else
-        {
-            e = 1;
-            f = 2; // included
-        }
+if (a == 0)
+{
+    c = 8; 
+    d = 9; // included
+}
+else
+{
+    e = 1;
+    f = 2; // included
+}
 
-        $$var z = 0;
-    }
-}", "a", "d", "f", "z");
+$$var z = 0;
+", "a", "d", "f", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
         [Fact]
         public async Task ExpressionsAfterLockStatement()
         {
-            await TestTryDoAsync(@"class Program
-{
-    static void Main(string[] args)
-    {
-        int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
+            await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
 
-        lock (new object())
-        {
-            a = 2;
-            b = 3; // included
-        }
+lock (new object())
+{
+    a = 2;
+    b = 3; // included
+}
 
-        $$var z = 0;
-    }
-}", "b", "z");
+$$var z = 0;
+", "b", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
         [Fact]
         public async Task ExpressionsAfterSwitchStatement()
         {
-            await TestTryDoAsync(@"class Program
-{
-    static void Main(string[] args)
-    {
-        int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0;
-
-        switch(a)
-        {
-            case 1:
-                b = 7;
-                c = 8; // included
-                break;
-            case 2:
-                d = 9;
-                e = 10; // included
-                break;
-            default:
-                f = 1;
-                g = 2; // included
-                break;
-        }
+            await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0;
+
+switch(a)
+{
+    case 1:
+        b = 7;
+        c = 8; // included
+        break;
+    case 2:
+        d = 9;
+        e = 10; // included
+        break;
+    default:
+        f = 1;
+        g = 2; // included
+        break;
+}
 
-        $$var z = 0;
-    }
-}", "a", "c", "e", "g", "z");
+$$var z = 0;
+", "a", "c", "e", "g", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
         [Fact]
         public async Task ExpressionsAfterTryStatement()
         {
-            await TestTryDoAsync(@"class Program
-{
-    static void Main(string[] args)
-    {
-        int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0;
+            await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0;
 
-        try
-        {
-            a = 2;
-            b = 3; // included
-        }
-        catch (System.DivideByZeroException)
-        {
-            c = 2;
-            d = 5; // included
-        }
-        catch (System.EntryPointNotFoundException)
-        {
-            e = 8;
-            f = 9; // included
-        }
+try
+{
+    a = 2;
+    b = 3; // included
+}
+catch (System.DivideByZeroException)
+{
+    c = 2;
+    d = 5; // included
+}
+catch (System.EntryPointNotFoundException)
+{
+    e = 8;
+    f = 9; // included
+}
 
-        $$var z = 0;
-    }
-}", "b", "d", "f", "z");
+$$var z = 0;
+", "b", "d", "f", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
         [Fact]
         public async Task ExpressionsAfterTryStatementWithFinally()
         {
-            await TestTryDoAsync(@"class Program
-{
-    static void Main(string[] args)
-    {
-        int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0;
+            await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0;
 
-        try
-        {
-            a = 2;
-            b = 3;
-        }
-        catch (System.DivideByZeroException)
-        {
-            c = 2;
-            d = 5;
-        }
-        catch (System.EntryPointNotFoundException)
-        {
-            e = 8;
-            f = 9;
-        }
-        finally
-        {
-            g = 2; // included
-        }
+try
+{
+    a = 2;
+    b = 3;
+}
+catch (System.DivideByZeroException)
+{
+    c = 2;
+    d = 5;
+}
+catch (System.EntryPointNotFoundException)
+{
+    e = 8;
+    f = 9;
+}
+finally
+{
+    g = 2; // included
+}
 
-        $$var z = 0;
-    }
-}", "g", "z");
+$$var z = 0;
+", "g", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
         [Fact]
         public async Task ExpressionsAfterUsingStatement()
         {
-            await TestTryDoAsync(@"class Program
-{
-    static void Main(string[] args)
-    {
-        int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0;
+            await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0;
 
-        using (null as System.IDisposable)
-        {
-            a = 4;
-            b = 8; // Included
-        }
+using (null as System.IDisposable)
+{
+    a = 4;
+    b = 8; // Included
+}
 
-        $$var z = 0;
-    }
-}", "b", "z");
+$$var z = 0;
+", "b", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
         [Fact]
         public async Task ExpressionsAfterWhileStatement()
         {
-            await TestTryDoAsync(@"class Program
-{
-    static void Main(string[] args)
-    {
-        int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0;
+            await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0;
 
-        while (a < 5)
-        {
-            a++;
-            b = 8; // Included
-        }
+while (a < 5)
+{
+    a++;
+    b = 8; // Included
+}
 
-        $$var z = 0;
-    }
-}", "a", "b", "z");
+$$var z = 0;
+", "a", "b", "z");
         }
 
         [WorkItem(778215, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/778215")]
         [Fact]
         public async Task ExpressionsInParenthesizedExpressions()
         {
-            await TestTryDoAsync(@"class Program
-{
-    static void Main(string[] args)
-    {
-        int i = 0, j = 0, k = 0, m = 0;
-        int flags = 7;
+            await TestTryDoInMainAsync(@"int i = 0, j = 0, k = 0, m = 0;
+int flags = 7;
 
-        if((flags & i) == k)
-        {
-            $$ m = 8;
-        }
-    }
-}", "m", "flags", "i", "k");
+if((flags & i) == k)
+{
+    $$ m = 8;
+}
+", "m", "flags", "i", "k");
         }
     }
 }

From 1b4d7bbc5b71655cb2399fa0ee21eaeae1778dab Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Tue, 21 Dec 2021 14:05:48 -0800
Subject: [PATCH 158/444] Update proximity expression tests to cover top level
 statements

Fixes #58337
---
 .../ProximityExpressionsGetterTests.cs        | 272 ++++++++++--------
 ...SharpProximityExpressionsService.Worker.cs |   8 +-
 .../Extensions/StatementSyntaxExtensions.cs   |  16 +-
 3 files changed, 173 insertions(+), 123 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/Debugging/ProximityExpressionsGetterTests.cs b/src/EditorFeatures/CSharpTest/Debugging/ProximityExpressionsGetterTests.cs
index 70c95b5cdce73..a9fe401573bfc 100644
--- a/src/EditorFeatures/CSharpTest/Debugging/ProximityExpressionsGetterTests.cs
+++ b/src/EditorFeatures/CSharpTest/Debugging/ProximityExpressionsGetterTests.cs
@@ -84,15 +84,23 @@ private static async Task TestProximityExpressionGetterAsync(
             await continuation(proximityExpressionsGetter, document, caretPosition);
         }
 
-        private static async Task TestTryDoInMainAsync(string body, params string[] expectedTerms)
+        private static async Task TestTryDoInMainAsync(string body, bool topLevelStatement, params string[] expectedTerms)
         {
-            var input = $@"class Program
+            string input;
+            if (topLevelStatement)
+            {
+                input = body;
+            }
+            else
+            {
+                input = $@"class Program
 {{
     static void Main(string[] args)
     {{
 {string.Join(Environment.NewLine, body.ReplaceLineEndings("\n").Split('\n').Select(line => line == "" ? line : $"        {line}"))}
     }}
 }}";
+            }
 
             await TestTryDoAsync(input, expectedTerms);
         }
@@ -169,10 +177,12 @@ public Class() : this(true)
 }", "this");
         }
 
-        [Fact]
-        public async Task TestArrayCreationExpression()
+        [Theory, CombinatorialData]
+        public async Task TestArrayCreationExpression(bool topLevelStatement)
         {
-            await TestTryDoAsync(@"
+            if (!topLevelStatement)
+            {
+                await TestTryDoAsync(@"
 class Class 
 {
     void Method()
@@ -180,16 +190,19 @@ void Method()
         int[] i = new int[] { 3 }$$;
     }
 }", "i", "this");
+            }
 
             await TestTryDoInMainAsync(@"
 int[] i = new int[] { 3 }$$;
-", "i", "args");
+", topLevelStatement, "i", "args");
         }
 
-        [Fact]
-        public async Task TestPostfixUnaryExpressionSyntax()
+        [Theory, CombinatorialData]
+        public async Task TestPostfixUnaryExpressionSyntax(bool topLevelStatement)
         {
-            await TestTryDoAsync(@"
+            if (!topLevelStatement)
+            {
+                await TestTryDoAsync(@"
 class Class 
 {
     void Method()
@@ -198,16 +211,19 @@ void Method()
         i++$$;
     }
 }", "i", "this");
+            }
 
             await TestTryDoInMainAsync(@"int i = 3;
 i++$$;
-", "i");
+", topLevelStatement, "i");
         }
 
-        [Fact]
-        public async Task TestLabeledStatement()
+        [Theory, CombinatorialData]
+        public async Task TestLabeledStatement(bool topLevelStatement)
         {
-            await TestTryDoAsync(@"
+            if (!topLevelStatement)
+            {
+                await TestTryDoAsync(@"
 class Class 
 {
     void Method()
@@ -216,60 +232,63 @@ void Method()
         label2$$: i++;
     }
 }", "i", "this");
+            }
 
             await TestTryDoInMainAsync(@"label: int i = 3;
 label2$$: i++;
-", "i");
+", topLevelStatement, "i");
         }
 
-        [Fact]
-        public async Task TestThrowStatement()
+        [Theory, CombinatorialData]
+        public async Task TestThrowStatement(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"e = new Exception();
 thr$$ow e;
-", "e");
+", topLevelStatement, "e");
         }
 
-        [Fact]
-        public async Task TestDoStatement()
+        [Theory, CombinatorialData]
+        public async Task TestDoStatement(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"do$$ { } while (true);
-", "args");
+", topLevelStatement, "args");
         }
 
-        [Fact]
-        public async Task TestLockStatement()
+        [Theory, CombinatorialData]
+        public async Task TestLockStatement(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"lock(typeof(Cl$$ass)) { };
-", "args");
+", topLevelStatement, "args");
         }
 
-        [Fact]
-        public async Task TestWhileStatement()
+        [Theory, CombinatorialData]
+        public async Task TestWhileStatement(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"while(DateTime.Now <$$ DateTime.Now) { };
-", "DateTime", "DateTime.Now", "args");
+", topLevelStatement, "DateTime", "DateTime.Now", "args");
         }
 
-        [Fact]
-        public async Task TestForStatementWithDeclarators()
+        [Theory, CombinatorialData]
+        public async Task TestForStatementWithDeclarators(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"for(int i = 0; i < 10; i$$++) { }
-", "i", "args");
+", topLevelStatement, "i", "args");
         }
 
-        [Fact]
-        public async Task TestForStatementWithInitializers()
+        [Theory, CombinatorialData]
+        public async Task TestForStatementWithInitializers(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"int i = 0;
 for(i = 1; i < 10; i$$++) { }
-", "i");
+", topLevelStatement, "i");
         }
 
-        [Fact]
-        public async Task TestUsingStatement()
+        [Theory, CombinatorialData]
+        public async Task TestUsingStatement(bool topLevelStatement)
         {
-            await TestTryDoAsync(@"
+            if (!topLevelStatement)
+            {
+                await TestTryDoAsync(@"
 class Class 
 {
     void Method()
@@ -277,9 +296,10 @@ void Method()
         using (FileStream fs = new FileStream($$)) { }
     }
 }", "this");
+            }
 
             await TestTryDoInMainAsync(@"using (FileStream fs = new FileStream($$)) { }
-", "args");
+", topLevelStatement, "args");
         }
 
         [Fact]
@@ -355,11 +375,13 @@ string this[int index]
 }", "index", "this", "value");
         }
 
-        [Fact]
+        [Theory, CombinatorialData]
         [WorkItem(538881, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538881")]
-        public async Task TestCatchBlock()
+        public async Task TestCatchBlock(bool topLevelStatement)
         {
-            await TestTryDoAsync(@"
+            if (!topLevelStatement)
+            {
+                await TestTryDoAsync(@"
 class Class 
 {
     void Method()
@@ -368,17 +390,20 @@ void Method()
         catch(Exception ex) { int $$ }
     }
 }", "ex", "this");
+            }
 
             await TestTryDoInMainAsync(@"try { }
 catch(Exception ex) { int $$ }
-", "ex");
+", topLevelStatement, "ex");
         }
 
-        [Fact]
+        [Theory, CombinatorialData]
         [WorkItem(538881, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538881")]
-        public async Task TestCatchBlockEmpty_OpenBrace()
+        public async Task TestCatchBlockEmpty_OpenBrace(bool topLevelStatement)
         {
-            await TestTryDoAsync(@"
+            if (!topLevelStatement)
+            {
+                await TestTryDoAsync(@"
 class Class 
 {
     void Method()
@@ -387,16 +412,19 @@ void Method()
         catch(Exception ex) { $$ }
     }
 }", "ex", "this");
+            }
 
             await TestTryDoInMainAsync(@"try { }
 catch(Exception ex) { $$ }
-", "ex");
+", topLevelStatement, "ex");
         }
 
-        [Fact]
-        public async Task TestCatchBlockEmpty_CloseBrace()
+        [Theory, CombinatorialData]
+        public async Task TestCatchBlockEmpty_CloseBrace(bool topLevelStatement)
         {
-            await TestTryDoAsync(@"
+            if (!topLevelStatement)
+            {
+                await TestTryDoAsync(@"
 class Class 
 {
     void Method()
@@ -405,17 +433,20 @@ void Method()
         catch(Exception ex) { } $$ 
     }
 }", "this");
+            }
 
             await TestTryDoInMainAsync(@"try { }
 catch(Exception ex) { } $$ 
-");
+", topLevelStatement);
         }
 
-        [Fact]
+        [Theory, CombinatorialData]
         [WorkItem(538874, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538874")]
-        public async Task TestObjectCreation()
+        public async Task TestObjectCreation(bool topLevelStatement)
         {
-            await TestTryDoAsync(@"
+            if (!topLevelStatement)
+            {
+                await TestTryDoAsync(@"
 class Class 
 {
     void Method()
@@ -423,9 +454,10 @@ void Method()
         $$Goo(new Bar(a).Baz);
     }
 }", "a", "new Bar(a).Baz", "Goo", "this");
+            }
 
             await TestTryDoInMainAsync(@"$$Goo(new Bar(a).Baz);
-", "a", "new Bar(a).Baz", "Goo", "args");
+", topLevelStatement, "a", "new Bar(a).Baz", "Goo", "args");
         }
 
         [Fact]
@@ -484,19 +516,19 @@ void M()
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact]
-        public async Task ForLoopExpressionsInFirstStatementOfLoop1()
+        [Theory, CombinatorialData]
+        public async Task ForLoopExpressionsInFirstStatementOfLoop1(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"for(int i = 0; i < 5; i++)
 {
     $$var x = 8;
 }
-", "i", "x");
+", topLevelStatement, "i", "x");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact]
-        public async Task ForLoopExpressionsInFirstStatementOfLoop2()
+        [Theory, CombinatorialData]
+        public async Task ForLoopExpressionsInFirstStatementOfLoop2(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"int i = 0, j = 0, k = 0, m = 0, n = 0;
 
@@ -505,12 +537,12 @@ public async Task ForLoopExpressionsInFirstStatementOfLoop2()
     $$m = 8;
     n = 7;
 }
-", "m", "i", "j", "k");
+", topLevelStatement, "m", "i", "j", "k");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact]
-        public async Task ForLoopExpressionsInFirstStatementOfLoop3()
+        [Theory, CombinatorialData]
+        public async Task ForLoopExpressionsInFirstStatementOfLoop3(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"int i = 0, j = 0, k = 0, m = 0;
 
@@ -519,43 +551,43 @@ public async Task ForLoopExpressionsInFirstStatementOfLoop3()
     var m = 8;
     $$var n = 7;
 }
-", "m", "n");
+", topLevelStatement, "m", "n");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact]
-        public async Task ForLoopExpressionsInFirstStatementOfLoop4()
+        [Theory, CombinatorialData]
+        public async Task ForLoopExpressionsInFirstStatementOfLoop4(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"int i = 0, j = 0, k = 0, m = 0;
 
 for(i = 0; j < 5; k++)
     $$m = 8;
-", "m", "i", "j", "k");
+", topLevelStatement, "m", "i", "j", "k");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact]
-        public async Task ForEachLoopExpressionsInFirstStatementOfLoop1()
+        [Theory, CombinatorialData]
+        public async Task ForEachLoopExpressionsInFirstStatementOfLoop1(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"foreach (var x in new int[] { 1, 2, 3 })
 {
     $$var z = 0;
 }
-", "x", "z");
+", topLevelStatement, "x", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact]
-        public async Task ForEachLoopExpressionsInFirstStatementOfLoop2()
+        [Theory, CombinatorialData]
+        public async Task ForEachLoopExpressionsInFirstStatementOfLoop2(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"foreach (var x in new int[] { 1, 2, 3 })
     $$var z = 0;
-", "x", "z");
+", topLevelStatement, "x", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact]
-        public async Task ExpressionsAfterForLoop1()
+        [Theory, CombinatorialData]
+        public async Task ExpressionsAfterForLoop1(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0;
 
@@ -566,12 +598,12 @@ public async Task ExpressionsAfterForLoop1()
 }
         
 $$var z = 0;
-", "a", "b", "d", "z");
+", topLevelStatement, "a", "b", "d", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact]
-        public async Task ExpressionsAfterForLoop2()
+        [Theory, CombinatorialData]
+        public async Task ExpressionsAfterForLoop2(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0;
 
@@ -582,12 +614,12 @@ public async Task ExpressionsAfterForLoop2()
 }
         
 $$var z = 0;
-", "a", "b", "z");
+", topLevelStatement, "a", "b", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact]
-        public async Task ExpressionsAfterForEachLoop()
+        [Theory, CombinatorialData]
+        public async Task ExpressionsAfterForEachLoop(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0;
 
@@ -598,12 +630,12 @@ public async Task ExpressionsAfterForEachLoop()
 }
         
 $$var z = 0;
-", "q", "d", "z");
+", topLevelStatement, "q", "d", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact]
-        public async Task ExpressionsAfterNestedForLoop()
+        [Theory, CombinatorialData]
+        public async Task ExpressionsAfterNestedForLoop(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
 
@@ -619,12 +651,12 @@ public async Task ExpressionsAfterNestedForLoop()
 }
         
 $$var z = 0;
-", "a", "b", "f", "z");
+", topLevelStatement, "a", "b", "f", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact]
-        public async Task ExpressionsAfterCheckedStatement()
+        [Theory, CombinatorialData]
+        public async Task ExpressionsAfterCheckedStatement(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
 
@@ -635,12 +667,12 @@ public async Task ExpressionsAfterCheckedStatement()
 }
         
 $$var z = 0;
-", "b", "z");
+", topLevelStatement, "b", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact]
-        public async Task ExpressionsAfterUncheckedStatement()
+        [Theory, CombinatorialData]
+        public async Task ExpressionsAfterUncheckedStatement(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
 
@@ -651,12 +683,12 @@ public async Task ExpressionsAfterUncheckedStatement()
 }
         
 $$var z = 0;
-", "b", "z");
+", topLevelStatement, "b", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact]
-        public async Task ExpressionsAfterIfStatement()
+        [Theory, CombinatorialData]
+        public async Task ExpressionsAfterIfStatement(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
 
@@ -667,12 +699,12 @@ public async Task ExpressionsAfterIfStatement()
 }
 
 $$var z = 0;
-", "a", "d", "z");
+", topLevelStatement, "a", "d", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact]
-        public async Task ExpressionsAfterIfStatementWithElse()
+        [Theory, CombinatorialData]
+        public async Task ExpressionsAfterIfStatementWithElse(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
 
@@ -688,12 +720,12 @@ public async Task ExpressionsAfterIfStatementWithElse()
 }
 
 $$var z = 0;
-", "a", "d", "f", "z");
+", topLevelStatement, "a", "d", "f", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact]
-        public async Task ExpressionsAfterLockStatement()
+        [Theory, CombinatorialData]
+        public async Task ExpressionsAfterLockStatement(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
 
@@ -704,12 +736,12 @@ public async Task ExpressionsAfterLockStatement()
 }
 
 $$var z = 0;
-", "b", "z");
+", topLevelStatement, "b", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact]
-        public async Task ExpressionsAfterSwitchStatement()
+        [Theory, CombinatorialData]
+        public async Task ExpressionsAfterSwitchStatement(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0;
 
@@ -730,12 +762,12 @@ public async Task ExpressionsAfterSwitchStatement()
 }
 
 $$var z = 0;
-", "a", "c", "e", "g", "z");
+", topLevelStatement, "a", "c", "e", "g", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact]
-        public async Task ExpressionsAfterTryStatement()
+        [Theory, CombinatorialData]
+        public async Task ExpressionsAfterTryStatement(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0;
 
@@ -756,12 +788,12 @@ public async Task ExpressionsAfterTryStatement()
 }
 
 $$var z = 0;
-", "b", "d", "f", "z");
+", topLevelStatement, "b", "d", "f", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact]
-        public async Task ExpressionsAfterTryStatementWithFinally()
+        [Theory, CombinatorialData]
+        public async Task ExpressionsAfterTryStatementWithFinally(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0;
 
@@ -786,12 +818,12 @@ public async Task ExpressionsAfterTryStatementWithFinally()
 }
 
 $$var z = 0;
-", "g", "z");
+", topLevelStatement, "g", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact]
-        public async Task ExpressionsAfterUsingStatement()
+        [Theory, CombinatorialData]
+        public async Task ExpressionsAfterUsingStatement(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0;
 
@@ -802,12 +834,12 @@ public async Task ExpressionsAfterUsingStatement()
 }
 
 $$var z = 0;
-", "b", "z");
+", topLevelStatement, "b", "z");
         }
 
         [WorkItem(775161, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775161")]
-        [Fact]
-        public async Task ExpressionsAfterWhileStatement()
+        [Theory, CombinatorialData]
+        public async Task ExpressionsAfterWhileStatement(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0;
 
@@ -818,12 +850,12 @@ public async Task ExpressionsAfterWhileStatement()
 }
 
 $$var z = 0;
-", "a", "b", "z");
+", topLevelStatement, "a", "b", "z");
         }
 
         [WorkItem(778215, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/778215")]
-        [Fact]
-        public async Task ExpressionsInParenthesizedExpressions()
+        [Theory, CombinatorialData]
+        public async Task ExpressionsInParenthesizedExpressions(bool topLevelStatement)
         {
             await TestTryDoInMainAsync(@"int i = 0, j = 0, k = 0, m = 0;
 int flags = 7;
@@ -832,7 +864,17 @@ public async Task ExpressionsInParenthesizedExpressions()
 {
     $$ m = 8;
 }
-", "m", "flags", "i", "k");
+", topLevelStatement, "m", "flags", "i", "k");
+        }
+
+        [WorkItem(58337, "https://github.com/dotnet/roslyn/issues/58337")]
+        [Theory, CombinatorialData]
+        public async Task ExpressionsInTopLevelStatement(bool topLevelStatement)
+        {
+            await TestTryDoInMainAsync(@"int a = 1;
+int b = 2;
+$$ Console.WriteLine(""Hello, World!"");
+", topLevelStatement, "Console", "b");
         }
     }
 }
diff --git a/src/Features/CSharp/Portable/Debugging/CSharpProximityExpressionsService.Worker.cs b/src/Features/CSharp/Portable/Debugging/CSharpProximityExpressionsService.Worker.cs
index 19161e53e41fb..b9c912c5d5e18 100644
--- a/src/Features/CSharp/Portable/Debugging/CSharpProximityExpressionsService.Worker.cs
+++ b/src/Features/CSharp/Portable/Debugging/CSharpProximityExpressionsService.Worker.cs
@@ -70,7 +70,7 @@ private void AddThisExpression()
             {
                 // If it's an instance member, then also add "this".
                 var memberDeclaration = _parentStatement.GetAncestorOrThis<MemberDeclarationSyntax>();
-                if (!memberDeclaration.GetModifiers().Any(SyntaxKind.StaticKeyword))
+                if (!memberDeclaration.IsKind(SyntaxKind.GlobalStatement) && !memberDeclaration.GetModifiers().Any(SyntaxKind.StaticKeyword))
                 {
                     _expressions.Add("this");
                 }
@@ -119,6 +119,12 @@ private void AddMethodParameters()
                     var parameterList = ((MemberDeclarationSyntax)block.Parent).GetParameterList();
                     AddParameters(parameterList);
                 }
+                else if (block is null
+                    && _parentStatement.Parent is GlobalStatementSyntax { Parent: CompilationUnitSyntax compilationUnit } globalStatement
+                    && compilationUnit.Members.FirstOrDefault() == globalStatement)
+                {
+                    _expressions.Add("args");
+                }
             }
 
             private void AddIndexerParameters()
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/StatementSyntaxExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/StatementSyntaxExtensions.cs
index 954d95e80d45a..d1d84bc3add19 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/StatementSyntaxExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/StatementSyntaxExtensions.cs
@@ -18,7 +18,7 @@ public static StatementSyntax WithoutLeadingBlankLinesInTrivia(this StatementSyn
             if (statement != null)
             {
                 var previousToken = statement.GetFirstToken().GetPreviousToken();
-                return previousToken.GetAncestors<StatementSyntax>().FirstOrDefault(s => s.Parent == statement.Parent);
+                return previousToken.GetAncestors<StatementSyntax>().FirstOrDefault(s => AreSiblingStatements(s, statement));
             }
 
             return null;
@@ -29,16 +29,18 @@ public static StatementSyntax WithoutLeadingBlankLinesInTrivia(this StatementSyn
             if (statement != null)
             {
                 var nextToken = statement.GetLastToken().GetNextToken();
-                return nextToken.GetAncestors<StatementSyntax>().FirstOrDefault(s => s.Parent == statement.Parent || AreInSiblingTopLevelStatements(s, statement));
+                return nextToken.GetAncestors<StatementSyntax>().FirstOrDefault(s => AreSiblingStatements(s, statement));
             }
 
             return null;
+        }
 
-            static bool AreInSiblingTopLevelStatements(StatementSyntax one, StatementSyntax other)
-            {
-                return one.IsParentKind(SyntaxKind.GlobalStatement) &&
-                    other.IsParentKind(SyntaxKind.GlobalStatement);
-            }
+        private static bool AreSiblingStatements(StatementSyntax first, StatementSyntax second)
+        {
+            if (first.Parent.IsKind(SyntaxKind.GlobalStatement))
+                return second.Parent.IsKind(SyntaxKind.GlobalStatement);
+            else
+                return first.Parent == second.Parent;
         }
     }
 }

From df6cfde10437b756688c69de8772243bef236e60 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Tue, 21 Dec 2021 14:06:57 -0800
Subject: [PATCH 159/444] Improve message when test fails

---
 .../Debugging/ProximityExpressionsGetterTests.cs          | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/Debugging/ProximityExpressionsGetterTests.cs b/src/EditorFeatures/CSharpTest/Debugging/ProximityExpressionsGetterTests.cs
index a9fe401573bfc..bf87813998e92 100644
--- a/src/EditorFeatures/CSharpTest/Debugging/ProximityExpressionsGetterTests.cs
+++ b/src/EditorFeatures/CSharpTest/Debugging/ProximityExpressionsGetterTests.cs
@@ -110,12 +110,8 @@ private static async Task TestTryDoAsync(string input, params string[] expectedT
             await TestProximityExpressionGetterAsync(input, async (getter, document, position) =>
             {
                 var actualTerms = await getter.GetProximityExpressionsAsync(document, position, CancellationToken.None);
-
-                Assert.Equal(expectedTerms.Length == 0, actualTerms == null);
-                if (expectedTerms.Length > 0)
-                {
-                    AssertEx.Equal(expectedTerms, actualTerms);
-                }
+                Assert.True(actualTerms is null or { Count: > 0 });
+                AssertEx.Equal(expectedTerms, actualTerms ?? Array.Empty<string>());
             });
         }
 

From e9d15a767c971d7ec248dbedfad452f4f26bbffd Mon Sep 17 00:00:00 2001
From: Jonathon Marolf <jmarolf@microsoft.com>
Date: Tue, 21 Dec 2021 14:58:50 -0800
Subject: [PATCH 160/444] set compilers.sln as the default solution when
 opening with VS Code

---
 .vscode/settings.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.vscode/settings.json b/.vscode/settings.json
index 85140b2d44e86..399accea7023f 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,5 +1,6 @@
 {
     "files.associations": {
         "**/eng/pipelines/*.yml": "azure-pipelines"
-    }
+    },
+    "omnisharp.defaultLaunchSolution": "Compilers.sln",
 }
\ No newline at end of file

From 79c8b92af799856919bb3844b6635e8606970366 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Tue, 21 Dec 2021 15:35:14 -0800
Subject: [PATCH 161/444] Support TestWorkspace with multiple source generated
 files

---
 .../Core/SourceGeneration/TestGenerators.cs   | 24 ++++++++++----
 .../CSharpTest/NavigateTo/NavigateToTests.cs  | 32 +++++++++++++++++++
 .../TestWorkspace_XmlConsumption.cs           | 11 +++++--
 3 files changed, 57 insertions(+), 10 deletions(-)

diff --git a/src/Compilers/Test/Core/SourceGeneration/TestGenerators.cs b/src/Compilers/Test/Core/SourceGeneration/TestGenerators.cs
index 57217b7bdad0a..f5da455501648 100644
--- a/src/Compilers/Test/Core/SourceGeneration/TestGenerators.cs
+++ b/src/Compilers/Test/Core/SourceGeneration/TestGenerators.cs
@@ -3,7 +3,8 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
-using System.IO;
+using System.Collections.Generic;
+using System.Linq;
 using System.Text;
 using System.Threading;
 using Microsoft.CodeAnalysis;
@@ -13,18 +14,27 @@ namespace Roslyn.Test.Utilities.TestGenerators
 {
     internal class SingleFileTestGenerator : ISourceGenerator
     {
-        private readonly string _content;
-        private readonly string _hintName;
+        private readonly List<(string content, string hintName)> _sources = new();
 
-        public SingleFileTestGenerator(string content, string hintName = "generatedFile")
+        public SingleFileTestGenerator()
         {
-            _content = content;
-            _hintName = hintName;
+        }
+
+        public SingleFileTestGenerator(string content, string? hintName = null)
+        {
+            AddSource(content, hintName);
+        }
+
+        public void AddSource(string content, string? hintName = null)
+        {
+            hintName ??= "generatedFile" + (_sources.Any() ? (_sources.Count + 1).ToString() : "");
+            _sources.Add((content, hintName));
         }
 
         public void Execute(GeneratorExecutionContext context)
         {
-            context.AddSource(this._hintName, SourceText.From(_content, Encoding.UTF8));
+            foreach (var (content, hintName) in _sources)
+                context.AddSource(hintName, SourceText.From(content, Encoding.UTF8));
         }
 
         public void Initialize(GeneratorInitializationContext context)
diff --git a/src/EditorFeatures/CSharpTest/NavigateTo/NavigateToTests.cs b/src/EditorFeatures/CSharpTest/NavigateTo/NavigateToTests.cs
index 8156a2a56398e..00b8e03512eb6 100644
--- a/src/EditorFeatures/CSharpTest/NavigateTo/NavigateToTests.cs
+++ b/src/EditorFeatures/CSharpTest/NavigateTo/NavigateToTests.cs
@@ -1473,6 +1473,38 @@ public class C
                 },
                 await _aggregator.GetItemsAsync("C"));
         }
+
+        [Fact]
+        public async Task DoIncludeSymbolsFromMultipleSourceGeneratedFiles()
+        {
+            using var workspace = TestWorkspace.Create(@"
+<Workspace>
+    <Project Language=""C#"" CommonReferences=""true"">
+        <DocumentFromSourceGenerator>
+            public partial class C
+            {
+            }
+        </DocumentFromSourceGenerator>
+        <DocumentFromSourceGenerator>
+            public partial class C
+            {
+            }
+        </DocumentFromSourceGenerator>
+    </Project>
+</Workspace>
+", composition: EditorTestCompositions.EditorFeatures);
+
+            _provider = new NavigateToItemProvider(workspace, AsynchronousOperationListenerProvider.NullListener, workspace.GetService<IThreadingContext>());
+            _aggregator = new NavigateToTestAggregator(_provider);
+
+            VerifyNavigateToResultItems(
+                new()
+                {
+                    new NavigateToItem("C", NavigateToItemKind.Class, "csharp", null, null, s_emptyExactPatternMatch, null),
+                    new NavigateToItem("C", NavigateToItemKind.Class, "csharp", null, null, s_emptyExactPatternMatch, null),
+                },
+                await _aggregator.GetItemsAsync("C"));
+        }
     }
 }
 #pragma warning restore CS0618 // MatchKind is obsolete
diff --git a/src/EditorFeatures/TestUtilities/Workspaces/TestWorkspace_XmlConsumption.cs b/src/EditorFeatures/TestUtilities/Workspaces/TestWorkspace_XmlConsumption.cs
index 6dc371b3c01a4..09326b5f40882 100644
--- a/src/EditorFeatures/TestUtilities/Workspaces/TestWorkspace_XmlConsumption.cs
+++ b/src/EditorFeatures/TestUtilities/Workspaces/TestWorkspace_XmlConsumption.cs
@@ -14,7 +14,6 @@
 using System.IO;
 using System.Linq;
 using System.Runtime.CompilerServices;
-using System.ServiceModel.Description;
 using System.Threading;
 using System.Xml.Linq;
 using Microsoft.CodeAnalysis.CSharp;
@@ -29,7 +28,6 @@
 using Microsoft.CodeAnalysis.UnitTests;
 using Microsoft.CodeAnalysis.VisualBasic;
 using Microsoft.VisualStudio.Composition;
-using Microsoft.VisualStudio.Text;
 using Roslyn.Test.Utilities;
 using Roslyn.Test.Utilities.TestGenerators;
 using Roslyn.Utilities;
@@ -338,8 +336,15 @@ private static TestHostProject CreateProject(
                 documents.Add(document);
             }
 
+            SingleFileTestGenerator testGenerator = null;
             foreach (var sourceGeneratedDocumentElement in projectElement.Elements(DocumentFromSourceGeneratorElementName))
             {
+                if (testGenerator is null)
+                {
+                    testGenerator = new SingleFileTestGenerator();
+                    analyzers.Add(new TestGeneratorReference(testGenerator));
+                }
+
                 var name = GetFileName(workspace, sourceGeneratedDocumentElement, ref documentId);
 
                 var markupCode = sourceGeneratedDocumentElement.NormalizedValue();
@@ -350,7 +355,7 @@ private static TestHostProject CreateProject(
                 var document = new TestHostDocument(exportProvider, languageServices, code, name, documentFilePath, cursorPosition, spans, isSourceGenerated: true);
                 documents.Add(document);
 
-                analyzers.Add(new TestGeneratorReference(new SingleFileTestGenerator(code, name)));
+                testGenerator.AddSource(code, name);
             }
 
             var additionalDocuments = new List<TestHostDocument>();

From 7812951bd074f434af813135f87bf2bfd52cc82c Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Tue, 21 Dec 2021 15:41:40 -0800
Subject: [PATCH 162/444] Support TestWorkspace with source generated files
 without full XML syntax

---
 .../CrefCompletionProviderTests.cs            |  2 +-
 .../OverrideCompletionProviderTests.cs        |  2 +-
 .../CSharpTest/NavigateTo/NavigateToTests.cs  | 31 +++++++++----------
 ...osticsClassificationTaggerProviderTests.cs |  2 +-
 .../DiagnosticsSquiggleTaggerProviderTests.cs | 10 +++---
 .../Workspaces/TestWorkspace_Create.cs        | 14 ++++++---
 .../TestWorkspace_XmlConsumption.cs           |  1 +
 .../Workspaces/TestWorkspace_XmlCreation.cs   | 24 +++++++++++---
 .../CrefCompletionProviderTests.vb            |  2 +-
 9 files changed, 53 insertions(+), 35 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/CrefCompletionProviderTests.cs b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/CrefCompletionProviderTests.cs
index b9e38257411fe..7bf6a90253c83 100644
--- a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/CrefCompletionProviderTests.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/CrefCompletionProviderTests.cs
@@ -440,7 +440,7 @@ public async Task CrefCompletionSpeculatesOutsideTrivia()
 class C
 {
 }";
-            using var workspace = TestWorkspace.Create(LanguageNames.CSharp, new CSharpCompilationOptions(OutputKind.ConsoleApplication), new CSharpParseOptions(), new[] { text }, ExportProvider);
+            using var workspace = TestWorkspace.Create(LanguageNames.CSharp, new CSharpCompilationOptions(OutputKind.ConsoleApplication), new CSharpParseOptions(), new[] { text }, exportProvider: ExportProvider);
             var called = false;
 
             var hostDocument = workspace.DocumentWithCursor;
diff --git a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/OverrideCompletionProviderTests.cs b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/OverrideCompletionProviderTests.cs
index 7beee24d167d8..043ff896b0a6a 100644
--- a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/OverrideCompletionProviderTests.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/OverrideCompletionProviderTests.cs
@@ -2777,7 +2777,7 @@ static void Main(string[] args)
         override $$
     }
 }";
-            using var workspace = TestWorkspace.Create(LanguageNames.CSharp, new CSharpCompilationOptions(OutputKind.ConsoleApplication), new CSharpParseOptions(), new[] { text }, ExportProvider);
+            using var workspace = TestWorkspace.Create(LanguageNames.CSharp, new CSharpCompilationOptions(OutputKind.ConsoleApplication), new CSharpParseOptions(), new[] { text }, exportProvider: ExportProvider);
             var provider = new OverrideCompletionProvider();
             var testDocument = workspace.Documents.Single();
             var document = workspace.CurrentSolution.GetRequiredDocument(testDocument.Id);
diff --git a/src/EditorFeatures/CSharpTest/NavigateTo/NavigateToTests.cs b/src/EditorFeatures/CSharpTest/NavigateTo/NavigateToTests.cs
index 00b8e03512eb6..0aa8e949a25e4 100644
--- a/src/EditorFeatures/CSharpTest/NavigateTo/NavigateToTests.cs
+++ b/src/EditorFeatures/CSharpTest/NavigateTo/NavigateToTests.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.Linq;
 using System.Threading.Tasks;
@@ -1477,22 +1478,20 @@ public class C
         [Fact]
         public async Task DoIncludeSymbolsFromMultipleSourceGeneratedFiles()
         {
-            using var workspace = TestWorkspace.Create(@"
-<Workspace>
-    <Project Language=""C#"" CommonReferences=""true"">
-        <DocumentFromSourceGenerator>
-            public partial class C
-            {
-            }
-        </DocumentFromSourceGenerator>
-        <DocumentFromSourceGenerator>
-            public partial class C
-            {
-            }
-        </DocumentFromSourceGenerator>
-    </Project>
-</Workspace>
-", composition: EditorTestCompositions.EditorFeatures);
+            using var workspace = TestWorkspace.CreateCSharp(
+                files: Array.Empty<string>(),
+                sourceGeneratedFiles: new[]
+                {
+                    @"
+public partial class C
+{
+}",
+                    @"
+public partial class C
+{
+}",
+                },
+                composition: EditorTestCompositions.EditorFeatures);
 
             _provider = new NavigateToItemProvider(workspace, AsynchronousOperationListenerProvider.NullListener, workspace.GetService<IThreadingContext>());
             _aggregator = new NavigateToTestAggregator(_provider);
diff --git a/src/EditorFeatures/Test/Diagnostics/DiagnosticsClassificationTaggerProviderTests.cs b/src/EditorFeatures/Test/Diagnostics/DiagnosticsClassificationTaggerProviderTests.cs
index 87d71ba66948d..bd36ed6d69eb6 100644
--- a/src/EditorFeatures/Test/Diagnostics/DiagnosticsClassificationTaggerProviderTests.cs
+++ b/src/EditorFeatures/Test/Diagnostics/DiagnosticsClassificationTaggerProviderTests.cs
@@ -37,7 +37,7 @@ public async Task Test_FadingSpans()
                 {  LanguageNames.CSharp, ImmutableArray.Create<DiagnosticAnalyzer>(analyzer) }
             };
 
-            using var workspace = TestWorkspace.CreateCSharp(new string[] { "class A { }", "class E { }" }, CSharpParseOptions.Default, composition: SquiggleUtilities.CompositionWithSolutionCrawler);
+            using var workspace = TestWorkspace.CreateCSharp(new string[] { "class A { }", "class E { }" }, parseOptions: CSharpParseOptions.Default, composition: SquiggleUtilities.CompositionWithSolutionCrawler);
             using var wrapper = new DiagnosticTaggerWrapper<DiagnosticsClassificationTaggerProvider, ClassificationTag>(workspace, analyzerMap);
             var tagger = wrapper.TaggerProvider.CreateTagger<ClassificationTag>(workspace.Documents.First().GetTextBuffer());
             using var disposable = tagger as IDisposable;
diff --git a/src/EditorFeatures/Test/Diagnostics/DiagnosticsSquiggleTaggerProviderTests.cs b/src/EditorFeatures/Test/Diagnostics/DiagnosticsSquiggleTaggerProviderTests.cs
index f84913a7e50a7..6f7aa429bfae8 100644
--- a/src/EditorFeatures/Test/Diagnostics/DiagnosticsSquiggleTaggerProviderTests.cs
+++ b/src/EditorFeatures/Test/Diagnostics/DiagnosticsSquiggleTaggerProviderTests.cs
@@ -41,7 +41,7 @@ public async Task Test_TagSourceDiffer()
                 {  LanguageNames.CSharp, ImmutableArray.Create<DiagnosticAnalyzer>(analyzer) }
             };
 
-            using var workspace = TestWorkspace.CreateCSharp(new string[] { "class A { }", "class E { }" }, CSharpParseOptions.Default);
+            using var workspace = TestWorkspace.CreateCSharp(new string[] { "class A { }", "class E { }" }, parseOptions: CSharpParseOptions.Default);
             using var wrapper = new DiagnosticTaggerWrapper<DiagnosticsSquiggleTaggerProvider, IErrorTag>(workspace, analyzerMap);
             var tagger = wrapper.TaggerProvider.CreateTagger<IErrorTag>(workspace.Documents.First().GetTextBuffer());
             using var disposable = tagger as IDisposable;
@@ -69,7 +69,7 @@ public async Task Test_TagSourceDiffer()
         [WpfFact, Trait(Traits.Feature, Traits.Features.Diagnostics)]
         public async Task MultipleTaggersAndDispose()
         {
-            using var workspace = TestWorkspace.CreateCSharp(new string[] { "class A {" }, CSharpParseOptions.Default);
+            using var workspace = TestWorkspace.CreateCSharp(new string[] { "class A {" }, parseOptions: CSharpParseOptions.Default);
             using var wrapper = new DiagnosticTaggerWrapper<DiagnosticsSquiggleTaggerProvider, IErrorTag>(workspace);
             // Make two taggers.
             var tagger1 = wrapper.TaggerProvider.CreateTagger<IErrorTag>(workspace.Documents.First().GetTextBuffer());
@@ -89,7 +89,7 @@ public async Task MultipleTaggersAndDispose()
         [WpfFact, Trait(Traits.Feature, Traits.Features.Diagnostics)]
         public async Task TaggerProviderCreatedAfterInitialDiagnosticsReported()
         {
-            using var workspace = TestWorkspace.CreateCSharp(new string[] { "class C {" }, CSharpParseOptions.Default);
+            using var workspace = TestWorkspace.CreateCSharp(new string[] { "class C {" }, parseOptions: CSharpParseOptions.Default);
             using var wrapper = new DiagnosticTaggerWrapper<DiagnosticsSquiggleTaggerProvider, IErrorTag>(workspace, analyzerMap: null, createTaggerProvider: false);
             // First, make sure all diagnostics have been reported.
             await wrapper.WaitForTags();
@@ -119,7 +119,7 @@ public async Task TestWithMockDiagnosticService_TaggerProviderCreatedBeforeIniti
 
             using var workspace = TestWorkspace.CreateCSharp(
                 new string[] { "class A { }" },
-                CSharpParseOptions.Default,
+                parseOptions: CSharpParseOptions.Default,
                 composition: s_compositionWithMockDiagnosticService);
 
             var listenerProvider = workspace.ExportProvider.GetExportedValue<IAsynchronousOperationListenerProvider>();
@@ -156,7 +156,7 @@ public async Task TestWithMockDiagnosticService_TaggerProviderCreatedAfterInitia
 
             using var workspace = TestWorkspace.CreateCSharp(
                 new string[] { "class A { }" },
-                CSharpParseOptions.Default,
+                parseOptions: CSharpParseOptions.Default,
                 composition: s_compositionWithMockDiagnosticService);
 
             var listenerProvider = workspace.ExportProvider.GetExportedValue<IAsynchronousOperationListenerProvider>();
diff --git a/src/EditorFeatures/TestUtilities/Workspaces/TestWorkspace_Create.cs b/src/EditorFeatures/TestUtilities/Workspaces/TestWorkspace_Create.cs
index 4fe217f35f5d9..5da952c24d78a 100644
--- a/src/EditorFeatures/TestUtilities/Workspaces/TestWorkspace_Create.cs
+++ b/src/EditorFeatures/TestUtilities/Workspaces/TestWorkspace_Create.cs
@@ -4,6 +4,7 @@
 
 #nullable disable
 
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
@@ -128,6 +129,7 @@ internal static TestWorkspace Create(
             CompilationOptions compilationOptions,
             ParseOptions parseOptions,
             string[] files,
+            string[] sourceGeneratedFiles = null,
             ExportProvider exportProvider = null,
             TestComposition composition = null,
             string[] metadataReferences = null,
@@ -137,7 +139,7 @@ internal static TestWorkspace Create(
             bool openDocuments = false,
             IDocumentServiceProvider documentServiceProvider = null)
         {
-            var workspaceElement = CreateWorkspaceElement(language, compilationOptions, parseOptions, files, metadataReferences, extension, commonReferences);
+            var workspaceElement = CreateWorkspaceElement(language, compilationOptions, parseOptions, files, sourceGeneratedFiles, metadataReferences, extension, commonReferences);
             return Create(workspaceElement, openDocuments, exportProvider, composition, workspaceKind, documentServiceProvider);
         }
 
@@ -193,11 +195,12 @@ public static TestWorkspace CreateCSharp(
             string[] metadataReferences = null,
             bool openDocuments = false)
         {
-            return CreateCSharp(new[] { file }, parseOptions, compilationOptions, exportProvider, composition, metadataReferences, openDocuments);
+            return CreateCSharp(new[] { file }, Array.Empty<string>(), parseOptions, compilationOptions, exportProvider, composition, metadataReferences, openDocuments);
         }
 
         public static TestWorkspace CreateCSharp(
             string[] files,
+            string[] sourceGeneratedFiles = null,
             ParseOptions parseOptions = null,
             CompilationOptions compilationOptions = null,
             ExportProvider exportProvider = null,
@@ -205,7 +208,7 @@ public static TestWorkspace CreateCSharp(
             string[] metadataReferences = null,
             bool openDocuments = false)
         {
-            return Create(LanguageNames.CSharp, compilationOptions, parseOptions, files, exportProvider, composition, metadataReferences, openDocuments: openDocuments);
+            return Create(LanguageNames.CSharp, compilationOptions, parseOptions, files, sourceGeneratedFiles, exportProvider, composition, metadataReferences, openDocuments: openDocuments);
         }
 
         public static TestWorkspace CreateCSharp2(
@@ -230,11 +233,12 @@ public static TestWorkspace CreateVisualBasic(
             string[] metadataReferences = null,
             bool openDocuments = false)
         {
-            return CreateVisualBasic(new[] { file }, parseOptions, compilationOptions, exportProvider, composition, metadataReferences, openDocuments);
+            return CreateVisualBasic(new[] { file }, Array.Empty<string>(), parseOptions, compilationOptions, exportProvider, composition, metadataReferences, openDocuments);
         }
 
         public static TestWorkspace CreateVisualBasic(
             string[] files,
+            string[] sourceGeneratedFiles = null,
             ParseOptions parseOptions = null,
             CompilationOptions compilationOptions = null,
             ExportProvider exportProvider = null,
@@ -242,7 +246,7 @@ public static TestWorkspace CreateVisualBasic(
             string[] metadataReferences = null,
             bool openDocuments = false)
         {
-            return Create(LanguageNames.VisualBasic, compilationOptions, parseOptions, files, exportProvider, composition, metadataReferences, openDocuments: openDocuments);
+            return Create(LanguageNames.VisualBasic, compilationOptions, parseOptions, files, sourceGeneratedFiles, exportProvider, composition, metadataReferences, openDocuments: openDocuments);
         }
 
         /// <param name="files">Can pass in multiple file contents with individual source kind: files will be named test1.vb, test2.vbx, etc.</param>
diff --git a/src/EditorFeatures/TestUtilities/Workspaces/TestWorkspace_XmlConsumption.cs b/src/EditorFeatures/TestUtilities/Workspaces/TestWorkspace_XmlConsumption.cs
index 09326b5f40882..bd2b15e80b91e 100644
--- a/src/EditorFeatures/TestUtilities/Workspaces/TestWorkspace_XmlConsumption.cs
+++ b/src/EditorFeatures/TestUtilities/Workspaces/TestWorkspace_XmlConsumption.cs
@@ -101,6 +101,7 @@ internal void InitializeDocuments(
                 compilationOptions,
                 parseOptions,
                 files,
+                sourceGeneratedFiles: Array.Empty<string>(),
                 metadataReferences,
                 extension,
                 commonReferences);
diff --git a/src/EditorFeatures/TestUtilities/Workspaces/TestWorkspace_XmlCreation.cs b/src/EditorFeatures/TestUtilities/Workspaces/TestWorkspace_XmlCreation.cs
index 0b7c578644977..6a10834bdce79 100644
--- a/src/EditorFeatures/TestUtilities/Workspaces/TestWorkspace_XmlCreation.cs
+++ b/src/EditorFeatures/TestUtilities/Workspaces/TestWorkspace_XmlCreation.cs
@@ -4,12 +4,10 @@
 
 #nullable disable
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Xml.Linq;
 using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.Text;
 using Microsoft.CodeAnalysis.VisualBasic;
 using Roslyn.Utilities;
 
@@ -22,23 +20,31 @@ internal static XElement CreateWorkspaceElement(
             CompilationOptions compilationOptions = null,
             ParseOptions parseOptions = null,
             string[] files = null,
+            string[] sourceGeneratedFiles = null,
             string[] metadataReferences = null,
             string extension = null,
             bool commonReferences = true)
         {
             var documentElements = new List<XElement>();
 
+            var index = 0;
+            extension ??= (language == LanguageNames.CSharp) ? CSharpExtension : VisualBasicExtension;
             if (files != null)
             {
-                var index = 0;
-                extension ??= (language == LanguageNames.CSharp) ? CSharpExtension : VisualBasicExtension;
-
                 foreach (var file in files)
                 {
                     documentElements.Add(CreateDocumentElement(file, GetDefaultTestSourceDocumentName(index++, extension), parseOptions));
                 }
             }
 
+            if (sourceGeneratedFiles != null)
+            {
+                foreach (var file in sourceGeneratedFiles)
+                {
+                    documentElements.Add(CreateDocumentFromSourceGeneratorElement(file, GetDefaultTestSourceDocumentName(index++, extension), parseOptions));
+                }
+            }
+
             if (metadataReferences != null)
             {
                 foreach (var reference in metadataReferences)
@@ -171,6 +177,14 @@ protected static XElement CreateDocumentElement(string code, string filePath, Pa
                 code.Replace("\r\n", "\n"));
         }
 
+        protected static XElement CreateDocumentFromSourceGeneratorElement(string code, string hintName, ParseOptions parseOptions = null)
+        {
+            return new XElement(DocumentFromSourceGeneratorElementName,
+                new XAttribute(FilePathAttributeName, hintName),
+                CreateParseOptionsElement(parseOptions),
+                code.Replace("\r\n", "\n"));
+        }
+
         private static XElement CreateParseOptionsElement(ParseOptions parseOptions)
         {
             return parseOptions == null
diff --git a/src/EditorFeatures/VisualBasicTest/Completion/CompletionProviders/CrefCompletionProviderTests.vb b/src/EditorFeatures/VisualBasicTest/Completion/CompletionProviders/CrefCompletionProviderTests.vb
index 3c809d3e366e1..6bc616e38ba64 100644
--- a/src/EditorFeatures/VisualBasicTest/Completion/CompletionProviders/CrefCompletionProviderTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/Completion/CompletionProviders/CrefCompletionProviderTests.vb
@@ -414,7 +414,7 @@ Class C
     End Sub
 End Class]]></a>.Value.NormalizeLineEndings()
 
-            Using workspace = TestWorkspace.Create(LanguageNames.VisualBasic, New VisualBasicCompilationOptions(OutputKind.ConsoleApplication), New VisualBasicParseOptions(), {text}, ExportProvider)
+            Using workspace = TestWorkspace.Create(LanguageNames.VisualBasic, New VisualBasicCompilationOptions(OutputKind.ConsoleApplication), New VisualBasicParseOptions(), {text}, exportProvider:=ExportProvider)
                 Dim called = False
 
                 Dim hostDocument = workspace.DocumentWithCursor

From 87283ea22556a220f4070f81b06e0f0d70d81706 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: Tue, 21 Dec 2021 19:15:40 -0800
Subject: [PATCH 163/444] Update to the latest debugger contracts. (#58433)

Pass PDB into ManagedHotReloadUpdate
---
 eng/Versions.props                                            | 4 ++--
 .../EditAndContinue/EditAndContinueLanguageService.cs         | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/eng/Versions.props b/eng/Versions.props
index a3fd15c6884d6..5532c98844f70 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -132,8 +132,8 @@
     <MicrosoftVisualStudioComponentModelHostVersion>$(VisualStudioEditorNewPackagesVersion)</MicrosoftVisualStudioComponentModelHostVersion>
     <MicrosoftVisualStudioCompositionVersion>16.9.20</MicrosoftVisualStudioCompositionVersion>
     <MicrosoftVisualStudioCoreUtilityVersion>$(VisualStudioEditorNewPackagesVersion)</MicrosoftVisualStudioCoreUtilityVersion>
-    <MicrosoftVisualStudioDebuggerUIInterfacesVersion>17.2.0-beta.21477.1</MicrosoftVisualStudioDebuggerUIInterfacesVersion>
-    <MicrosoftVisualStudioDebuggerContractsVersion>17.2.0-beta.21580.1</MicrosoftVisualStudioDebuggerContractsVersion>
+    <MicrosoftVisualStudioDebuggerUIInterfacesVersion>17.2.0-beta.21616.2</MicrosoftVisualStudioDebuggerUIInterfacesVersion>
+    <MicrosoftVisualStudioDebuggerContractsVersion>17.2.0-beta.21616.2</MicrosoftVisualStudioDebuggerContractsVersion>
     <MicrosoftVisualStudioDebuggerEngineimplementationVersion>17.0.1042805-preview</MicrosoftVisualStudioDebuggerEngineimplementationVersion>
     <MicrosoftVisualStudioDebuggerMetadataimplementationVersion>17.0.1042805-preview</MicrosoftVisualStudioDebuggerMetadataimplementationVersion>
     <MicrosoftVisualStudioDesignerInterfacesVersion>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftVisualStudioDesignerInterfacesVersion>
diff --git a/src/EditorFeatures/Core/Implementation/EditAndContinue/EditAndContinueLanguageService.cs b/src/EditorFeatures/Core/Implementation/EditAndContinue/EditAndContinueLanguageService.cs
index bab37ec4f33eb..707ce22218021 100644
--- a/src/EditorFeatures/Core/Implementation/EditAndContinue/EditAndContinueLanguageService.cs
+++ b/src/EditorFeatures/Core/Implementation/EditAndContinue/EditAndContinueLanguageService.cs
@@ -293,7 +293,7 @@ public async ValueTask<ManagedHotReloadUpdates> GetHotReloadUpdatesAsync(Cancell
             _pendingUpdatedSolution = solution;
 
             var updates = moduleUpdates.Updates.SelectAsArray(
-                update => new ManagedHotReloadUpdate(update.Module, update.ILDelta, update.MetadataDelta, update.UpdatedTypes));
+                update => new ManagedHotReloadUpdate(update.Module, update.ILDelta, update.MetadataDelta, update.PdbDelta, update.UpdatedTypes));
 
             var diagnostics = await EmitSolutionUpdateResults.GetHotReloadDiagnosticsAsync(solution, diagnosticData, rudeEdits, syntaxError, cancellationToken).ConfigureAwait(false);
 

From be874ec9fc872c37de1f81590ab5c2a415428bf2 Mon Sep 17 00:00:00 2001
From: Manish Vasani <mavasani@microsoft.com>
Date: Tue, 21 Dec 2021 21:24:41 -0800
Subject: [PATCH 164/444] Clear prior build errors for additional and analyzer
 config docs at start of build

Fixes [AB#1424584](https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1424584)

The primary issue is that the lingering compiler warning CS0169 from prior solution snapshot is reported in `Index.razor`, which is an Additional document, not a regular source document. Existing code in clearing build diagnostics at start of a build was only clearing diagnostics with location in source documents. Doing the same for additional documents fixes this issue.
---
 .../TaskList/ExternalErrorDiagnosticUpdateSource.cs             | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/TaskList/ExternalErrorDiagnosticUpdateSource.cs b/src/VisualStudio/Core/Def/Implementation/TaskList/ExternalErrorDiagnosticUpdateSource.cs
index 4488bddd0e8c8..b9facb2cb6f0d 100644
--- a/src/VisualStudio/Core/Def/Implementation/TaskList/ExternalErrorDiagnosticUpdateSource.cs
+++ b/src/VisualStudio/Core/Def/Implementation/TaskList/ExternalErrorDiagnosticUpdateSource.cs
@@ -383,7 +383,7 @@ private void ClearBuildOnlyProjectErrors(Solution solution, ProjectId? projectId
             }
 
             // Remove all document errors
-            foreach (var documentId in project.DocumentIds)
+            foreach (var documentId in project.DocumentIds.Concat(project.AdditionalDocumentIds).Concat(project.AnalyzerConfigDocumentIds))
             {
                 ClearBuildOnlyDocumentErrors(solution, projectId, documentId);
             }

From e343cb049b9c9050cd521412560c413737f0255d Mon Sep 17 00:00:00 2001
From: Manish Vasani <mavasani@microsoft.com>
Date: Tue, 21 Dec 2021 22:24:02 -0800
Subject: [PATCH 165/444] Fix MakeFieldReadonly false positive for ref
 assignments

Fixes #46785
Fixes #57983
---
 .../MakeFieldReadonlyTests.cs                 | 24 +++++++++++++++++--
 .../Core/Extensions/OperationExtensions.cs    |  6 +++++
 2 files changed, 28 insertions(+), 2 deletions(-)

diff --git a/src/Analyzers/CSharp/Tests/MakeFieldReadonly/MakeFieldReadonlyTests.cs b/src/Analyzers/CSharp/Tests/MakeFieldReadonly/MakeFieldReadonlyTests.cs
index 811f51493f746..9a7d768db6754 100644
--- a/src/Analyzers/CSharp/Tests/MakeFieldReadonly/MakeFieldReadonlyTests.cs
+++ b/src/Analyzers/CSharp/Tests/MakeFieldReadonly/MakeFieldReadonlyTests.cs
@@ -1717,13 +1717,13 @@ await TestInRegularAndScript1Async(
         }
 
         [WorkItem(46785, "https://github.com/dotnet/roslyn/issues/46785")]
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/46785"), Trait(Traits.Feature, Traits.Features.CodeActionsMakeFieldReadonly)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsMakeFieldReadonly)]
         public async Task UsedAsRef_NoDiagnostic()
         {
             await TestMissingInRegularAndScriptAsync(
 @"public class C
 {
-    private string [|_x|] = string.Empty;
+    private string [|x|] = string.Empty;
 
     public bool M()
     {
@@ -1733,6 +1733,26 @@ public bool M()
 }");
         }
 
+        [WorkItem(57983, "https://github.com/dotnet/roslyn/issues/57983")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsMakeFieldReadonly)]
+        public async Task UsedAsRef_NoDiagnostic_02()
+        {
+            await TestMissingInRegularAndScriptAsync(
+@"using System.Runtime.CompilerServices;
+
+public class Test
+{
+    private ulong [|nextD3D12ComputeFenceValue|];
+
+    internal void Repro()
+    {
+        ref ulong d3D12FenceValue = ref Unsafe.NullRef<ulong>();
+        d3D12FenceValue = ref nextD3D12ComputeFenceValue;
+        d3D12FenceValue++;
+    }
+}");
+        }
+
         [WorkItem(42760, "https://github.com/dotnet/roslyn/issues/42760")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsMakeFieldReadonly)]
         public async Task WithThreadStaticAttribute_NoDiagnostic()
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/OperationExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/OperationExtensions.cs
index 800e930574599..3bde34e3df8b5 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/OperationExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/OperationExtensions.cs
@@ -126,6 +126,12 @@ INegatedPatternOperation or
                     ? ValueUsageInfo.ReadWrite
                     : ValueUsageInfo.Write;
             }
+            else if (operation.Parent is ISimpleAssignmentOperation simpleAssignmentOperation &&
+                simpleAssignmentOperation.Value == operation &&
+                simpleAssignmentOperation.IsRef)
+            {
+                return ValueUsageInfo.ReadableWritableReference;
+            }
             else if (operation.Parent is IIncrementOrDecrementOperation)
             {
                 return ValueUsageInfo.ReadWrite;

From 3ae6b3c03a21e9ac954ff64a696cdb1da6d53306 Mon Sep 17 00:00:00 2001
From: Manish Vasani <mavasani@microsoft.com>
Date: Wed, 22 Dec 2021 00:05:46 -0800
Subject: [PATCH 166/444] Handle /warnaserror with Warning analyzer bulk
 configuration in editorconfig

Fixes batch compiler issue in #55541. I'll create a separate PR for the fix on IDE side
---
 .../Test/CommandLine/CommandLineTests.cs      | 19 ++++++++++++++++++-
 .../AnalyzerOptionsExtensions.cs              |  8 ++++++++
 2 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
index 7e18c0095c956..f660dbe8eb004 100644
--- a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
+++ b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
@@ -12479,6 +12479,11 @@ public void TestCategoryBasedBulkAnalyzerDiagnosticConfiguration(DiagnosticSever
 dotnet_analyzer_diagnostic.category-{category}.severity = error";
             TestBulkAnalyzerConfigurationCore(analyzer, analyzerConfigText, errorlog, expectedDiagnosticSeverity: ReportDiagnostic.Warn);
 
+            // Verify category based configuration to warning + /warnaserror reports errors.
+            analyzerConfigText = $@"
+[*.cs]
+dotnet_analyzer_diagnostic.category-{category}.severity = warning";
+            TestBulkAnalyzerConfigurationCore(analyzer, analyzerConfigText, errorlog, warnAsError: true, expectedDiagnosticSeverity: ReportDiagnostic.Error);
 
             // Verify disabled by default analyzer is not enabled by category based configuration.
             analyzer = new NamedTypeAnalyzerWithConfigurableEnabledByDefault(isEnabledByDefault: false, defaultSeverity);
@@ -12559,6 +12564,12 @@ public void TestBulkAnalyzerDiagnosticConfiguration(DiagnosticSeverity defaultSe
 dotnet_analyzer_diagnostic.severity = error";
             TestBulkAnalyzerConfigurationCore(analyzer, analyzerConfigText, errorlog, expectedDiagnosticSeverity: ReportDiagnostic.Warn);
 
+            // Verify bulk configuration to warning + /warnaserror reports errors.
+            analyzerConfigText = $@"
+[*.cs]
+dotnet_analyzer_diagnostic.severity = warning";
+            TestBulkAnalyzerConfigurationCore(analyzer, analyzerConfigText, errorlog, warnAsError: true, expectedDiagnosticSeverity: ReportDiagnostic.Error);
+
             // Verify disabled by default analyzer is not enabled by bulk configuration.
             analyzer = new NamedTypeAnalyzerWithConfigurableEnabledByDefault(isEnabledByDefault: false, defaultSeverity);
             analyzerConfigText = $@"
@@ -12636,7 +12647,8 @@ private void TestBulkAnalyzerConfigurationCore(
             bool errorlog,
             ReportDiagnostic expectedDiagnosticSeverity,
             string rulesetText = null,
-            bool noWarn = false)
+            bool noWarn = false,
+            bool warnAsError = false)
         {
             var diagnosticId = analyzer.Descriptor.Id;
             var dir = Temp.CreateDirectory();
@@ -12654,6 +12666,11 @@ private void TestBulkAnalyzerConfigurationCore(
                 arguments = arguments.Append($"/nowarn:{diagnosticId}");
             }
 
+            if (warnAsError)
+            {
+                arguments = arguments.Append($"/warnaserror");
+            }
+
             if (errorlog)
             {
                 arguments = arguments.Append($"/errorlog:errorlog");
diff --git a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerOptionsExtensions.cs b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerOptionsExtensions.cs
index c0f2fda23b531..1ef1e3684300a 100644
--- a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerOptionsExtensions.cs
+++ b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerOptionsExtensions.cs
@@ -66,6 +66,10 @@ public static bool TryGetSeverityFromBulkConfiguration(
             if (analyzerConfigOptions.TryGetValue(categoryBasedKey, out var value) &&
                 AnalyzerConfigSet.TryParseSeverity(value, out severity))
             {
+                // '/warnaserror' should bump Warning bulk configuration to Error.
+                if (severity == ReportDiagnostic.Warn && compilation.Options.GeneralDiagnosticOption == ReportDiagnostic.Error)
+                    severity = ReportDiagnostic.Error;
+
                 return true;
             }
 
@@ -74,6 +78,10 @@ public static bool TryGetSeverityFromBulkConfiguration(
             if (analyzerConfigOptions.TryGetValue(DotnetAnalyzerDiagnosticSeverityKey, out value) &&
                 AnalyzerConfigSet.TryParseSeverity(value, out severity))
             {
+                // '/warnaserror' should bump Warning bulk configuration to Error.
+                if (severity == ReportDiagnostic.Warn && compilation.Options.GeneralDiagnosticOption == ReportDiagnostic.Error)
+                    severity = ReportDiagnostic.Error;
+
                 return true;
             }
 

From 5a6a566c7542553eb3f126d618b8f84530f78f14 Mon Sep 17 00:00:00 2001
From: "dotnet-maestro[bot]"
 <42748379+dotnet-maestro[bot]@users.noreply.github.com>
Date: Wed, 22 Dec 2021 14:58:12 +0000
Subject: [PATCH 167/444] [main] Update dependencies from dotnet/arcade
 (#58408)

[main] Update dependencies from dotnet/arcade
---
 eng/Version.Details.xml              | 8 ++++----
 eng/common/dotnet-install.sh         | 3 +++
 eng/common/native/CommonLibrary.psm1 | 3 ++-
 global.json                          | 4 ++--
 4 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index 85896ac039e85..fd98a9b586b16 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -13,18 +13,18 @@
     </Dependency>
   </ProductDependencies>
   <ToolsetDependencies>
-    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="7.0.0-beta.21615.1">
+    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="7.0.0-beta.21621.3">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>943d03f62955c771825dfa1f1bdeb8f853a2d7dd</Sha>
+      <Sha>0cd94b1d02c03377d99f3739beb191591f6abee5</Sha>
       <SourceBuild RepoName="arcade" ManagedOnly="true" />
     </Dependency>
     <Dependency Name="Microsoft.Net.Compilers.Toolset" Version="4.1.0-2.21609.7">
       <Uri>https://github.com/dotnet/roslyn</Uri>
       <Sha>818313426323d979747781a17c78860c833776da</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="7.0.0-beta.21615.1">
+    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="7.0.0-beta.21621.3">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>943d03f62955c771825dfa1f1bdeb8f853a2d7dd</Sha>
+      <Sha>0cd94b1d02c03377d99f3739beb191591f6abee5</Sha>
     </Dependency>
   </ToolsetDependencies>
 </Dependencies>
diff --git a/eng/common/dotnet-install.sh b/eng/common/dotnet-install.sh
index fdfeea66e7d43..5c94e98632a0a 100755
--- a/eng/common/dotnet-install.sh
+++ b/eng/common/dotnet-install.sh
@@ -55,6 +55,9 @@ case $cpuname in
   aarch64)
     buildarch=arm64
     ;;
+  loongarch64)
+    buildarch=loongarch64
+    ;;
   amd64|x86_64)
     buildarch=x64
     ;;
diff --git a/eng/common/native/CommonLibrary.psm1 b/eng/common/native/CommonLibrary.psm1
index adf707c8fe700..ca38268c44d83 100644
--- a/eng/common/native/CommonLibrary.psm1
+++ b/eng/common/native/CommonLibrary.psm1
@@ -276,7 +276,8 @@ function Get-MachineArchitecture {
   }
   if (($ProcessorArchitecture -Eq "AMD64") -Or
       ($ProcessorArchitecture -Eq "IA64") -Or
-      ($ProcessorArchitecture -Eq "ARM64")) {
+      ($ProcessorArchitecture -Eq "ARM64") -Or
+      ($ProcessorArchitecture -Eq "LOONGARCH64")) {
     return "x64"
   }
   return "x86"
diff --git a/global.json b/global.json
index fd86f0793bb3e..02b28209e68ee 100644
--- a/global.json
+++ b/global.json
@@ -12,7 +12,7 @@
     "xcopy-msbuild": "16.10.0-preview2"
   },
   "msbuild-sdks": {
-    "Microsoft.DotNet.Arcade.Sdk": "7.0.0-beta.21615.1",
-    "Microsoft.DotNet.Helix.Sdk": "7.0.0-beta.21615.1"
+    "Microsoft.DotNet.Arcade.Sdk": "7.0.0-beta.21621.3",
+    "Microsoft.DotNet.Helix.Sdk": "7.0.0-beta.21621.3"
   }
 }

From d589d90acb9165bd3834e6e6d213df629d807c16 Mon Sep 17 00:00:00 2001
From: "dotnet-maestro[bot]"
 <42748379+dotnet-maestro[bot]@users.noreply.github.com>
Date: Thu, 23 Dec 2021 14:59:32 +0000
Subject: [PATCH 168/444] Update dependencies from
 https://github.com/dotnet/arcade build 20211223.1 (#58471)

[main] Update dependencies from dotnet/arcade
---
 eng/Version.Details.xml | 8 ++++----
 global.json             | 4 ++--
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index fd98a9b586b16..61ea8dfc0871d 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -13,18 +13,18 @@
     </Dependency>
   </ProductDependencies>
   <ToolsetDependencies>
-    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="7.0.0-beta.21621.3">
+    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="7.0.0-beta.21623.1">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>0cd94b1d02c03377d99f3739beb191591f6abee5</Sha>
+      <Sha>4abaab2bf44d06638abeb23fc96c4f6eef58a2f0</Sha>
       <SourceBuild RepoName="arcade" ManagedOnly="true" />
     </Dependency>
     <Dependency Name="Microsoft.Net.Compilers.Toolset" Version="4.1.0-2.21609.7">
       <Uri>https://github.com/dotnet/roslyn</Uri>
       <Sha>818313426323d979747781a17c78860c833776da</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="7.0.0-beta.21621.3">
+    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="7.0.0-beta.21623.1">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>0cd94b1d02c03377d99f3739beb191591f6abee5</Sha>
+      <Sha>4abaab2bf44d06638abeb23fc96c4f6eef58a2f0</Sha>
     </Dependency>
   </ToolsetDependencies>
 </Dependencies>
diff --git a/global.json b/global.json
index 02b28209e68ee..59c01b0b4680d 100644
--- a/global.json
+++ b/global.json
@@ -12,7 +12,7 @@
     "xcopy-msbuild": "16.10.0-preview2"
   },
   "msbuild-sdks": {
-    "Microsoft.DotNet.Arcade.Sdk": "7.0.0-beta.21621.3",
-    "Microsoft.DotNet.Helix.Sdk": "7.0.0-beta.21621.3"
+    "Microsoft.DotNet.Arcade.Sdk": "7.0.0-beta.21623.1",
+    "Microsoft.DotNet.Helix.Sdk": "7.0.0-beta.21623.1"
   }
 }

From 678b269e0e31a1b31ed1dfc74b464929218b7039 Mon Sep 17 00:00:00 2001
From: David Wengier <david.wengier@microsoft.com>
Date: Fri, 24 Dec 2021 12:46:12 +1100
Subject: [PATCH 169/444] Support top level statements in event hookup (#58475)

---
 ...EventHookupCommandHandler_TabKeyCommand.cs | 18 +++++++++----
 .../EventHookupCommandHandlerTests.cs         | 25 +++++++++++++++++++
 2 files changed, 38 insertions(+), 5 deletions(-)

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
index 76dc07e72e453..9217c543dad2b 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
@@ -186,9 +186,10 @@ private static Document AddMethodNameAndAnnotationsToSolution(
             var root = document.GetSyntaxRootSynchronously(cancellationToken);
             var plusEqualsToken = root.FindTokenOnLeftOfPosition(position);
             var eventHookupExpression = plusEqualsToken.GetAncestor<AssignmentExpressionSyntax>();
+            var typeDecl = eventHookupExpression.GetAncestor<TypeDeclarationSyntax>();
 
             var textToInsert = eventHandlerMethodName + ";";
-            if (!eventHookupExpression.IsInStaticContext())
+            if (!eventHookupExpression.IsInStaticContext() && typeDecl is not null)
             {
                 // This will be simplified later if it's not needed.
                 textToInsert = "this." + textToInsert;
@@ -222,24 +223,30 @@ private static SyntaxNode AddGeneratedHandlerMethodToSolution(
             var root = document.Root;
             var eventHookupExpression = root.GetAnnotatedNodesAndTokens(plusEqualsTokenAnnotation).Single().AsToken().GetAncestor<AssignmentExpressionSyntax>();
 
-            var generatedMethodSymbol = GetMethodSymbol(document, eventHandlerMethodName, eventHookupExpression, cancellationToken);
+            var typeDecl = eventHookupExpression.GetAncestor<TypeDeclarationSyntax>();
+            var methodKind = typeDecl is null
+                ? MethodKind.LocalFunction
+                : MethodKind.Ordinary;
+
+            var generatedMethodSymbol = GetMethodSymbol(document, eventHandlerMethodName, eventHookupExpression, methodKind, cancellationToken);
 
             if (generatedMethodSymbol == null)
             {
                 return null;
             }
 
-            var typeDecl = eventHookupExpression.GetAncestor<TypeDeclarationSyntax>();
+            var container = (SyntaxNode)typeDecl ?? eventHookupExpression.GetAncestor<CompilationUnitSyntax>();
 
-            var typeDeclWithMethodAdded = CodeGenerator.AddMethodDeclaration(typeDecl, generatedMethodSymbol, document.Project.Solution.Workspace, new CodeGenerationOptions(afterThisLocation: eventHookupExpression.GetLocation()));
+            var newContainer = CodeGenerator.AddMethodDeclaration(container, generatedMethodSymbol, document.Project.Solution.Workspace, new CodeGenerationOptions(afterThisLocation: eventHookupExpression.GetLocation()));
 
-            return root.ReplaceNode(typeDecl, typeDeclWithMethodAdded);
+            return root.ReplaceNode(container, newContainer);
         }
 
         private static IMethodSymbol GetMethodSymbol(
             SemanticDocument semanticDocument,
             string eventHandlerMethodName,
             AssignmentExpressionSyntax eventHookupExpression,
+            MethodKind methodKind,
             CancellationToken cancellationToken)
         {
             var semanticModel = semanticDocument.SemanticModel;
@@ -271,6 +278,7 @@ private static IMethodSymbol GetMethodSymbol(
                 name: eventHandlerMethodName,
                 typeParameters: default,
                 parameters: delegateInvokeMethod.Parameters,
+                methodKind: methodKind,
                 statements: ImmutableArray.Create(
                     CodeGenerationHelpers.GenerateThrowStatement(syntaxFactory, semanticDocument, "System.NotImplementedException")));
         }
diff --git a/src/EditorFeatures/CSharpTest/EventHookup/EventHookupCommandHandlerTests.cs b/src/EditorFeatures/CSharpTest/EventHookup/EventHookupCommandHandlerTests.cs
index 6fbb7e3cbe8fb..2cf1fe41ca81a 100644
--- a/src/EditorFeatures/CSharpTest/EventHookup/EventHookupCommandHandlerTests.cs
+++ b/src/EditorFeatures/CSharpTest/EventHookup/EventHookupCommandHandlerTests.cs
@@ -1024,6 +1024,31 @@ private void C_MyEvent()
             testState.AssertCodeIs(expectedCode);
         }
 
+        [WpfFact, Trait(Traits.Feature, Traits.Features.EventHookup)]
+        [WorkItem(58474, "https://github.com/dotnet/roslyn/issues/58474")]
+        public async Task EventHookupInTopLevelCode()
+        {
+            var markup = @"
+
+System.AppDomain.CurrentDomain.UnhandledException +$$
+
+";
+            using var testState = EventHookupTestState.CreateTestState(markup);
+            testState.SendTypeChar('=');
+            testState.SendTab();
+            await testState.WaitForAsynchronousOperationsAsync();
+
+            var expectedCode = @"
+
+System.AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
+
+void CurrentDomain_UnhandledException(object sender, System.UnhandledExceptionEventArgs e)
+{
+    throw new System.NotImplementedException();
+}";
+            testState.AssertCodeIs(expectedCode);
+        }
+
         private static OptionsCollection QualifyMethodAccessWithNotification(NotificationOption2 notification)
             => new OptionsCollection(LanguageNames.CSharp) { { CodeStyleOptions2.QualifyMethodAccess, true, notification } };
     }

From 8fb8592fcf5637eb4bc04c1fced5e585b821d445 Mon Sep 17 00:00:00 2001
From: David Wengier <david.wengier@microsoft.com>
Date: Fri, 24 Dec 2021 16:14:27 +1100
Subject: [PATCH 170/444] Fix event hookup at the end of a document (#58477)

---
 .../EventHookup/EventHookupSessionManager.cs  | 24 +++++++++++++-
 ...HookupSessionManager_EventHookupSession.cs |  5 ++-
 .../EventHookupCommandHandlerTests.cs         | 31 +++++++++++++++++++
 3 files changed, 58 insertions(+), 2 deletions(-)

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs
index 570b58457add4..de8b8614f8726 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs
@@ -50,7 +50,7 @@ internal void EventHookupFoundInSession(EventHookupSession analyzedSession)
             if (_toolTipPresenter == null &&
                 CurrentSession == analyzedSession &&
                 caretPoint.HasValue &&
-                analyzedSession.TrackingSpan.GetSpan(CurrentSession.TextView.TextSnapshot).Contains(caretPoint.Value))
+                IsCaretWithinSpanOrAtEnd(analyzedSession.TrackingSpan, analyzedSession.TextView.TextSnapshot, caretPoint.Value))
             {
                 // Create a tooltip presenter that stays alive, even when the user types, without tracking the mouse.
                 _toolTipPresenter = _toolTipService.CreatePresenter(analyzedSession.TextView,
@@ -80,6 +80,28 @@ internal void EventHookupFoundInSession(EventHookupSession analyzedSession)
             }
         }
 
+        private static bool IsCaretWithinSpanOrAtEnd(ITrackingSpan trackingSpan, ITextSnapshot textSnapshot, SnapshotPoint caretPoint)
+        {
+            var snapshotSpan = trackingSpan.GetSpan(textSnapshot);
+
+            // If the caret is within the span, then we want to show the tooltip
+            if (snapshotSpan.Contains(caretPoint))
+            {
+                return true;
+            }
+
+            // Otherwise if the span is empty, and at the end of the file, and the caret
+            // is also at the end of the file, then show the tooltip.
+            if (snapshotSpan.IsEmpty &&
+                snapshotSpan.Start.Position == caretPoint.Position &&
+                caretPoint.Position == textSnapshot.Length)
+            {
+                return true;
+            }
+
+            return false;
+        }
+
         internal void BeginSession(
             EventHookupCommandHandler eventHookupCommandHandler,
             ITextView textView,
diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs
index e7f4f2bcbcfff..12dbd69c81d9e 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs
@@ -114,7 +114,10 @@ public EventHookupSession(
                 {
                     var position = textView.GetCaretPoint(subjectBuffer).Value.Position;
                     _trackingPoint = textView.TextSnapshot.CreateTrackingPoint(position, PointTrackingMode.Negative);
-                    _trackingSpan = textView.TextSnapshot.CreateTrackingSpan(new Span(position, 1), 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");
 
diff --git a/src/EditorFeatures/CSharpTest/EventHookup/EventHookupCommandHandlerTests.cs b/src/EditorFeatures/CSharpTest/EventHookup/EventHookupCommandHandlerTests.cs
index 2cf1fe41ca81a..0d57db3ad040d 100644
--- a/src/EditorFeatures/CSharpTest/EventHookup/EventHookupCommandHandlerTests.cs
+++ b/src/EditorFeatures/CSharpTest/EventHookup/EventHookupCommandHandlerTests.cs
@@ -1042,6 +1042,37 @@ public async Task EventHookupInTopLevelCode()
 
 System.AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
 
+void CurrentDomain_UnhandledException(object sender, System.UnhandledExceptionEventArgs e)
+{
+    throw new System.NotImplementedException();
+}";
+            testState.AssertCodeIs(expectedCode);
+        }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.EventHookup)]
+        public async Task EventHookupAtEndOfDocument()
+        {
+            var markup = @"
+
+System.AppDomain.CurrentDomain.UnhandledException +$$";
+            using var testState = EventHookupTestState.CreateTestState(markup);
+            testState.SendTypeChar('=');
+
+            await testState.WaitForAsynchronousOperationsAsync();
+            testState.AssertShowing("CurrentDomain_UnhandledException");
+
+            var expectedCode = @"
+
+System.AppDomain.CurrentDomain.UnhandledException +=";
+            testState.AssertCodeIs(expectedCode);
+
+            testState.SendTab();
+            await testState.WaitForAsynchronousOperationsAsync();
+
+            expectedCode = @"
+
+System.AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
+
 void CurrentDomain_UnhandledException(object sender, System.UnhandledExceptionEventArgs e)
 {
     throw new System.NotImplementedException();

From 6e9947a83bc6eeb4b4bedca44d4b91523f12a3f1 Mon Sep 17 00:00:00 2001
From: Manish Vasani <mavasani@microsoft.com>
Date: Thu, 23 Dec 2021 21:35:17 -0800
Subject: [PATCH 171/444] Enqueue additional and analyzer config documents in
 WorkCoordinator

Fixes #53192
Currently, work coordinator only enqueues source document IDs for project analysis work items. This means we don't analyze the additional documents, which can now report standalone diagnostics through RegisterAdditionalFileAction. This PR fixes this by enqueuing project's additional document IDs and analyzer config document IDs.
---
 .../SolutionCrawler/WorkCoordinatorTests.cs   | 25 ++++++++++++++++++-
 .../SolutionCrawler/WorkCoordinator.cs        |  5 ++--
 2 files changed, 27 insertions(+), 3 deletions(-)

diff --git a/src/EditorFeatures/Test/SolutionCrawler/WorkCoordinatorTests.cs b/src/EditorFeatures/Test/SolutionCrawler/WorkCoordinatorTests.cs
index 2bb8424b5110d..955e649141d88 100644
--- a/src/EditorFeatures/Test/SolutionCrawler/WorkCoordinatorTests.cs
+++ b/src/EditorFeatures/Test/SolutionCrawler/WorkCoordinatorTests.cs
@@ -335,6 +335,8 @@ internal async Task Project_AnalyzerOptions_Change(BackgroundAnalysisScope analy
 
             Assert.Equal(expectedDocumentEvents, worker.SyntaxDocumentIds.Count);
             Assert.Equal(expectedDocumentEvents, worker.DocumentIds.Count);
+
+            Assert.Equal(1, worker.NonSourceDocumentIds.Count);
         }
 
         [InlineData(BackgroundAnalysisScope.ActiveFile, false)]
@@ -701,22 +703,26 @@ internal async Task Document_AdditionalFileChange(BackgroundAnalysisScope analys
 
             var expectedDocumentSyntaxEvents = 5;
             var expectedDocumentSemanticEvents = 5;
+            var expectedNonSourceDocumentEvents = 1;
 
             var ncfile = DocumentInfo.Create(DocumentId.CreateNewId(project.Id), "D6");
 
             var worker = await ExecuteOperation(workspace, w => w.OnAdditionalDocumentAdded(ncfile));
             Assert.Equal(expectedDocumentSyntaxEvents, worker.SyntaxDocumentIds.Count);
             Assert.Equal(expectedDocumentSemanticEvents, worker.DocumentIds.Count);
+            Assert.Equal(expectedNonSourceDocumentEvents, worker.NonSourceDocumentIds.Count);
 
             worker = await ExecuteOperation(workspace, w => w.ChangeAdditionalDocument(ncfile.Id, SourceText.From("//")));
 
             Assert.Equal(expectedDocumentSyntaxEvents, worker.SyntaxDocumentIds.Count);
             Assert.Equal(expectedDocumentSemanticEvents, worker.DocumentIds.Count);
+            Assert.Equal(expectedNonSourceDocumentEvents, worker.NonSourceDocumentIds.Count);
 
             worker = await ExecuteOperation(workspace, w => w.OnAdditionalDocumentRemoved(ncfile.Id));
 
             Assert.Equal(expectedDocumentSyntaxEvents, worker.SyntaxDocumentIds.Count);
             Assert.Equal(expectedDocumentSemanticEvents, worker.DocumentIds.Count);
+            Assert.Empty(worker.NonSourceDocumentIds);
         }
 
         [InlineData(BackgroundAnalysisScope.ActiveFile, false)]
@@ -1619,7 +1625,7 @@ internal static class Metadata
             public static readonly IncrementalAnalyzerProviderMetadata Crawler = new IncrementalAnalyzerProviderMetadata(new Dictionary<string, object> { { "WorkspaceKinds", new[] { SolutionCrawlerWorkspaceKind } }, { "HighPriorityForActiveFile", false }, { "Name", "TestAnalyzer" } });
         }
 
-        private class Analyzer : IIncrementalAnalyzer
+        private class Analyzer : IIncrementalAnalyzer2
         {
             public static readonly Option<bool> TestOption = new Option<bool>("TestOptions", "TestOption", defaultValue: true);
 
@@ -1628,6 +1634,7 @@ private class Analyzer : IIncrementalAnalyzer
 
             public readonly HashSet<DocumentId> SyntaxDocumentIds = new HashSet<DocumentId>();
             public readonly HashSet<DocumentId> DocumentIds = new HashSet<DocumentId>();
+            public readonly HashSet<DocumentId> NonSourceDocumentIds = new HashSet<DocumentId>();
             public readonly HashSet<ProjectId> ProjectIds = new HashSet<ProjectId>();
 
             public readonly HashSet<DocumentId> InvalidateDocumentIds = new HashSet<DocumentId>();
@@ -1653,6 +1660,7 @@ public void Reset()
 
                 SyntaxDocumentIds.Clear();
                 DocumentIds.Clear();
+                NonSourceDocumentIds.Clear();
                 ProjectIds.Clear();
 
                 InvalidateDocumentIds.Clear();
@@ -1682,6 +1690,12 @@ public Task AnalyzeSyntaxAsync(Document document, InvocationReasons reasons, Can
                 return Task.CompletedTask;
             }
 
+            public Task AnalyzeNonSourceDocumentAsync(TextDocument textDocument, InvocationReasons reasons, CancellationToken cancellationToken)
+            {
+                this.NonSourceDocumentIds.Add(textDocument.Id);
+                return Task.CompletedTask;
+            }
+
             public Task RemoveDocumentAsync(DocumentId documentId, CancellationToken cancellationToken)
             {
                 InvalidateDocumentIds.Add(documentId);
@@ -1732,6 +1746,15 @@ public Task DocumentCloseAsync(Document document, CancellationToken cancellation
 
             public Task DocumentResetAsync(Document document, CancellationToken cancellationToken)
                 => Task.CompletedTask;
+
+            public Task NonSourceDocumentOpenAsync(TextDocument textDocument, CancellationToken cancellationToken)
+                => Task.CompletedTask;
+
+            public Task NonSourceDocumentCloseAsync(TextDocument textDocument, CancellationToken cancellationToken)
+                => Task.CompletedTask;
+
+            public Task NonSourceDocumentResetAsync(TextDocument textDocument, CancellationToken cancellationToken)
+                => Task.CompletedTask;
             #endregion
         }
 
diff --git a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
index 0a3a83b8c8615..81daf1f3cb999 100644
--- a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
+++ b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
@@ -439,7 +439,8 @@ private async Task EnqueueWorkItemAsync(Project project, DocumentId documentId,
                 _shutdownToken.ThrowIfCancellationRequested();
 
                 var priorityService = project.GetLanguageService<IWorkCoordinatorPriorityService>();
-                var isLowPriority = priorityService != null && await priorityService.IsLowPriorityAsync(GetRequiredDocument(project, documentId, document), _shutdownToken).ConfigureAwait(false);
+                document ??= project.GetDocument(documentId);
+                var isLowPriority = priorityService != null && document != null && await priorityService.IsLowPriorityAsync(document, _shutdownToken).ConfigureAwait(false);
 
                 var currentMember = GetSyntaxPath(changedMember);
 
@@ -473,7 +474,7 @@ private static Document GetRequiredDocument(Project project, DocumentId document
 
             private async Task EnqueueWorkItemAsync(Project project, InvocationReasons invocationReasons)
             {
-                foreach (var documentId in project.DocumentIds)
+                foreach (var documentId in project.DocumentIds.Concat(project.AdditionalDocumentIds).Concat(project.AnalyzerConfigDocumentIds))
                     await EnqueueWorkItemAsync(project, documentId, document: null, invocationReasons).ConfigureAwait(false);
             }
 

From ce24c9023757bf243b9b32b00abfadb0ddb8b43b Mon Sep 17 00:00:00 2001
From: Manish Vasani <mavasani@microsoft.com>
Date: Thu, 23 Dec 2021 22:20:10 -0800
Subject: [PATCH 172/444] Fix unused param (IDE0060) false positive

Fixes #56317
#42408 handled bailing out reporting unused params for methods that only have a throw operation in its body. It missed a case where the throw might be wrapped within a conversion wrapped within a return operation, which happens when the method returns a non-void type.
---
 .../RemoveUnusedParametersTests.cs            | 30 +++++++++++++++++++
 ...lyzer.SymbolStartAnalyzer.BlockAnalyzer.cs | 13 ++++++--
 .../Core/Extensions/OperationExtensions.cs    | 15 ++++++++++
 3 files changed, 56 insertions(+), 2 deletions(-)

diff --git a/src/Analyzers/CSharp/Tests/RemoveUnusedParametersAndValues/RemoveUnusedParametersTests.cs b/src/Analyzers/CSharp/Tests/RemoveUnusedParametersAndValues/RemoveUnusedParametersTests.cs
index 2ba5d60c76a3e..d65a510d172c2 100644
--- a/src/Analyzers/CSharp/Tests/RemoveUnusedParametersAndValues/RemoveUnusedParametersTests.cs
+++ b/src/Analyzers/CSharp/Tests/RemoveUnusedParametersAndValues/RemoveUnusedParametersTests.cs
@@ -1503,6 +1503,36 @@ public C(int [|i|])
 }");
         }
 
+        [WorkItem(56317, "https://github.com/dotnet/roslyn/issues/56317")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnusedParameters)]
+        public async Task NotImplementedException_NoDiagnostic4()
+        {
+            await TestDiagnosticMissingAsync(
+@"using System;
+
+class C
+{
+    private int Goo(int [|i|])
+        => throw new NotImplementedException();
+}");
+        }
+
+        [WorkItem(56317, "https://github.com/dotnet/roslyn/issues/56317")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnusedParameters)]
+        public async Task NotImplementedException_NoDiagnostic5()
+        {
+            await TestDiagnosticMissingAsync(
+@"using System;
+
+class C
+{
+    private int Goo(int [|i|])
+    {
+        throw new NotImplementedException();
+    }
+}");
+        }
+
         [WorkItem(41236, "https://github.com/dotnet/roslyn/issues/41236")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnusedParameters)]
         public async Task NotImplementedException_MultipleStatements1()
diff --git a/src/Analyzers/Core/Analyzers/RemoveUnusedParametersAndValues/AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs b/src/Analyzers/Core/Analyzers/RemoveUnusedParametersAndValues/AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs
index f110f9e90fdb9..54e1f0deb591e 100644
--- a/src/Analyzers/Core/Analyzers/RemoveUnusedParametersAndValues/AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/RemoveUnusedParametersAndValues/AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs
@@ -152,9 +152,18 @@ static bool IsSingleThrowNotImplementedOperation(IOperation firstBlock)
                         if (firstOp == null)
                             return false;
 
-                        // unwrap: { throw new NYI(); }
                         if (firstOp is IExpressionStatementOperation expressionStatement)
+                        {
+                            // unwrap: { throw new NYI(); }
                             firstOp = expressionStatement.Operation;
+                        }
+                        else if (firstOp is IReturnOperation returnOperation)
+                        {
+                            // unwrap: 'int M(int p) => throw new NYI();'
+                            // For this case, the throw operation is wrapped within a conversion operation to 'int',
+                            // which in turn is wrapped within a return operation.
+                            firstOp = returnOperation.ReturnedValue.WalkDownConversion();
+                        }
 
                         // => throw new NotImplementedOperation(...)
                         return IsThrowNotImplementedOperation(notImplementedExceptionType, firstOp);
@@ -177,7 +186,7 @@ static bool IsSingleThrowNotImplementedOperation(IOperation firstBlock)
                         return firstOp;
                     }
 
-                    static bool IsThrowNotImplementedOperation(INamedTypeSymbol notImplementedExceptionType, IOperation operation)
+                    static bool IsThrowNotImplementedOperation(INamedTypeSymbol notImplementedExceptionType, IOperation? operation)
                         => operation is IThrowOperation throwOperation &&
                            UnwrapImplicitConversion(throwOperation.Exception) is IObjectCreationOperation objectCreation &&
                            notImplementedExceptionType.Equals(objectCreation.Type);
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/OperationExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/OperationExtensions.cs
index 3bde34e3df8b5..5829096471015 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/OperationExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/OperationExtensions.cs
@@ -370,5 +370,20 @@ public static bool IsNumericLiteral(this IOperation operation)
 
         public static bool IsNullLiteral(this IOperation operand)
             => operand is ILiteralOperation { ConstantValue: { HasValue: true, Value: null } };
+
+        /// <summary>
+        /// Walks down consecutive conversion operations until an operand is reached that isn't a conversion operation.
+        /// </summary>
+        /// <param name="operation">The starting operation.</param>
+        /// <returns>The inner non conversion operation or the starting operation if it wasn't a conversion operation.</returns>
+        public static IOperation WalkDownConversion(this IOperation? operation)
+        {
+            while (operation is IConversionOperation conversionOperation)
+            {
+                operation = conversionOperation.Operand;
+            }
+
+            return operation;
+        }
     }
 }

From bbb2c26f15179e95560b061541e835364b4de51b Mon Sep 17 00:00:00 2001
From: Manish Vasani <mavasani@microsoft.com>
Date: Thu, 23 Dec 2021 22:29:52 -0800
Subject: [PATCH 173/444] Address feedback

---
 .../Core/Portable/SolutionCrawler/WorkCoordinator.cs      | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
index 81daf1f3cb999..5be133bc20d64 100644
--- a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
+++ b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
@@ -474,7 +474,13 @@ private static Document GetRequiredDocument(Project project, DocumentId document
 
             private async Task EnqueueWorkItemAsync(Project project, InvocationReasons invocationReasons)
             {
-                foreach (var documentId in project.DocumentIds.Concat(project.AdditionalDocumentIds).Concat(project.AnalyzerConfigDocumentIds))
+                foreach (var documentId in project.DocumentIds)
+                    await EnqueueWorkItemAsync(project, documentId, document: null, invocationReasons).ConfigureAwait(false);
+
+                foreach (var documentId in project.AdditionalDocumentIds)
+                    await EnqueueWorkItemAsync(project, documentId, document: null, invocationReasons).ConfigureAwait(false);
+
+                foreach (var documentId in project.AnalyzerConfigDocumentIds)
                     await EnqueueWorkItemAsync(project, documentId, document: null, invocationReasons).ConfigureAwait(false);
             }
 

From e7b9d146544a3f71ffdb008cbf7e3856f5d0e29a Mon Sep 17 00:00:00 2001
From: Manish Vasani <mavasani@microsoft.com>
Date: Thu, 23 Dec 2021 22:39:15 -0800
Subject: [PATCH 174/444] Fix build

---
 .../Compiler/Core/Extensions/OperationExtensions.cs             | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/OperationExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/OperationExtensions.cs
index 5829096471015..b9027c0239b53 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/OperationExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/OperationExtensions.cs
@@ -376,7 +376,7 @@ public static bool IsNullLiteral(this IOperation operand)
         /// </summary>
         /// <param name="operation">The starting operation.</param>
         /// <returns>The inner non conversion operation or the starting operation if it wasn't a conversion operation.</returns>
-        public static IOperation WalkDownConversion(this IOperation? operation)
+        public static IOperation? WalkDownConversion(this IOperation? operation)
         {
             while (operation is IConversionOperation conversionOperation)
             {

From 9f3de42345b7ae1f6db28ce3822b7a3ae3136475 Mon Sep 17 00:00:00 2001
From: Youssef Victor <youssefvictor00@gmail.com>
Date: Fri, 24 Dec 2021 13:21:12 +0200
Subject: [PATCH 175/444] draft (#58481)

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

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
index 9217c543dad2b..a66120dc6f69e 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
@@ -224,11 +224,8 @@ private static SyntaxNode AddGeneratedHandlerMethodToSolution(
             var eventHookupExpression = root.GetAnnotatedNodesAndTokens(plusEqualsTokenAnnotation).Single().AsToken().GetAncestor<AssignmentExpressionSyntax>();
 
             var typeDecl = eventHookupExpression.GetAncestor<TypeDeclarationSyntax>();
-            var methodKind = typeDecl is null
-                ? MethodKind.LocalFunction
-                : MethodKind.Ordinary;
 
-            var generatedMethodSymbol = GetMethodSymbol(document, eventHandlerMethodName, eventHookupExpression, methodKind, cancellationToken);
+            var generatedMethodSymbol = GetMethodSymbol(document, eventHandlerMethodName, eventHookupExpression, cancellationToken);
 
             if (generatedMethodSymbol == null)
             {
@@ -246,7 +243,6 @@ private static IMethodSymbol GetMethodSymbol(
             SemanticDocument semanticDocument,
             string eventHandlerMethodName,
             AssignmentExpressionSyntax eventHookupExpression,
-            MethodKind methodKind,
             CancellationToken cancellationToken)
         {
             var semanticModel = semanticDocument.SemanticModel;
@@ -278,7 +274,6 @@ private static IMethodSymbol GetMethodSymbol(
                 name: eventHandlerMethodName,
                 typeParameters: default,
                 parameters: delegateInvokeMethod.Parameters,
-                methodKind: methodKind,
                 statements: ImmutableArray.Create(
                     CodeGenerationHelpers.GenerateThrowStatement(syntaxFactory, semanticDocument, "System.NotImplementedException")));
         }

From 4f839eb8f4f8cd28512010b0ca30047fb03820f4 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Fri, 24 Dec 2021 08:37:31 -0800
Subject: [PATCH 176/444] Enable Smart Indenter test which is already passing

---
 .../CSharpTest/Formatting/Indentation/SmartIndenterTests.cs     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartIndenterTests.cs b/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartIndenterTests.cs
index 3a473b0449f46..e4a68a4baae37 100644
--- a/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartIndenterTests.cs
+++ b/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartIndenterTests.cs
@@ -2000,7 +2000,7 @@ static void Main(string[] args)
 
         [WorkItem(648068, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/648068")]
         [WorkItem(674611, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/674611")]
-        [WpfFact(Skip = "674611"), Trait(Traits.Feature, Traits.Features.SmartIndent), Trait(Traits.Feature, Traits.Features.Venus)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.SmartIndent), Trait(Traits.Feature, Traits.Features.Venus)]
         public void AtBeginningOfSpanInNugget()
         {
             var markup = @"class Program

From bee33801a6db6f7edd644aed0888c288ee075936 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Fri, 24 Dec 2021 08:39:12 -0800
Subject: [PATCH 177/444] Confirm new behavior for smart indenter

Closes #15813
---
 .../Formatting/Indentation/SmartIndenterTests.cs         | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartIndenterTests.cs b/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartIndenterTests.cs
index e4a68a4baae37..92cb204305c25 100644
--- a/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartIndenterTests.cs
+++ b/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartIndenterTests.cs
@@ -2704,8 +2704,8 @@ class C
                 expectedIndentation: 8);
         }
 
-        [WpfFact(Skip = "https://github.com/dotnet/roslyn/issues/15813"), Trait(Traits.Feature, Traits.Features.SmartIndent)]
-        public void DontCreateIndentOperationForBrokenBracketedArgumentList()
+        [WpfFact, Trait(Traits.Feature, Traits.Features.SmartIndent)]
+        public void CreateIndentOperationForBrokenBracketedArgumentList()
         {
             var code = @"
 class Program
@@ -2717,12 +2717,11 @@ static void M()
     }
 }
 ";
-            // Need to confirm expected behavior after discard/deconstruction parsing changes
-            // https://github.com/dotnet/roslyn/issues/15813
+
             AssertSmartIndent(
                 code,
                 indentationLine: 6,
-                expectedIndentation: 8);
+                expectedIndentation: 12);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.SmartIndent)]

From 1d9529860676a9e1bd50db4e23eed594398f966e Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Mon, 27 Dec 2021 12:18:03 -0800
Subject: [PATCH 178/444] Allow valid metadata name characters in source
 generator hint names

Fixes #58476
---
 .../SourceGeneration/AdditionalSourcesCollectionTests.cs     | 5 +++++
 .../Portable/SourceGeneration/AdditionalSourcesCollection.cs | 4 +++-
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/Compilers/CSharp/Test/Semantic/SourceGeneration/AdditionalSourcesCollectionTests.cs b/src/Compilers/CSharp/Test/Semantic/SourceGeneration/AdditionalSourcesCollectionTests.cs
index 8e2bd4290666b..e081af04cf4ed 100644
--- a/src/Compilers/CSharp/Test/Semantic/SourceGeneration/AdditionalSourcesCollectionTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/SourceGeneration/AdditionalSourcesCollectionTests.cs
@@ -15,7 +15,9 @@
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Text;
+using Roslyn.Test.Utilities;
 using Xunit;
+
 namespace Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests.SourceGeneration
 {
     public class AdditionalSourcesCollectionTests
@@ -24,6 +26,8 @@ public class AdditionalSourcesCollectionTests
         [Theory]
         [InlineData("abc")] // abc.cs
         [InlineData("abc.cs")] //abc.cs
+        [InlineData("abc+nested.cs")] //abc+nested.cs
+        [InlineData("abc`1.cs")] //abc`1.cs
         [InlineData("abc.vb")] // abc.vb.cs
         [InlineData("abc.generated.cs")]
         [InlineData("abc_-_")]
@@ -32,6 +36,7 @@ public class AdditionalSourcesCollectionTests
         [InlineData("abc(1).cs")]
         [InlineData("abc[1].cs")]
         [InlineData("abc{1}.cs")]
+        [WorkItem(58476, "https://github.com/dotnet/roslyn/issues/58476")]
         public void HintName_ValidValues(string hintName)
         {
             AdditionalSourcesCollection asc = new AdditionalSourcesCollection(".cs");
diff --git a/src/Compilers/Core/Portable/SourceGeneration/AdditionalSourcesCollection.cs b/src/Compilers/Core/Portable/SourceGeneration/AdditionalSourcesCollection.cs
index f6a7ba40916d1..e5cf2dedcd21c 100644
--- a/src/Compilers/Core/Portable/SourceGeneration/AdditionalSourcesCollection.cs
+++ b/src/Compilers/Core/Portable/SourceGeneration/AdditionalSourcesCollection.cs
@@ -36,7 +36,7 @@ public void Add(string hintName, SourceText source)
                 throw new ArgumentNullException(nameof(hintName));
             }
 
-            // allow any identifier character or [.,-_ ()[]{}]
+            // allow any identifier character or [.,-+`_ ()[]{}]
             for (int i = 0; i < hintName.Length; i++)
             {
                 char c = hintName[i];
@@ -44,6 +44,8 @@ public void Add(string hintName, SourceText source)
                     && c != '.'
                     && c != ','
                     && c != '-'
+                    && c != '+'
+                    && c != '`'
                     && c != '_'
                     && c != ' '
                     && c != '('

From 3a2a2a67bae73150eae5ad8f80ecb3b689d8e056 Mon Sep 17 00:00:00 2001
From: Andrew Hall <andrha@microsoft.com>
Date: Tue, 28 Dec 2021 01:20:15 -0800
Subject: [PATCH 179/444] Stack Trace Explorer improvements (#58458)

* Add option to open automatically when clipboard contains stack trace (with option to disable)
* Add close button on each tab
* Add clear button at top
---
 .../StackTraceExplorer/IgnoredFrame.cs        |   2 +
 .../StackTraceExplorer/ParsedFrame.cs         |   2 +
 .../StackTraceExplorer/ParsedStackFrame.cs    |   2 +
 .../StackTraceExplorerOptions.cs              |  21 +++
 .../Options/AdvancedOptionPageControl.xaml    |   8 ++
 .../Options/AdvancedOptionPageControl.xaml.cs |   3 +
 .../Impl/Options/AdvancedOptionPageStrings.cs |   6 +
 .../Core/Def/ServicesVSResources.resx         |   4 +
 .../StackTraceExplorer.xaml.cs                |  14 +-
 .../StackTraceExplorerCommandHandler.cs       | 109 +++++++++++++-
 .../StackTraceExplorerRoot.xaml               | 134 ++++++++++--------
 .../StackTraceExplorerRoot.xaml.cs            |  24 ++--
 .../StackTraceExplorerRootViewModel.cs        |  37 ++++-
 .../StackTraceExplorerToolWindow.cs           |  47 +++++-
 .../StackTraceExplorerViewModel.cs            |  76 +++++-----
 .../Core/Def/xlf/ServicesVSResources.cs.xlf   |   5 +
 .../Core/Def/xlf/ServicesVSResources.de.xlf   |   5 +
 .../Core/Def/xlf/ServicesVSResources.es.xlf   |   5 +
 .../Core/Def/xlf/ServicesVSResources.fr.xlf   |   5 +
 .../Core/Def/xlf/ServicesVSResources.it.xlf   |   5 +
 .../Core/Def/xlf/ServicesVSResources.ja.xlf   |   5 +
 .../Core/Def/xlf/ServicesVSResources.ko.xlf   |   5 +
 .../Core/Def/xlf/ServicesVSResources.pl.xlf   |   5 +
 .../Def/xlf/ServicesVSResources.pt-BR.xlf     |   5 +
 .../Core/Def/xlf/ServicesVSResources.ru.xlf   |   5 +
 .../Core/Def/xlf/ServicesVSResources.tr.xlf   |   5 +
 .../Def/xlf/ServicesVSResources.zh-Hans.xlf   |   5 +
 .../Def/xlf/ServicesVSResources.zh-Hant.xlf   |   5 +
 28 files changed, 429 insertions(+), 125 deletions(-)
 create mode 100644 src/Features/Core/Portable/StackTraceExplorer/StackTraceExplorerOptions.cs

diff --git a/src/Features/Core/Portable/StackTraceExplorer/IgnoredFrame.cs b/src/Features/Core/Portable/StackTraceExplorer/IgnoredFrame.cs
index 246a4443bba9e..2ec8d7ad929cd 100644
--- a/src/Features/Core/Portable/StackTraceExplorer/IgnoredFrame.cs
+++ b/src/Features/Core/Portable/StackTraceExplorer/IgnoredFrame.cs
@@ -13,6 +13,8 @@ public IgnoredFrame(string originalText)
             _originalText = originalText;
         }
 
+        public override bool IsStackFrame => false;
+
         public override string ToString()
         {
             return _originalText;
diff --git a/src/Features/Core/Portable/StackTraceExplorer/ParsedFrame.cs b/src/Features/Core/Portable/StackTraceExplorer/ParsedFrame.cs
index 9e65a78a3290b..9d6ee17438a04 100644
--- a/src/Features/Core/Portable/StackTraceExplorer/ParsedFrame.cs
+++ b/src/Features/Core/Portable/StackTraceExplorer/ParsedFrame.cs
@@ -9,5 +9,7 @@ internal abstract class ParsedFrame
         public ParsedFrame()
         {
         }
+
+        public abstract bool IsStackFrame { get; }
     }
 }
diff --git a/src/Features/Core/Portable/StackTraceExplorer/ParsedStackFrame.cs b/src/Features/Core/Portable/StackTraceExplorer/ParsedStackFrame.cs
index 5b464fc65d575..4d971c5792925 100644
--- a/src/Features/Core/Portable/StackTraceExplorer/ParsedStackFrame.cs
+++ b/src/Features/Core/Portable/StackTraceExplorer/ParsedStackFrame.cs
@@ -32,6 +32,8 @@ public ParsedStackFrame(
 
         public StackFrameCompilationUnit Root => Tree.Root;
 
+        public override bool IsStackFrame => true;
+
         public override string ToString()
         {
             return Tree.Text.CreateString();
diff --git a/src/Features/Core/Portable/StackTraceExplorer/StackTraceExplorerOptions.cs b/src/Features/Core/Portable/StackTraceExplorer/StackTraceExplorerOptions.cs
new file mode 100644
index 0000000000000..b359dcde6a8d3
--- /dev/null
+++ b/src/Features/Core/Portable/StackTraceExplorer/StackTraceExplorerOptions.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 Microsoft.CodeAnalysis.Options;
+
+namespace Microsoft.CodeAnalysis.StackTraceExplorer
+{
+    internal static class StackTraceExplorerOptions
+    {
+        /// <summary>
+        /// Used to determine if a user focusing VS should look at the clipboard for a callstack and automatically
+        /// open the tool window with the callstack inserted
+        /// </summary>
+        public static readonly Option2<bool> OpenOnFocus = new(
+            nameof(StackTraceExplorerOptions),
+            nameof(OpenOnFocus),
+            true,
+            storageLocation: new RoamingProfileStorageLocation("StackTraceExplorer.Options.OpenOnFocus"));
+    }
+}
diff --git a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
index 9c02ff52e8d29..2c1019da82c54 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
+++ b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
@@ -306,6 +306,14 @@
                               Content="{x:Static local:AdvancedOptionPageStrings.Combine_inheritance_margin_with_indicator_margin}"/>
                 </StackPanel>
             </GroupBox>
+
+            <GroupBox x:Uid="StackTraceExplorerGroupBox" Header="{x:Static local:AdvancedOptionPageStrings.Stack_Trace_Explorer}">
+                <StackPanel>
+                    <CheckBox x:Uid="AutomaticallyOpenStackTraceExplorer"
+                              x:Name="AutomaticallyOpenStackTraceExplorer"
+                              Content="{x:Static local:AdvancedOptionPageStrings.Option_Automatically_open_stack_trace_explorer_on_focus}" />
+                </StackPanel>
+            </GroupBox>
         </StackPanel>
     </ScrollViewer>
 </options:AbstractOptionPageControl>
diff --git a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
index f71c20f945332..f769d0fbfbe3a 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
@@ -25,6 +25,7 @@
 using Microsoft.CodeAnalysis.QuickInfo;
 using Microsoft.CodeAnalysis.Remote;
 using Microsoft.CodeAnalysis.SolutionCrawler;
+using Microsoft.CodeAnalysis.StackTraceExplorer;
 using Microsoft.CodeAnalysis.Structure;
 using Microsoft.CodeAnalysis.SymbolSearch;
 using Microsoft.CodeAnalysis.ValidateFormatString;
@@ -152,6 +153,8 @@ public AdvancedOptionPageControl(OptionStore optionStore, IComponentModel compon
             // Leave the null converter here to make sure if the option value is get from the storage (if it is null), the feature will be enabled
             BindToOption(ShowInheritanceMargin, FeatureOnOffOptions.ShowInheritanceMargin, LanguageNames.CSharp, () => true);
             BindToOption(InheritanceMarginCombinedWithIndicatorMargin, FeatureOnOffOptions.InheritanceMarginCombinedWithIndicatorMargin);
+
+            BindToOption(AutomaticallyOpenStackTraceExplorer, StackTraceExplorerOptions.OpenOnFocus);
         }
 
         // Since this dialog is constructed once for the lifetime of the application and VS Theme can be changed after the application has started,
diff --git a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs
index d54710449a7f7..90285b616fb77 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs
@@ -299,5 +299,11 @@ public static string Combine_inheritance_margin_with_indicator_margin
 
         public static string Inheritance_Margin
             => ServicesVSResources.Inheritance_Margin;
+
+        public static string Stack_Trace_Explorer
+            => ServicesVSResources.Stack_Trace_Explorer;
+
+        public static string Option_Automatically_open_stack_trace_explorer_on_focus
+            => ServicesVSResources.Automatically_open_stack_trace_explorer_on_focus;
     }
 }
diff --git a/src/VisualStudio/Core/Def/ServicesVSResources.resx b/src/VisualStudio/Core/Def/ServicesVSResources.resx
index e67296ccae599..45ad9b62b64e0 100644
--- a/src/VisualStudio/Core/Def/ServicesVSResources.resx
+++ b/src/VisualStudio/Core/Def/ServicesVSResources.resx
@@ -1893,4 +1893,8 @@ Additional information: {1}</value>
   <data name="Sort_usings" xml:space="preserve">
     <value>Sort usings</value>
   </data>
+  <data name="Automatically_open_stack_trace_explorer_on_focus" xml:space="preserve">
+    <value>Automatically open Stack Trace Explorer on focus</value>
+    <comment>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</comment>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorer.xaml.cs b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorer.xaml.cs
index 21b08689909aa..7fd02bd939d3a 100644
--- a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorer.xaml.cs
+++ b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorer.xaml.cs
@@ -3,8 +3,11 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Threading;
+using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
+using Microsoft.CodeAnalysis.StackTraceExplorer;
 
 namespace Microsoft.VisualStudio.LanguageServices.StackTraceExplorer
 {
@@ -13,11 +16,11 @@ namespace Microsoft.VisualStudio.LanguageServices.StackTraceExplorer
     /// </summary>
     internal partial class StackTraceExplorer : UserControl
     {
-        private readonly StackTraceExplorerViewModel _viewModel;
+        public readonly StackTraceExplorerViewModel ViewModel;
 
         public StackTraceExplorer(StackTraceExplorerViewModel viewModel)
         {
-            DataContext = _viewModel = viewModel;
+            DataContext = ViewModel = viewModel;
             InitializeComponent();
 
             DataObject.AddPastingHandler(this, OnPaste);
@@ -31,12 +34,13 @@ private void CommandBinding_Executed(object sender, System.Windows.Input.Execute
 
         public void OnPaste()
         {
-            _viewModel.OnPaste();
+            var text = Clipboard.GetText();
+            ViewModel.OnPaste_CallOnUIThread(text);
         }
 
         private void ListViewItem_MouseDoubleClick(object sender, System.Windows.Input.MouseButtonEventArgs e)
         {
-            if (_viewModel.Selection is StackFrameViewModel stackFrameViewModel)
+            if (ViewModel.Selection is StackFrameViewModel stackFrameViewModel)
             {
                 stackFrameViewModel.NavigateToSymbol();
             }
@@ -44,7 +48,7 @@ private void ListViewItem_MouseDoubleClick(object sender, System.Windows.Input.M
 
         internal void OnClear()
         {
-            _viewModel.OnClear();
+            ViewModel.OnClear();
         }
     }
 }
diff --git a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerCommandHandler.cs b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerCommandHandler.cs
index 6ae09b6f24beb..414b2775983b8 100644
--- a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerCommandHandler.cs
+++ b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerCommandHandler.cs
@@ -4,23 +4,124 @@
 
 using System;
 using System.ComponentModel.Design;
+using System.IO.Packaging;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.StackTraceExplorer;
 using Microsoft.VisualStudio.LanguageServices.Setup;
 using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Shell.Interop;
-using Microsoft.VisualStudio.Text.Classification;
-using Microsoft.VisualStudio.Utilities;
 
 namespace Microsoft.VisualStudio.LanguageServices.StackTraceExplorer
 {
-    internal class StackTraceExplorerCommandHandler
+    internal class StackTraceExplorerCommandHandler : IVsBroadcastMessageEvents, IDisposable
     {
         private readonly RoslynPackage _package;
+        private readonly IThreadingContext _threadingContext;
         private static StackTraceExplorerCommandHandler? _instance;
+        private uint _vsShellBroadcastCookie;
 
         private StackTraceExplorerCommandHandler(RoslynPackage package)
         {
             _package = package;
+            _threadingContext = package.ComponentModel.GetService<IThreadingContext>();
+
+            var workspace = package.ComponentModel.GetService<VisualStudioWorkspace>();
+            var optionService = workspace.Services.GetRequiredService<IOptionService>();
+            optionService.OptionChanged += OptionService_OptionChanged;
+
+            var enabled = workspace.CurrentSolution.Options.GetOption(StackTraceExplorerOptions.OpenOnFocus);
+            if (enabled)
+            {
+                AdviseBroadcastMessages();
+            }
+        }
+
+        public int OnBroadcastMessage(uint msg, IntPtr wParam, IntPtr lParam)
+        {
+            if (msg != 0x001C) // WM_ACTIVATEAPP
+            {
+                return VSConstants.S_OK;
+            }
+
+            // wParam contains a value indicated if the window was activated.
+            // See https://docs.microsoft.com/en-us/windows/win32/winmsg/wm-activateapp 
+            // 1 = activate
+            // 0 = deactivated
+            if (wParam == IntPtr.Zero)
+            {
+                return VSConstants.S_OK;
+            }
+
+            var window = GetOrInitializeWindow();
+            _threadingContext.JoinableTaskFactory.RunAsync(async () =>
+            {
+                var shouldActivate = await window.ShouldShowOnActivatedAsync(default).ConfigureAwait(false);
+
+                if (shouldActivate)
+                {
+                    await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync();
+                    var windowFrame = (IVsWindowFrame)window.Frame;
+                    ErrorHandler.ThrowOnFailure(windowFrame.Show());
+                }
+            });
+
+            return VSConstants.S_OK;
+        }
+
+        public void Dispose()
+        {
+            UnadviseBroadcastMessages();
+
+            var workspace = _package.ComponentModel.GetService<VisualStudioWorkspace>();
+            var optionService = workspace.Services.GetRequiredService<IOptionService>();
+            optionService.OptionChanged -= OptionService_OptionChanged;
+        }
+
+        private void AdviseBroadcastMessages()
+        {
+            if (_vsShellBroadcastCookie != 0)
+            {
+                return;
+            }
+
+            var serviceProvider = (IServiceProvider)_package;
+            var vsShell = serviceProvider.GetService(typeof(SVsShell)) as IVsShell;
+
+            if (vsShell is not null)
+            {
+                vsShell.AdviseBroadcastMessages(this, out _vsShellBroadcastCookie);
+            }
+        }
+
+        private void UnadviseBroadcastMessages()
+        {
+            if (_vsShellBroadcastCookie != 0)
+            {
+                var serviceProvider = (IServiceProvider)_package;
+                var vsShell = serviceProvider.GetService(typeof(SVsShell)) as IVsShell;
+                if (vsShell is not null)
+                {
+                    vsShell.UnadviseBroadcastMessages(_vsShellBroadcastCookie);
+                    _vsShellBroadcastCookie = 0;
+                }
+            }
+        }
+
+        private void OptionService_OptionChanged(object sender, OptionChangedEventArgs e)
+        {
+            if (e.Option == StackTraceExplorerOptions.OpenOnFocus && e.Value is not null)
+            {
+                var enabled = (bool)e.Value;
+                if (enabled)
+                {
+                    AdviseBroadcastMessages();
+                }
+                else
+                {
+                    UnadviseBroadcastMessages();
+                }
+            }
         }
 
         private void Execute(object sender, EventArgs e)
@@ -34,7 +135,7 @@ private void Execute(object sender, EventArgs e)
 
             // Paste current clipboard contents on showing
             // the window
-            window.Root?.OnPaste();
+            window.Root?.ViewModel.DoPasteSynchronously(default);
         }
 
         private StackTraceExplorerToolWindow GetOrInitializeWindow()
diff --git a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerRoot.xaml b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerRoot.xaml
index 825e65902dd03..abc981fbe1df2 100644
--- a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerRoot.xaml
+++ b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerRoot.xaml
@@ -17,7 +17,6 @@
              platformimaging:ImageThemingUtilities.ImageBackgroundColor="{StaticResource {x:Static vsshell:VsColors.ToolWindowBackgroundKey}}">
     <UserControl.Resources>
         <ResourceDictionary>
-            <Style TargetType="Button" BasedOn="{StaticResource {x:Static vsshell:VsResourceKeys.ThemedDialogButtonStyleKey}}" />
             <Style TargetType="CheckBox" BasedOn="{StaticResource {x:Static vsshell:VsResourceKeys.ThemedDialogCheckBoxStyleKey}}" />
             <Style TargetType="ComboBox" BasedOn="{StaticResource {x:Static vsshell:VsResourceKeys.ThemedDialogComboBoxStyleKey}}" />
             <Style TargetType="TextBox" BasedOn="{StaticResource {x:Static vsshell:VsResourceKeys.ThemedDialogTextBoxStyleKey}}" />
@@ -36,14 +35,63 @@
                 <Setter Property="BorderThickness" Value="0" />
                 <Setter Property="Padding" Value="0" />
             </Style>
+
+            <Style TargetType="Button" BasedOn="{StaticResource {x:Static vsshell:VsResourceKeys.ThemedDialogButtonStyleKey}}">
+                <Setter Property="Background" Value="Transparent" />
+                <Style.Triggers>
+                    <Trigger Property="IsMouseOver" Value="True">
+                        <Setter Property="Background" Value="{DynamicResource {x:Static vsui:CommonControlsColors.ButtonHoverBrushKey}}" />
+                    </Trigger>
+                </Style.Triggers>
+            </Style>
         </ResourceDictionary>
     </UserControl.Resources>
     <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="*" />
+        </Grid.RowDefinitions>
+        <StackPanel Orientation="Horizontal" Grid.Row="0" MinHeight="20" MinWidth="20" Margin="5">
+            <Button Click="Clear_Click" x:Name="ClearButton">
+                <Button.Content>
+                    <StackPanel Orientation="Horizontal">
+                        <imaging:CrispImage Moniker="{x:Static imagecatalog:KnownMonikers.ClearCollection}" Margin="0 0 5 0" />
+                        <TextBlock Text="{Binding ElementName=Root, Path=Clear_Text}" />
+                    </StackPanel>
+                </Button.Content>
+            </Button>
+        </StackPanel>
         <TabControl x:Name="TabControl"
+            Grid.Row="1"
             TabStripPlacement="Top"
             ItemsSource="{Binding Tabs, Mode=OneWay}"
             SelectedItem="{Binding SelectedTab, Mode=TwoWay}">
 
+            <!-- Container template for the tab control header to allow for horizontal scrolling of tabs -->
+            <TabControl.Template>
+                <ControlTemplate TargetType="TabControl">
+                    <Grid>
+                        <Grid.RowDefinitions>
+                            <RowDefinition Height="Auto" />
+                            <RowDefinition />
+                        </Grid.RowDefinitions>
+                        <ScrollViewer HorizontalScrollBarVisibility="Auto"  VerticalScrollBarVisibility="Hidden" >
+                            <TabPanel x:Name="HeaderPanel"
+                              Panel.ZIndex ="1" 
+                              KeyboardNavigation.TabIndex="1"
+                              Grid.Column="0"
+                              Grid.Row="0"
+                              Margin="2,2,2,0"
+                              IsItemsHost="true"/>
+                        </ScrollViewer>
+                        <ContentPresenter x:Name="PART_SelectedContentHost"
+                                      SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}"
+                                      Margin="{TemplateBinding Padding}"
+                                      ContentSource="SelectedContent" Grid.Row="1"/>
+                    </Grid>
+                </ControlTemplate>
+            </TabControl.Template>
+
             <TabControl.ItemContainerStyle>
                 <Style TargetType="TabItem">
                     <Setter Property="Header" Value="{Binding Header}" />
@@ -61,14 +109,41 @@
                                         <RowDefinition Height="auto" />
                                         <RowDefinition Height="auto" />
                                     </Grid.RowDefinitions>
-                                    <ContentPresenter  Grid.Row="0" x:Name="contentPresenter" ContentSource="Header" Focusable="False" HorizontalAlignment="{Binding HorizontalContentAlignment, RelativeSource={RelativeSource AncestorType={x:Type ItemsControl}}}" Margin="{TemplateBinding Padding}" RecognizesAccessKey="True" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" VerticalAlignment="{Binding VerticalContentAlignment, RelativeSource={RelativeSource AncestorType={x:Type ItemsControl}}}"/>
+                                    <Grid.ColumnDefinitions>
+                                        <ColumnDefinition Width="80" />
+                                        <ColumnDefinition Width="16" />
+                                    </Grid.ColumnDefinitions>
+
+                                    <ContentPresenter  
+                                        Grid.Row="0" 
+                                        x:Name="contentPresenter" 
+                                        ContentSource="Header" 
+                                        Focusable="False" 
+                                        HorizontalAlignment="{Binding HorizontalContentAlignment, RelativeSource={RelativeSource AncestorType={x:Type ItemsControl}}}" 
+                                        Margin="5 0 5 0" 
+                                        RecognizesAccessKey="True" 
+                                        SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" 
+                                        VerticalAlignment="{Binding VerticalContentAlignment, RelativeSource={RelativeSource AncestorType={x:Type ItemsControl}}}"/>
+
+                                    <Button Grid.Row="0" Grid.Column="1" Command="{Binding CloseClick}" Margin="0" Padding="0" BorderThickness="0" Width="16" MinWidth="16" MinHeight="16" Height="16">
+                                        <Button.Template>
+                                            <ControlTemplate>
+                                                <Grid Background="{TemplateBinding Background}">
+                                                    <imaging:CrispImage Moniker="{x:Static imagecatalog:KnownMonikers.Close}" Margin="0" Width="14" Height="14" />
+                                                </Grid>
+                                            </ControlTemplate>
+                                        </Button.Template>
+                                    </Button>
+
                                     <!-- the line under the text to indicate that this label is selected -->
                                     <Rectangle
                                         x:Name="_underline"
                                         Grid.Row="1"
+                                        Grid.Column="0"
+                                        Grid.ColumnSpan="2"
                                         Height="3"
                                         Visibility="Collapsed"
-                                        Width="{Binding ActualWidth, ElementName=contentPresenter}"
+                                        Width="96"
                                         HorizontalAlignment="Center"
                                         Fill="{DynamicResource {x:Static vsui:CommonDocumentColors.InnerTabInactiveHoverTextBrushKey}}"/>
                                 </Grid>
@@ -102,59 +177,6 @@
                         </Setter.Value>
                     </Setter>
                 </Style>
-                <!--<Style TargetType="TabItem" BasedOn="{StaticResource {x:Static vsshell:VsResourceKeys.ThemedDialogTabItemNavigationStyleKey}}">
-                    <Setter Property="Header" Value="{Binding Header}" />
-                    <Setter Property="Content" Value="{Binding Content}" />
-                    <Setter Property="AutomationProperties.Name" Value="{Binding Title}" />
-                    <Setter Property="Background" Value="{DynamicResource {x:Static vsui:CommonControlsColors.InnerTabInactiveBackgroundBrushKey}}" />
-                    <Setter Property="BorderBrush" Value="Transparent" />
-                    <Setter Property="BorderThickness" Value="1" />
-                    <Setter Property="Foreground" Value="{DynamicResource {x:Static vsui:CommonControlsColors.InnerTabInactiveTextBrushKey}}" />
-                    <Setter Property="Padding" Value="6,3,6,3" />
-                    <Setter Property="Template">
-                        <Setter.Value>
-                            <ControlTemplate TargetType="TabItem">
-                                <Border x:Name="PART_Border"
-                                        Background="{TemplateBinding Background}"
-                                        BorderBrush="{TemplateBinding BorderBrush}"
-                                        BorderThickness="{TemplateBinding BorderThickness}"
-                                        Padding="{TemplateBinding Padding}">
-                                    <Grid>
-                                        <Grid.ColumnDefinitions>
-                                            <ColumnDefinition Width="Auto" />
-                                            <ColumnDefinition Width="16" />
-                                        </Grid.ColumnDefinitions>
-                                        <Label Content="{Binding Header}" Padding="0" Margin="0" />
-                                        <imaging:CrispImage Moniker="{x:Static imagecatalog:KnownMonikers.Close}" Grid.Column="1" Margin="4, 0, 0, 0" Width="12">
-                                            <imaging:CrispImage.Triggers>
-                                                <Trigger Property="IsMouseOver" Value="True">
-                                                    <Setter Property="Background" Value="{DynamicResource {x:Static platformimaging:ImageThemingUtilities.ImageBackgroundColorProperty}}" />
-                                                </Trigger>
-                                            </imaging:CrispImage.Triggers>
-                                        </imaging:CrispImage>
-                                    </Grid>
-                                </Border>
-                                    <ControlTemplate.Triggers>
-                                        <Trigger Property="IsSelected" Value="True">
-                                            <Setter Property="Background" Value="{DynamicResource {x:Static vsui:CommonControlsColors.InnerTabActiveBackgroundBrushKey}}" />
-                                            <Setter Property="Foreground" Value="{DynamicResource {x:Static vsui:CommonControlsColors.InnerTabActiveTextBrushKey}}" />
-                                            <Setter Property="BorderBrush" Value="{DynamicResource {x:Static vsui:CommonControlsColors.InnerTabActiveBorderBrushKey}}" />
-                                        </Trigger>
-                                        <MultiTrigger>
-                                            <MultiTrigger.Conditions>
-                                                <Condition Property="IsMouseOver" Value="True" />
-                                                <Condition Property="IsSelected" Value="False" />
-                                            </MultiTrigger.Conditions>
-                                            <MultiTrigger.Setters>
-                                                <Setter Property="Background" Value="{DynamicResource {x:Static vsui:CommonControlsColors.InnerTabInactiveHoverBackgroundBrushKey}}" />
-                                                <Setter Property="Foreground" Value="{DynamicResource {x:Static vsui:CommonControlsColors.InnerTabInactiveHoverTextBrushKey}}" />
-                                            </MultiTrigger.Setters>
-                                        </MultiTrigger>
-                                    </ControlTemplate.Triggers>
-                            </ControlTemplate>
-                        </Setter.Value>
-                    </Setter>
-                </Style>-->
             </TabControl.ItemContainerStyle>
         </TabControl>
     </Grid>
diff --git a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerRoot.xaml.cs b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerRoot.xaml.cs
index 22baf9b6a2fbd..745fb296d715c 100644
--- a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerRoot.xaml.cs
+++ b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerRoot.xaml.cs
@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
@@ -24,31 +25,29 @@ namespace Microsoft.VisualStudio.LanguageServices.StackTraceExplorer
     /// </summary>
     internal partial class StackTraceExplorerRoot : UserControl
     {
-        private readonly StackTraceExplorerRootViewModel _viewModel;
+        public string CloseTab => ServicesVSResources.Close_tab;
+        public string Clear_Text => ServicesVSResources.Clear;
+
+        public readonly StackTraceExplorerRootViewModel ViewModel;
 
         public StackTraceExplorerRoot(StackTraceExplorerRootViewModel viewModel)
         {
-            DataContext = _viewModel = viewModel;
+            DataContext = ViewModel = viewModel;
 
             InitializeComponent();
             DataObject.AddPastingHandler(this, OnPaste);
         }
 
-        private void CommandBinding_OnPaste(object sender, System.Windows.Input.ExecutedRoutedEventArgs e)
-            => OnPaste();
+        private void CommandBinding_OnPaste(object sender, ExecutedRoutedEventArgs e)
+            => ViewModel.DoPasteAsync(default).Start();
 
         internal void OnClear()
         {
-            _viewModel.SelectedTab?.Content.OnClear();
+            ViewModel.SelectedTab?.Content.OnClear();
         }
 
         private void OnPaste(object sender, DataObjectPastingEventArgs e)
-            => OnPaste();
-
-        public void OnPaste()
-        {
-            _viewModel.OnPaste();
-        }
+            => ViewModel.DoPasteAsync(default).Start();
 
         private void Close_Click(object sender, RoutedEventArgs e)
         {
@@ -57,5 +56,8 @@ private void Close_Click(object sender, RoutedEventArgs e)
                 tab.CloseClick.Execute(null);
             }
         }
+
+        private void Clear_Click(object sender, RoutedEventArgs e)
+            => OnClear();
     }
 }
diff --git a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerRootViewModel.cs b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerRootViewModel.cs
index 5fca23a15954a..b19150cc79a28 100644
--- a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerRootViewModel.cs
+++ b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerRootViewModel.cs
@@ -4,9 +4,13 @@
 
 using System.Collections.ObjectModel;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows;
 using System.Windows.Input;
 using Microsoft.CodeAnalysis.Editor.Host;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.StackTraceExplorer;
 using Microsoft.VisualStudio.LanguageServices.Utilities;
 using Microsoft.VisualStudio.Text.Classification;
 
@@ -36,7 +40,13 @@ public StackTraceExplorerTab? SelectedTab
             set => SetProperty(ref _selectedTab, value);
         }
 
-        public void AddNewTab(bool triggerPaste)
+        /// <summary>
+        /// Returns true if there's a tab that already matches the text
+        /// </summary>
+        public bool ContainsTab(string text)
+            => Tabs.Any(tab => tab.Content.ViewModel.Matches(text));
+
+        public async Task AddNewTabAsync(StackTraceAnalysisResult? result, string originalText, CancellationToken cancellationToken)
         {
             // Name will always have an index. Use the highest index opened + 1.
             var highestIndex = Tabs.Count == 0
@@ -49,27 +59,40 @@ public void AddNewTab(bool triggerPaste)
             SelectedTab = newTab;
 
             newTab.OnClosed += Tab_Closed;
-
-            if (triggerPaste)
+            if (result.HasValue)
             {
-                SelectedTab.Content.OnPaste();
+                await newTab.Content.ViewModel.SetStackTraceResultAsync(result.Value, originalText, cancellationToken).ConfigureAwait(false);
             }
         }
 
-        internal void OnPaste()
+        public async Task DoPasteAsync(CancellationToken cancellationToken)
         {
+            var text = Clipboard.GetText();
+            if (string.IsNullOrEmpty(text))
+            {
+                return;
+            }
+
+            var result = await StackTraceAnalyzer.AnalyzeAsync(text, cancellationToken).ConfigureAwait(false);
             if (SelectedTab is { IsEmpty: true })
             {
                 // Paste in the SelectedTab instead of opening a new tab
                 // for cases where there are no contents in the current tab
-                SelectedTab.Content.OnPaste();
+                await SelectedTab.Content.ViewModel.SetStackTraceResultAsync(result, text, cancellationToken).ConfigureAwait(false);
             }
             else
             {
-                AddNewTab(triggerPaste: true);
+                await AddNewTabAsync(result, text, cancellationToken).ConfigureAwait(false);
             }
         }
 
+        public void DoPasteSynchronously(CancellationToken cancellationToken)
+        {
+#pragma warning disable VSTHRD102 // Implement internal logic asynchronously
+            _threadingContext.JoinableTaskFactory.Run(() => DoPasteAsync(cancellationToken));
+#pragma warning restore VSTHRD102 // Implement internal logic asynchronously
+        }
+
         private void Tab_Closed(object sender, System.EventArgs e)
         {
             var tab = (StackTraceExplorerTab)sender;
diff --git a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerToolWindow.cs b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerToolWindow.cs
index 8554d478e502f..8edc39cd79434 100644
--- a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerToolWindow.cs
+++ b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerToolWindow.cs
@@ -3,12 +3,16 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using System.Runtime.InteropServices;
+using System.Threading;
+using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Input;
-using Microsoft.CodeAnalysis.Editor.Host;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.StackTraceExplorer;
 using Microsoft.VisualStudio.Imaging;
 using Microsoft.VisualStudio.LanguageServices.Setup;
 using Microsoft.VisualStudio.LanguageServices.Utilities;
@@ -17,7 +21,6 @@
 using Microsoft.VisualStudio.Shell.Interop;
 using Microsoft.VisualStudio.Text.Classification;
 using Microsoft.VisualStudio.Utilities;
-using Roslyn.Utilities;
 using static Microsoft.VisualStudio.VSConstants;
 
 namespace Microsoft.VisualStudio.LanguageServices.StackTraceExplorer
@@ -26,6 +29,8 @@ namespace Microsoft.VisualStudio.LanguageServices.StackTraceExplorer
     internal class StackTraceExplorerToolWindow : ToolWindowPane, IOleCommandTarget
     {
         private bool _initialized;
+
+        [MemberNotNullWhen(true, nameof(_initialized))]
         public StackTraceExplorerRoot? Root { get; private set; }
 
         public StackTraceExplorerToolWindow() : base(null)
@@ -38,12 +43,44 @@ public StackTraceExplorerToolWindow() : base(null)
 
             dockPanel.CommandBindings.Add(new CommandBinding(ApplicationCommands.Paste, (s, e) =>
             {
-                Root?.OnPaste();
+                Root?.ViewModel.DoPasteAsync(default).Start();
             }));
 
             Content = dockPanel;
         }
 
+        /// <summary>
+        /// Checks the contents of the clipboard for a valid stack trace and 
+        /// opens stack trace explorer if anything parses correctly
+        /// </summary>
+        public async Task<bool> ShouldShowOnActivatedAsync(CancellationToken cancellationToken)
+        {
+            if (Root is null)
+            {
+                return false;
+            }
+
+            var text = Clipboard.GetText();
+            if (string.IsNullOrEmpty(text))
+            {
+                return false;
+            }
+
+            if (Root.ViewModel.ContainsTab(text))
+            {
+                return false;
+            }
+
+            var result = await StackTraceAnalyzer.AnalyzeAsync(text, cancellationToken).ConfigureAwait(false);
+            if (result.ParsedFrames.Any(static frame => frame.IsStackFrame))
+            {
+                await Root.ViewModel.AddNewTabAsync(result, text, cancellationToken).ConfigureAwait(false);
+                return true;
+            }
+
+            return false;
+        }
+
         public void InitializeIfNeeded(RoslynPackage roslynPackage)
         {
             if (_initialized)
@@ -70,7 +107,7 @@ public void InitializeIfNeeded(RoslynPackage roslynPackage)
             contextMenu.Items.Add(new MenuItem()
             {
                 Header = ServicesVSResources.Paste,
-                Command = new DelegateCommand(_ => Root.OnPaste()),
+                Command = new DelegateCommand(_ => Root.ViewModel.DoPasteSynchronously(default)),
                 Icon = new CrispImage()
                 {
                     Moniker = KnownMonikers.Paste
@@ -109,7 +146,7 @@ int IOleCommandTarget.Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt
                 switch (command)
                 {
                     case VSStd97CmdID.Paste:
-                        Root?.OnPaste();
+                        Root?.ViewModel.DoPasteSynchronously(default);
                         break;
                 }
             }
diff --git a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerViewModel.cs b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerViewModel.cs
index 64f6297e730de..a4b6084494eaa 100644
--- a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerViewModel.cs
+++ b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerViewModel.cs
@@ -42,6 +42,8 @@ public FrameViewModel? Selection
         public bool IsListVisible => Frames.Count > 0;
         public bool IsInstructionTextVisible => Frames.Count == 0;
 
+        private int _id;
+
         internal void OnClear()
         {
             Frames.Clear();
@@ -61,57 +63,57 @@ public StackTraceExplorerViewModel(IThreadingContext threadingContext, Workspace
             Frames.CollectionChanged += CallstackLines_CollectionChanged;
         }
 
-        private void CallstackLines_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
-        {
-            NotifyPropertyChanged(nameof(IsListVisible));
-            NotifyPropertyChanged(nameof(IsInstructionTextVisible));
-        }
+        public bool Matches(string text) => text.GetHashCode() == _id;
 
-        private void Workspace_WorkspaceChanged(object sender, WorkspaceChangeEventArgs e)
+        public void OnPaste_CallOnUIThread(string text)
         {
-            if (e.Kind == WorkspaceChangeKind.SolutionChanged)
+            IsLoading = true;
+            Frames.Clear();
+            var cancellationToken = _threadingContext.DisposalToken;
+            System.Threading.Tasks.Task.Run(async () =>
             {
-                Selection = null;
-                Frames.Clear();
-            }
+                try
+                {
+                    var result = await StackTraceAnalyzer.AnalyzeAsync(text, cancellationToken).ConfigureAwait(false);
+                    await SetStackTraceResultAsync(result, text, cancellationToken).ConfigureAwait(false);
+                }
+                finally
+                {
+                    await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync();
+                    IsLoading = false;
+                }
+            }, cancellationToken);
         }
 
-        internal void OnPaste()
+        public async System.Threading.Tasks.Task SetStackTraceResultAsync(StackTraceAnalysisResult result, string originalText, System.Threading.CancellationToken cancellationToken)
         {
+            _id = originalText.GetHashCode();
+            var viewModels = result.ParsedFrames.Select(l => GetViewModel(l));
+
+            await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+
+            Selection = null;
             Frames.Clear();
-            var textObject = Clipboard.GetData(DataFormats.Text);
 
-            if (textObject is string text)
+            foreach (var vm in viewModels)
             {
-                OnPaste(text);
+                Frames.Add(vm);
             }
         }
 
-        internal void OnPaste(string text)
+        private void CallstackLines_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
         {
-            System.Threading.Tasks.Task.Run(async () =>
-            {
-                try
-                {
-                    var result = await StackTraceAnalyzer.AnalyzeAsync(text, _threadingContext.DisposalToken).ConfigureAwait(false);
-                    var viewModels = result.ParsedFrames.Select(l => GetViewModel(l));
-
-                    await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync();
-
-                    Selection = null;
-                    Frames.Clear();
+            NotifyPropertyChanged(nameof(IsListVisible));
+            NotifyPropertyChanged(nameof(IsInstructionTextVisible));
+        }
 
-                    foreach (var vm in viewModels)
-                    {
-                        Frames.Add(vm);
-                    }
-                }
-                finally
-                {
-                    await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync();
-                    IsLoading = false;
-                }
-            }, _threadingContext.DisposalToken);
+        private void Workspace_WorkspaceChanged(object sender, WorkspaceChangeEventArgs e)
+        {
+            if (e.Kind == WorkspaceChangeKind.SolutionChanged)
+            {
+                Selection = null;
+                Frames.Clear();
+            }
         }
 
         private FrameViewModel GetViewModel(ParsedFrame frame)
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
index 8b9eb15b44db2..73b24320af964 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
@@ -107,6 +107,11 @@
         <target state="translated">Sestavení</target>
         <note />
       </trans-unit>
+      <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
+        <source>Automatically open Stack Trace Explorer on focus</source>
+        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
+      </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
         <source>Avoid expression statements that implicitly ignore value</source>
         <target state="translated">Vyhněte se výrazům, které implicitně ignorují hodnotu.</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
index 0ced2673a9f61..114d6066b16bc 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
@@ -107,6 +107,11 @@
         <target state="translated">Assemblys</target>
         <note />
       </trans-unit>
+      <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
+        <source>Automatically open Stack Trace Explorer on focus</source>
+        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
+      </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
         <source>Avoid expression statements that implicitly ignore value</source>
         <target state="translated">Ausdrucksanweisungen vermeiden, die implizit Werte ignorieren</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
index dad70d9036135..f67e3a64555de 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
@@ -107,6 +107,11 @@
         <target state="translated">Ensamblados</target>
         <note />
       </trans-unit>
+      <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
+        <source>Automatically open Stack Trace Explorer on focus</source>
+        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
+      </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
         <source>Avoid expression statements that implicitly ignore value</source>
         <target state="translated">Evitar instrucciones de expresión que omiten implícitamente el valor</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
index 6e53b9fab37e9..87e7ac8e28bab 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
@@ -107,6 +107,11 @@
         <target state="translated">Assemblys</target>
         <note />
       </trans-unit>
+      <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
+        <source>Automatically open Stack Trace Explorer on focus</source>
+        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
+      </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
         <source>Avoid expression statements that implicitly ignore value</source>
         <target state="translated">Éviter les instructions d'expression qui ignorent implicitement la valeur</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
index 9123f06c92226..83eb2e3413da0 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
@@ -107,6 +107,11 @@
         <target state="translated">Assembly</target>
         <note />
       </trans-unit>
+      <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
+        <source>Automatically open Stack Trace Explorer on focus</source>
+        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
+      </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
         <source>Avoid expression statements that implicitly ignore value</source>
         <target state="translated">Evita le istruzioni di espressione che ignorano il valore in modo implicito</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
index 454b5cbc00f95..046d7cda10b0d 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
@@ -107,6 +107,11 @@
         <target state="translated">アセンブリ</target>
         <note />
       </trans-unit>
+      <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
+        <source>Automatically open Stack Trace Explorer on focus</source>
+        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
+      </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
         <source>Avoid expression statements that implicitly ignore value</source>
         <target state="translated">値を暗黙的に無視する式ステートメントを指定しないでください</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
index d2fd1ed353012..e02d7a3d25887 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
@@ -107,6 +107,11 @@
         <target state="translated">어셈블리</target>
         <note />
       </trans-unit>
+      <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
+        <source>Automatically open Stack Trace Explorer on focus</source>
+        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
+      </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
         <source>Avoid expression statements that implicitly ignore value</source>
         <target state="translated">암시적으로 값을 무시하는 식 문을 사용하지 마세요.</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
index 03a36568f7b52..91b18d3d98359 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
@@ -107,6 +107,11 @@
         <target state="translated">Zestawy</target>
         <note />
       </trans-unit>
+      <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
+        <source>Automatically open Stack Trace Explorer on focus</source>
+        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
+      </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
         <source>Avoid expression statements that implicitly ignore value</source>
         <target state="translated">Unikaj instrukcji wyrażeń, które niejawnie ignorują wartość</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
index 851931e706acf..58e792ae327ed 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
@@ -107,6 +107,11 @@
         <target state="translated">Assemblies</target>
         <note />
       </trans-unit>
+      <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
+        <source>Automatically open Stack Trace Explorer on focus</source>
+        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
+      </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
         <source>Avoid expression statements that implicitly ignore value</source>
         <target state="translated">Evitar instruções de expressão que implicitamente ignoram valor</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
index 2b59aa65cca2e..1ba945a205059 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
@@ -107,6 +107,11 @@
         <target state="translated">Сборки</target>
         <note />
       </trans-unit>
+      <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
+        <source>Automatically open Stack Trace Explorer on focus</source>
+        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
+      </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
         <source>Avoid expression statements that implicitly ignore value</source>
         <target state="translated">Избегайте операторов-выражений, неявно игнорирующих значение.</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
index 1329623f56138..c9766d0540ed7 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
@@ -107,6 +107,11 @@
         <target state="translated">Derlemeler</target>
         <note />
       </trans-unit>
+      <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
+        <source>Automatically open Stack Trace Explorer on focus</source>
+        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
+      </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
         <source>Avoid expression statements that implicitly ignore value</source>
         <target state="translated">Değeri örtük olarak yok sayan ifade deyimlerini engelle</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
index b470e8636b073..273b4ebea6fc7 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
@@ -107,6 +107,11 @@
         <target state="translated">程序集</target>
         <note />
       </trans-unit>
+      <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
+        <source>Automatically open Stack Trace Explorer on focus</source>
+        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
+      </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
         <source>Avoid expression statements that implicitly ignore value</source>
         <target state="translated">避免会隐式忽略值的表达式语句</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
index 5f77c0aba4de1..e32d62aebba53 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
@@ -107,6 +107,11 @@
         <target state="translated">組件</target>
         <note />
       </trans-unit>
+      <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
+        <source>Automatically open Stack Trace Explorer on focus</source>
+        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
+      </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
         <source>Avoid expression statements that implicitly ignore value</source>
         <target state="translated">避免會隱含地忽略值的運算陳述式</target>

From 3028ee7aaf5bccff7d289091cf1a457669d0e0c8 Mon Sep 17 00:00:00 2001
From: Fred Silberberg <frsilb@microsoft.com>
Date: Tue, 28 Dec 2021 11:36:01 -0800
Subject: [PATCH 180/444] Report level 7 name warning for `record` when
 langversion is below 9 (#58452)

Another small bug I noticed when working on required members and touching this function. We currently do not report a level 7 warning for 'record' when the langversion is below the minimum for records.
---
 .../Portable/Symbols/Source/SourceMemberContainerSymbol.cs | 7 ++-----
 .../CSharp/Test/Semantic/Semantics/RecordTests.cs          | 7 +++++++
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs
index df51a3425bc4f..d54f61f32abb7 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs
@@ -449,12 +449,9 @@ internal static void ReportReservedTypeName(string? name, CSharpCompilation comp
                 return;
             }
 
-            if (name == SyntaxFacts.GetText(SyntaxKind.RecordKeyword))
+            if (name == SyntaxFacts.GetText(SyntaxKind.RecordKeyword) && compilation.LanguageVersion >= MessageID.IDS_FeatureRecords.RequiredVersion())
             {
-                if (compilation.LanguageVersion >= MessageID.IDS_FeatureRecords.RequiredVersion())
-                {
-                    diagnostics.Add(ErrorCode.WRN_RecordNamedDisallowed, location);
-                }
+                diagnostics.Add(ErrorCode.WRN_RecordNamedDisallowed, location);
             }
             else if (IsReservedTypeName(name))
             {
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/RecordTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/RecordTests.cs
index 1e78065f9d519..be4ff5932474b 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/RecordTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/RecordTests.cs
@@ -2873,6 +2873,13 @@ record M(record r) => r;
                 );
 
             comp = CreateCompilation(src, parseOptions: TestOptions.Regular8);
+            comp.VerifyDiagnostics(
+                // (2,7): warning CS8981: The type name 'record' only contains lower-cased ascii characters. Such names may become reserved for the language.
+                // class record { }
+                Diagnostic(ErrorCode.WRN_LowerCaseTypeName, "record").WithArguments("record").WithLocation(2, 7)
+            );
+
+            comp = CreateCompilation(src, parseOptions: TestOptions.Regular8, options: TestOptions.ReleaseDll.WithWarningLevel(6));
             comp.VerifyDiagnostics();
         }
 

From 542782dba2f85485bb7bdc2d8b2849ceb8409261 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Tue, 28 Dec 2021 10:26:11 -0800
Subject: [PATCH 181/444] Make sure Index and Range are accessible before
 offering refactorings

---
 ...dexOperatorDiagnosticAnalyzer.InfoCache.cs |  2 +-
 ...ngeOperatorDiagnosticAnalyzer.InfoCache.cs |  2 +-
 .../UseIndexOperatorTests.cs                  | 37 ++++++++++++++++++
 .../UseRangeOperatorTests.cs                  | 38 ++++++++++++++++++-
 4 files changed, 76 insertions(+), 3 deletions(-)

diff --git a/src/Analyzers/CSharp/Analyzers/UseIndexOrRangeOperator/CSharpUseIndexOperatorDiagnosticAnalyzer.InfoCache.cs b/src/Analyzers/CSharp/Analyzers/UseIndexOrRangeOperator/CSharpUseIndexOperatorDiagnosticAnalyzer.InfoCache.cs
index 518d27e7a2896..4a0cb84c4711c 100644
--- a/src/Analyzers/CSharp/Analyzers/UseIndexOrRangeOperator/CSharpUseIndexOperatorDiagnosticAnalyzer.InfoCache.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseIndexOrRangeOperator/CSharpUseIndexOperatorDiagnosticAnalyzer.InfoCache.cs
@@ -37,7 +37,7 @@ private InfoCache(INamedTypeSymbol indexType)
             public static bool TryCreate(Compilation compilation, [NotNullWhen(true)] out InfoCache? infoCache)
             {
                 var indexType = compilation.GetBestTypeByMetadataName("System.Index");
-                if (indexType == null)
+                if (indexType == null || !indexType.IsAccessibleWithin(compilation.Assembly))
                 {
                     infoCache = null;
                     return false;
diff --git a/src/Analyzers/CSharp/Analyzers/UseIndexOrRangeOperator/CSharpUseRangeOperatorDiagnosticAnalyzer.InfoCache.cs b/src/Analyzers/CSharp/Analyzers/UseIndexOrRangeOperator/CSharpUseRangeOperatorDiagnosticAnalyzer.InfoCache.cs
index dce0edef26d49..1314d73049dd8 100644
--- a/src/Analyzers/CSharp/Analyzers/UseIndexOrRangeOperator/CSharpUseRangeOperatorDiagnosticAnalyzer.InfoCache.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseIndexOrRangeOperator/CSharpUseRangeOperatorDiagnosticAnalyzer.InfoCache.cs
@@ -51,7 +51,7 @@ private InfoCache(INamedTypeSymbol rangeType, INamedTypeSymbol stringType)
             public static bool TryCreate(Compilation compilation, [NotNullWhen(true)] out InfoCache? infoCache)
             {
                 var rangeType = compilation.GetBestTypeByMetadataName("System.Range");
-                if (rangeType == null)
+                if (rangeType == null || !rangeType.IsAccessibleWithin(compilation.Assembly))
                 {
                     infoCache = null;
                     return false;
diff --git a/src/Analyzers/CSharp/Tests/UseIndexOrRangeOperator/UseIndexOperatorTests.cs b/src/Analyzers/CSharp/Tests/UseIndexOrRangeOperator/UseIndexOperatorTests.cs
index 8be8b3f432ff4..427c301fe5907 100644
--- a/src/Analyzers/CSharp/Tests/UseIndexOrRangeOperator/UseIndexOperatorTests.cs
+++ b/src/Analyzers/CSharp/Tests/UseIndexOrRangeOperator/UseIndexOperatorTests.cs
@@ -511,6 +511,43 @@ void Goo(string[] s)
                 ReferenceAssemblies = ReferenceAssemblies.NetCore.NetCoreApp20,
                 TestCode = source,
                 FixedCode = source,
+                LanguageVersion = LanguageVersion.CSharp8,
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIndexOperator)]
+        public async Task TestMissingWithInaccessibleSystemIndex()
+        {
+            var source =
+@"
+class C
+{
+    void Goo(string[] s)
+    {
+        var v = s[s.Length - 1];
+    }
+}";
+
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.NetCore.NetCoreApp20,
+                TestState =
+                {
+                    Sources = { source },
+                    AdditionalProjects =
+                    {
+                        ["AdditionalProject"] =
+                        {
+                            Sources =
+                            {
+                                "namespace System { internal struct Index { } }"
+                            }
+                        }
+                    },
+                    AdditionalProjectReferences = { "AdditionalProject" },
+                },
+                FixedCode = source,
+                LanguageVersion = LanguageVersion.CSharp8,
             }.RunAsync();
         }
 
diff --git a/src/Analyzers/CSharp/Tests/UseIndexOrRangeOperator/UseRangeOperatorTests.cs b/src/Analyzers/CSharp/Tests/UseIndexOrRangeOperator/UseRangeOperatorTests.cs
index 9960e519f58f0..8af04d6bdd4e4 100644
--- a/src/Analyzers/CSharp/Tests/UseIndexOrRangeOperator/UseRangeOperatorTests.cs
+++ b/src/Analyzers/CSharp/Tests/UseIndexOrRangeOperator/UseRangeOperatorTests.cs
@@ -94,7 +94,43 @@ void Goo(string s)
                 ReferenceAssemblies = ReferenceAssemblies.NetCore.NetCoreApp20,
                 TestCode = source,
                 FixedCode = source,
-                LanguageVersion = LanguageVersion.CSharp7,
+                LanguageVersion = LanguageVersion.CSharp8,
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseRangeOperator)]
+        public async Task TestNotWithInaccessibleSystemRange()
+        {
+            var source =
+@"
+class C
+{
+    void Goo(string s)
+    {
+        var v = s.Substring(1, s.Length - 1);
+    }
+}";
+
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.NetCore.NetCoreApp20,
+                TestState =
+                {
+                    Sources = { source },
+                    AdditionalProjects =
+                    {
+                        ["AdditionalProject"] =
+                        {
+                            Sources =
+                            {
+                                "namespace System { internal struct Range { } }"
+                            }
+                        }
+                    },
+                    AdditionalProjectReferences = { "AdditionalProject" },
+                },
+                FixedCode = source,
+                LanguageVersion = LanguageVersion.CSharp8,
             }.RunAsync();
         }
 

From 98eb7c155824a2d8ee27ba68a4fddf2354d8aad1 Mon Sep 17 00:00:00 2001
From: Shen Chen <shech@microsoft.com>
Date: Tue, 28 Dec 2021 23:32:42 -0800
Subject: [PATCH 182/444] Change TFM to Net462

---
 .../IntegrationTests/Workspace/WorkspacesNetCore.cs           | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspacesNetCore.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspacesNetCore.cs
index 7f6b11ecd61b3..2e366de400a58 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspacesNetCore.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspacesNetCore.cs
@@ -31,7 +31,7 @@ public override void OpenCSharpThenVBSolution()
             base.OpenCSharpThenVBSolution();
         }
 
-        [WpfFact(Skip = "https://github.com/dotnet/roslyn/issues/55711"), Trait(Traits.Feature, Traits.Features.Workspace)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Workspace)]
         [Trait(Traits.Feature, Traits.Features.NetCore)]
         [WorkItem(34264, "https://github.com/dotnet/roslyn/issues/34264")]
         public override void MetadataReference()
@@ -40,7 +40,7 @@ public override void MetadataReference()
             VisualStudio.SolutionExplorer.EditProjectFile(project);
             VisualStudio.Editor.SetText(@"<Project Sdk=""Microsoft.NET.Sdk"">
   <PropertyGroup>
-    <TargetFramework>net461</TargetFramework>
+    <TargetFramework>net462</TargetFramework>
   </PropertyGroup>
 </Project>");
             VisualStudio.SolutionExplorer.SaveAll();

From 2435d78fa89f25f86dc1d442b4b24663136a85e1 Mon Sep 17 00:00:00 2001
From: AlekseyTs <AlekseyTs@users.noreply.github.com>
Date: Wed, 29 Dec 2021 12:16:27 -0800
Subject: [PATCH 183/444] Optimize custom modifier check in
 PEFieldSymbol.EnsureSignatureIsLoaded. (#58522)

---
 .../CSharp/Portable/Symbols/Metadata/PE/PEFieldSymbol.cs        | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEFieldSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEFieldSymbol.cs
index 81255729de0da..6895447a75757 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEFieldSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEFieldSymbol.cs
@@ -276,7 +276,7 @@ private void EnsureSignatureIsLoaded()
                 type = NullableTypeDecoder.TransformType(type, _handle, moduleSymbol, accessSymbol: this, nullableContext: _containingType);
                 type = TupleTypeDecoder.DecodeTupleTypesIfApplicable(type, _handle, moduleSymbol);
 
-                _lazyIsVolatile = customModifiersArray.Any(m => !m.IsOptional && m.Modifier.SpecialType == SpecialType.System_Runtime_CompilerServices_IsVolatile);
+                _lazyIsVolatile = customModifiersArray.Any(m => !m.IsOptional && ((CSharpCustomModifier)m).ModifierSymbol.SpecialType == SpecialType.System_Runtime_CompilerServices_IsVolatile);
 
                 TypeSymbol fixedElementType;
                 int fixedSize;

From 0c99dcbae7b9da900b77e0be2e1476ca6af48c22 Mon Sep 17 00:00:00 2001
From: AlekseyTs <AlekseyTs@users.noreply.github.com>
Date: Wed, 29 Dec 2021 16:42:50 -0800
Subject: [PATCH 184/444] HeapOrReferenceIndexBase.Add - immediately reserve
 the slot to be resilient to a re-entrancy (#58526)

Comparisons performed by dictionaries can cause a re-entrancy and invalidate the index, unless we reserve it before that.
Fixes #58520.
---
 .../Symbol/Symbols/CustomModifiersTests.cs    | 183 ++++++++++++++++++
 .../Core/Portable/PEWriter/MetadataWriter.cs  |   2 +-
 2 files changed, 184 insertions(+), 1 deletion(-)

diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/CustomModifiersTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/CustomModifiersTests.cs
index 9005c72379cf0..73a57fcf805fc 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/CustomModifiersTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/CustomModifiersTests.cs
@@ -2815,5 +2815,188 @@ class CL3 : CL1
 @"Alice and Bob
 Charlie");
         }
+
+        [Fact]
+        [WorkItem(58520, "https://github.com/dotnet/roslyn/issues/58520")]
+        public void Issue58520_01()
+        {
+            var ilSource = @"
+.class public auto ansi beforefieldinit C1`1<T>
+    extends System.Object
+{
+    // Methods
+    .method public hidebysig static 
+        string Method () cil managed 
+    {
+        // Method begins at RVA 0x2050
+        // Code size 6 (0x6)
+        .maxstack 8
+
+        IL_0000: ldstr ""Method""
+        IL_0005: ret
+    } // end of method C1`1::Method
+
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        // Method begins at RVA 0x2057
+        // Code size 7 (0x7)
+        .maxstack 8
+
+        IL_0000: ldarg.0
+        IL_0001: call instance void System.Object::.ctor()
+        IL_0006: ret
+    } // end of method C1`1::.ctor
+
+} // end of class C1`1
+
+.class public auto ansi beforefieldinit C2`1<T>
+    extends System.Object
+{
+    // Methods
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        // Method begins at RVA 0x2057
+        // Code size 7 (0x7)
+        .maxstack 8
+
+        IL_0000: ldarg.0
+        IL_0001: call instance void System.Object::.ctor()
+        IL_0006: ret
+    } // end of method C2`1::.ctor
+
+} // end of class C2`1
+
+.class public auto ansi beforefieldinit C3`1<T>
+    extends class C1`1<int32 modopt(class C2`1<!T>)>
+{
+    // Methods
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        // Method begins at RVA 0x205f
+        // Code size 7 (0x7)
+        .maxstack 8
+
+        IL_0000: ldarg.0
+        IL_0001: call instance void class C1`1<int32>::.ctor()
+        IL_0006: ret
+    } // end of method C3`1::.ctor
+
+} // end of class C3`1
+";
+
+            var source = @"
+class Test
+{
+    static void Main()
+    {
+        M<int>();
+    }
+
+    static void M<T>()
+    {
+        System.Func<string> x = C3<T>.Method;
+        System.Console.WriteLine(x());
+    }
+}
+";
+            var compilation = CreateCompilationWithIL(source, ilSource, options: TestOptions.ReleaseExe);
+
+            CompileAndVerify(compilation, expectedOutput: @"Method");
+        }
+
+        [Fact]
+        [WorkItem(58520, "https://github.com/dotnet/roslyn/issues/58520")]
+        public void Issue58520_02()
+        {
+            var ilSource = @"
+.class public auto ansi beforefieldinit C1`1<T>
+    extends System.Object
+{
+    // Methods
+    .method public hidebysig static 
+        string Method () cil managed 
+    {
+        // Method begins at RVA 0x2050
+        // Code size 6 (0x6)
+        .maxstack 8
+
+        IL_0000: ldstr ""Method""
+        IL_0005: ret
+    } // end of method C1`1::Method
+
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        // Method begins at RVA 0x2057
+        // Code size 7 (0x7)
+        .maxstack 8
+
+        IL_0000: ldarg.0
+        IL_0001: call instance void System.Object::.ctor()
+        IL_0006: ret
+    } // end of method C1`1::.ctor
+
+} // end of class C1`1
+
+.class public auto ansi beforefieldinit C2`1<T>
+    extends System.Object
+{
+    // Methods
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        // Method begins at RVA 0x2057
+        // Code size 7 (0x7)
+        .maxstack 8
+
+        IL_0000: ldarg.0
+        IL_0001: call instance void System.Object::.ctor()
+        IL_0006: ret
+    } // end of method C2`1::.ctor
+
+} // end of class C2`1
+
+.class public auto ansi beforefieldinit C3`1<T>
+    extends class C1`1<int32 modopt(class C2`1<!T>)>
+{
+    // Methods
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        // Method begins at RVA 0x205f
+        // Code size 7 (0x7)
+        .maxstack 8
+
+        IL_0000: ldarg.0
+        IL_0001: call instance void class C1`1<int32>::.ctor()
+        IL_0006: ret
+    } // end of method C3`1::.ctor
+
+} // end of class C3`1
+";
+
+            var source = @"
+class Test
+{
+    static void Main()
+    {
+        M<int>();
+    }
+
+    static void M<T>()
+    {
+        System.Func<string> x0 = C1<int>.Method;
+        System.Func<string> x1 = C3<T>.Method;
+        System.Console.WriteLine(x0()+x1());
+    }
+}
+";
+            var compilation = CreateCompilationWithIL(source, ilSource, options: TestOptions.ReleaseExe);
+
+            CompileAndVerify(compilation, expectedOutput: @"MethodMethod");
+        }
     }
 }
diff --git a/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs b/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
index 80b96c26c2db7..17defcf93881b 100644
--- a/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
+++ b/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
@@ -4116,8 +4116,8 @@ public int Add(T item)
                 Debug.Assert(!this.TryGetValue(item, out i));
 #endif
                 int index = _firstRowId + _rows.Count;
-                this.AddItem(item, index);
                 _rows.Add(item);
+                this.AddItem(item, index);
                 return index;
             }
 

From 78f0ba59f9e894fa8ed695bc80616ebad86ba576 Mon Sep 17 00:00:00 2001
From: AlekseyTs <AlekseyTs@users.noreply.github.com>
Date: Wed, 29 Dec 2021 17:28:10 -0800
Subject: [PATCH 185/444] MemberSemanticModel - special case binding
 CompilationUnit for a simple program. (#58527)

Fixes #58521.
---
 .../Compilation/MemberSemanticModel.cs        | 48 +++++++++++--------
 .../Semantics/TopLevelStatementsTests.cs      | 19 ++++++++
 2 files changed, 47 insertions(+), 20 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Compilation/MemberSemanticModel.cs b/src/Compilers/CSharp/Portable/Compilation/MemberSemanticModel.cs
index 81c0f5698dd83..b2ec4487ff52c 100644
--- a/src/Compilers/CSharp/Portable/Compilation/MemberSemanticModel.cs
+++ b/src/Compilers/CSharp/Portable/Compilation/MemberSemanticModel.cs
@@ -1998,24 +1998,7 @@ protected void EnsureNullabilityAnalysisPerformedIfNecessary()
 
             BoundNode bind(CSharpSyntaxNode root, out Binder binder)
             {
-                if (root is CompilationUnitSyntax)
-                {
-                    // Top level statements are unique among our nodes: if there are no syntax nodes before local functions,
-                    // then that means the start of the span of the top-level statement is the same as the start of the local
-                    // function. Therefore, GetEnclosingBinder can't tell the difference, and it will get the binder for the
-                    // local function, not for the CompilationUnitSyntax. This is desirable in almost all cases but this one:
-                    // There are no locals or invocations before this, meaning there's nothing to call GetDeclaredSymbol,
-                    // GetTypeInfo, or GetSymbolInfo on. GetDeclaredSymbol(CompilationUnitSyntax) goes down another path that
-                    // does not need to do any binding whatsoever, so it also doesn't care about this behavior. The only place
-                    // that actually needs to get the enclosing binding for a CompilationUnitSyntax in such a scenario is this
-                    // method. So, if our root is the CompilationUnitSyntax, directly get the binder for it.
-                    binder = RootBinder.GetBinder(root);
-                    Debug.Assert(binder is SimpleProgramBinder);
-                }
-                else
-                {
-                    binder = GetEnclosingBinder(GetAdjustedNodePosition(root));
-                }
+                binder = GetBinderToBindNode(root);
                 return Bind(binder, root, BindingDiagnosticBag.Discarded);
             }
 
@@ -2038,6 +2021,31 @@ void rewriteAndCache()
             }
         }
 
+        private Binder GetBinderToBindNode(CSharpSyntaxNode nodeToBind)
+        {
+            Binder binder;
+            if (nodeToBind is CompilationUnitSyntax)
+            {
+                // Top level statements are unique among our nodes: if there are no syntax nodes before local functions,
+                // then that means the start of the span of the top-level statement is the same as the start of the local
+                // function. Therefore, GetEnclosingBinder can't tell the difference, and it will get the binder for the
+                // local function, not for the CompilationUnitSyntax. This is desirable in almost all cases but this one:
+                // There are no locals or invocations before this, meaning there's nothing to call GetDeclaredSymbol,
+                // GetTypeInfo, or GetSymbolInfo on. GetDeclaredSymbol(CompilationUnitSyntax) goes down another path that
+                // does not need to do any binding whatsoever, so it also doesn't care about this behavior. The only place
+                // that actually needs to get the enclosing binding for a CompilationUnitSyntax in such a scenario is this
+                // method. So, if our root is the CompilationUnitSyntax, directly get the binder for it.
+                binder = RootBinder.GetBinder(nodeToBind);
+                Debug.Assert(binder is SimpleProgramBinder);
+            }
+            else
+            {
+                binder = GetEnclosingBinder(GetAdjustedNodePosition(nodeToBind));
+            }
+
+            return binder;
+        }
+
 #nullable enable
         /// <summary>
         /// Rewrites the given bound node with nullability information, and returns snapshots for later speculative analysis at positions inside this member.
@@ -2105,7 +2113,7 @@ internal ImmutableArray<BoundNode> GetBoundNodes(CSharpSyntaxNode node)
             // If we didn't find in the cached bound nodes, find a binding root and bind it.
             // This will cache bound nodes under the binding root.
             CSharpSyntaxNode nodeToBind = GetBindingRoot(node);
-            var statementBinder = GetEnclosingBinder(GetAdjustedNodePosition(nodeToBind));
+            var statementBinder = GetBinderToBindNode(nodeToBind);
             Binder incrementalBinder = new IncrementalBinder(this, statementBinder);
 
             using (_nodeMapLock.DisposableWrite())
@@ -2126,7 +2134,7 @@ internal ImmutableArray<BoundNode> GetBoundNodes(CSharpSyntaxNode node)
             // In this case, however, we only add the single bound node we found to the map, not any child bound nodes,
             // to avoid duplicates in the map if a parent of this node comes through this code path also.
 
-            var binder = GetEnclosingBinder(GetAdjustedNodePosition(node));
+            var binder = GetBinderToBindNode(node);
             incrementalBinder = new IncrementalBinder(this, binder);
 
             using (_nodeMapLock.DisposableRead())
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/TopLevelStatementsTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/TopLevelStatementsTests.cs
index c92610ce0d4d3..f5a4253b4995d 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/TopLevelStatementsTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/TopLevelStatementsTests.cs
@@ -9587,5 +9587,24 @@ namespace NS
                 Diagnostic(ErrorCode.WRN_UnreferencedVarAssg, "x").WithArguments("x").WithLocation(6, 5)
                 );
         }
+
+        [Fact]
+        [WorkItem(58521, "https://github.com/dotnet/roslyn/issues/58521")]
+        public void BindCompilationUnitInSemanticModelWhenLocalFunctionIsAtTheTop()
+        {
+            var source = @"
+void F<T>(T t)
+{
+    var f = (ref T x) => 0;
+}
+";
+            var compilation = CreateCompilation(source, options: TestOptions.DebugDll);
+            var tree = compilation.SyntaxTrees[0];
+            var identifier = tree.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().First(id => id.Identifier.Text == "var");
+            var model = compilation.GetSemanticModel(tree);
+
+            model.GetOperation(identifier);
+            Assert.Equal(OperationKind.Literal, model.GetOperation(tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().Single()).Kind);
+        }
     }
 }

From d9ad24a6d5719a1556f3ee2c16a9103cf36ab192 Mon Sep 17 00:00:00 2001
From: Fred Silberberg <frsilb@microsoft.com>
Date: Wed, 29 Dec 2021 22:15:44 -0800
Subject: [PATCH 186/444] Update language feature status (#58525)

---
 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 003bb89aa1434..15b16f46a7454 100644
--- a/docs/Language Feature Status.md	
+++ b/docs/Language Feature Status.md	
@@ -18,7 +18,7 @@ efforts behind them.
 | [Relax ordering of `ref` and `partial` modifiers](https://github.com/dotnet/csharplang/issues/946) | [ref-partial](https://github.com/dotnet/roslyn/tree/features/ref-partial) | In Progress | [alrz](https://github.com/alrz) | [gafter](https://github.com/gafter) | [jcouv](https://github.com/jcouv) |
 | [Generic attributes](https://github.com/dotnet/csharplang/issues/124) | [generic-attributes](https://github.com/dotnet/roslyn/tree/features/generic-attributes) | [Merged into 17.0p4 (preview langver)](https://github.com/dotnet/roslyn/issues/36285) | [AviAvni](https://github.com/AviAvni) | [RikkiGibson](https://github.com/RikkiGibson), [jcouv](https://github.com/jcouv) | [mattwar](https://github.com/mattwar) |
 | [Default in deconstruction](https://github.com/dotnet/roslyn/pull/25562) | [decon-default](https://github.com/dotnet/roslyn/tree/features/decon-default) | [Implemented](https://github.com/dotnet/roslyn/issues/25559) | [jcouv](https://github.com/jcouv) | [gafter](https://github.com/gafter) | [jcouv](https://github.com/jcouv) |
-| [Semi-auto-properties](https://github.com/dotnet/csharplang/issues/140) | [semi-auto-properties](https://github.com/dotnet/roslyn/tree/features/features/semi-auto-properties) | [In Progress](https://github.com/dotnet/roslyn/issues/57012) | [Youssef1313](https://github.com/Youssef1313) | TBD | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) |
+| [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) |
 | [Required members](https://github.com/dotnet/csharplang/issues/3630) | [required-members](https://github.com/dotnet/roslyn/tree/features/required-members) | [In Progress](https://github.com/dotnet/roslyn/issues/57046) | [333fred](https://github.com/333fred) | [jcouv](https://github.com/jcouv), [RikkiGibson](https://github.com/RikkiGibson) | [333fred](https://github.com/333fred) |
 | [Top Level statement attribute specifiers](https://github.com/dotnet/csharplang/issues/5045) | [main-attributes](https://github.com/dotnet/roslyn/tree/features/features/main-attributes) | [In Progress](https://github.com/dotnet/roslyn/issues/57047) | [chsienki](https://github.com/chsienki) | TBD | [jaredpar](https://github.com/jaredpar) |
 | [Primary Constructors](https://github.com/dotnet/csharplang/issues/2691) | [primary-constructors](https://github.com/dotnet/roslyn/tree/features/features/primary-constructors) | [In Progress](https://github.com/dotnet/roslyn/issues/57048) | TBD | TBD | [MadsTorgersen](https://github.com/MadsTorgersen) |

From cb400a925dc235b505ee2163dc1501d3433d2a12 Mon Sep 17 00:00:00 2001
From: Paul Chen <lancevdance@gmail.com>
Date: Sun, 2 Jan 2022 02:10:12 +0800
Subject: [PATCH 187/444] Visit anonymous type and optionally custom modifiers
 in VisitType. (#58541)

---
 .../Portable/Symbols/TypeSymbolExtensions.cs  | 115 ++++++++---
 .../Symbol/Symbols/SymbolExtensionTests.cs    | 193 ++++++++++++++++++
 2 files changed, 281 insertions(+), 27 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Symbols/TypeSymbolExtensions.cs b/src/Compilers/CSharp/Portable/Symbols/TypeSymbolExtensions.cs
index 6b0f2459f47c4..a83da25243d79 100644
--- a/src/Compilers/CSharp/Portable/Symbols/TypeSymbolExtensions.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/TypeSymbolExtensions.cs
@@ -637,7 +637,8 @@ private static bool IsTypeLessVisibleThan(TypeSymbol type, Symbol sym, ref Compo
             this TypeSymbol type,
             Func<TypeSymbol, T, bool, bool> predicate,
             T arg,
-            bool canDigThroughNullable = false)
+            bool canDigThroughNullable = false,
+            bool visitCustomModifiers = false)
         {
             return VisitType(
                 typeWithAnnotationsOpt: default,
@@ -645,7 +646,8 @@ private static bool IsTypeLessVisibleThan(TypeSymbol type, Symbol sym, ref Compo
                 typeWithAnnotationsPredicate: null,
                 typePredicate: predicate,
                 arg,
-                canDigThroughNullable);
+                canDigThroughNullable,
+                visitCustomModifiers: visitCustomModifiers);
         }
 
         /// <summary>
@@ -666,10 +668,13 @@ private static bool IsTypeLessVisibleThan(TypeSymbol type, Symbol sym, ref Compo
             Func<TypeSymbol, T, bool, bool>? typePredicate,
             T arg,
             bool canDigThroughNullable = false,
-            bool useDefaultType = false)
+            bool useDefaultType = false,
+            bool visitCustomModifiers = false)
         {
             RoslynDebug.Assert(typeWithAnnotationsOpt.HasType == (type is null));
             RoslynDebug.Assert(canDigThroughNullable == false || useDefaultType == false, "digging through nullable will cause early resolution of nullable types");
+            RoslynDebug.Assert(canDigThroughNullable == false || visitCustomModifiers == false);
+            RoslynDebug.Assert(visitCustomModifiers == false || typePredicate is { });
 
             // In order to handle extremely "deep" types like "int[][][][][][][][][]...[]"
             // or int*****************...* we implement manual tail recursion rather than 
@@ -693,7 +698,7 @@ private static bool IsTypeLessVisibleThan(TypeSymbol type, Symbol sym, ref Compo
                             if ((object)containingType != null)
                             {
                                 isNestedNamedType = true;
-                                var result = VisitType(default, containingType, typeWithAnnotationsPredicate, typePredicate, arg, canDigThroughNullable, useDefaultType);
+                                var result = VisitType(default, containingType, typeWithAnnotationsPredicate, typePredicate, arg, canDigThroughNullable, useDefaultType, visitCustomModifiers);
                                 if (result is object)
                                 {
                                     return result;
@@ -722,6 +727,21 @@ private static bool IsTypeLessVisibleThan(TypeSymbol type, Symbol sym, ref Compo
                     }
                 }
 
+                if (visitCustomModifiers && typeWithAnnotationsOpt.HasType)
+                {
+                    foreach (var customModifier in typeWithAnnotationsOpt.CustomModifiers)
+                    {
+                        var result = VisitType(
+                            typeWithAnnotationsOpt: default, type: ((CSharpCustomModifier)customModifier).ModifierSymbol,
+                            typeWithAnnotationsPredicate, typePredicate, arg,
+                            canDigThroughNullable, useDefaultType, visitCustomModifiers);
+                        if (result is object)
+                        {
+                            return result;
+                        }
+                    }
+                }
+
                 TypeWithAnnotations next;
 
                 switch (current.TypeKind)
@@ -737,32 +757,71 @@ private static bool IsTypeLessVisibleThan(TypeSymbol type, Symbol sym, ref Compo
                     case TypeKind.Struct:
                     case TypeKind.Interface:
                     case TypeKind.Delegate:
-                        var typeArguments = ((NamedTypeSymbol)current).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics;
-                        if (typeArguments.IsEmpty)
+
+                        if (current.IsAnonymousType)
                         {
-                            return null;
-                        }
+                            var anonymous = (AnonymousTypeManager.AnonymousTypeOrDelegatePublicSymbol)current;
+                            var fields = anonymous.TypeDescriptor.Fields;
+
+                            if (fields.IsEmpty)
+                            {
+                                return null;
+                            }
+
+                            int i;
+                            for (i = 0; i < fields.Length - 1; i++)
+                            {
+                                // Let's try to avoid early resolution of nullable types
+                                (TypeWithAnnotations nextTypeWithAnnotations, TypeSymbol? nextType) = getNextIterationElements(fields[i].TypeWithAnnotations, canDigThroughNullable);
+                                var result = VisitType(
+                                    typeWithAnnotationsOpt: nextTypeWithAnnotations,
+                                    type: nextType,
+                                    typeWithAnnotationsPredicate,
+                                    typePredicate,
+                                    arg,
+                                    canDigThroughNullable,
+                                    useDefaultType,
+                                    visitCustomModifiers);
+                                if (result is object)
+                                {
+                                    return result;
+                                }
+                            }
 
-                        int i;
-                        for (i = 0; i < typeArguments.Length - 1; i++)
+                            next = fields[i].TypeWithAnnotations;
+                        }
+                        else
                         {
-                            // Let's try to avoid early resolution of nullable types
-                            (TypeWithAnnotations nextTypeWithAnnotations, TypeSymbol? nextType) = getNextIterationElements(typeArguments[i], canDigThroughNullable);
-                            var result = VisitType(
-                                typeWithAnnotationsOpt: nextTypeWithAnnotations,
-                                type: nextType,
-                                typeWithAnnotationsPredicate,
-                                typePredicate,
-                                arg,
-                                canDigThroughNullable,
-                                useDefaultType);
-                            if (result is object)
+                            var typeArguments = ((NamedTypeSymbol)current).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics;
+
+                            if (typeArguments.IsEmpty)
                             {
-                                return result;
+                                return null;
                             }
+
+                            int i;
+                            for (i = 0; i < typeArguments.Length - 1; i++)
+                            {
+                                // Let's try to avoid early resolution of nullable types
+                                (TypeWithAnnotations nextTypeWithAnnotations, TypeSymbol? nextType) = getNextIterationElements(typeArguments[i], canDigThroughNullable);
+                                var result = VisitType(
+                                    typeWithAnnotationsOpt: nextTypeWithAnnotations,
+                                    type: nextType,
+                                    typeWithAnnotationsPredicate,
+                                    typePredicate,
+                                    arg,
+                                    canDigThroughNullable,
+                                    useDefaultType,
+                                    visitCustomModifiers);
+                                if (result is object)
+                                {
+                                    return result;
+                                }
+                            }
+
+                            next = typeArguments[i];
                         }
 
-                        next = typeArguments[i];
                         break;
 
                     case TypeKind.Array:
@@ -775,7 +834,7 @@ private static bool IsTypeLessVisibleThan(TypeSymbol type, Symbol sym, ref Compo
 
                     case TypeKind.FunctionPointer:
                         {
-                            var result = visitFunctionPointerType((FunctionPointerTypeSymbol)current, typeWithAnnotationsPredicate, typePredicate, arg, useDefaultType, canDigThroughNullable, out next);
+                            var result = visitFunctionPointerType((FunctionPointerTypeSymbol)current, typeWithAnnotationsPredicate, typePredicate, arg, useDefaultType, canDigThroughNullable, visitCustomModifiers, out next);
                             if (result is object)
                             {
                                 return result;
@@ -796,7 +855,7 @@ private static bool IsTypeLessVisibleThan(TypeSymbol type, Symbol sym, ref Compo
             static (TypeWithAnnotations, TypeSymbol?) getNextIterationElements(TypeWithAnnotations type, bool canDigThroughNullable)
                 => canDigThroughNullable ? (default(TypeWithAnnotations), type.NullableUnderlyingTypeOrSelf) : (type, null);
 
-            static TypeSymbol? visitFunctionPointerType(FunctionPointerTypeSymbol type, Func<TypeWithAnnotations, T, bool, bool>? typeWithAnnotationsPredicate, Func<TypeSymbol, T, bool, bool>? typePredicate, T arg, bool useDefaultType, bool canDigThroughNullable, out TypeWithAnnotations next)
+            static TypeSymbol? visitFunctionPointerType(FunctionPointerTypeSymbol type, Func<TypeWithAnnotations, T, bool, bool>? typeWithAnnotationsPredicate, Func<TypeSymbol, T, bool, bool>? typePredicate, T arg, bool useDefaultType, bool canDigThroughNullable, bool visitCustomModifiers, out TypeWithAnnotations next)
             {
                 MethodSymbol currentPointer = type.Signature;
                 if (currentPointer.ParameterCount == 0)
@@ -812,7 +871,8 @@ private static bool IsTypeLessVisibleThan(TypeSymbol type, Symbol sym, ref Compo
                     typePredicate,
                     arg,
                     canDigThroughNullable,
-                    useDefaultType);
+                    useDefaultType,
+                    visitCustomModifiers);
                 if (result is object)
                 {
                     next = default;
@@ -830,7 +890,8 @@ private static bool IsTypeLessVisibleThan(TypeSymbol type, Symbol sym, ref Compo
                         typePredicate,
                         arg,
                         canDigThroughNullable,
-                        useDefaultType);
+                        useDefaultType,
+                        visitCustomModifiers);
                     if (result is object)
                     {
                         next = default;
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolExtensionTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolExtensionTests.cs
index 6c032e4930553..8cd545b5dd241 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolExtensionTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolExtensionTests.cs
@@ -5,9 +5,12 @@
 #nullable disable
 
 using Microsoft.CodeAnalysis.CSharp.Symbols;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Test.Utilities;
 using System;
+using System.Linq;
 using Xunit;
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests.Symbols
@@ -84,6 +87,196 @@ class C { }
             HasNameQualifierCore(namespaceNames, compilation.GetMember<NamedTypeSymbol>("NB.C"), "NB");
         }
 
+        [Fact]
+        public void VisitType_AnonymousDelegate()
+        {
+            var source = @"
+void F<T>(T t)
+{
+    var f = (ref T x) => 0;
+}
+";
+            var compilation = CreateCompilation(source, options: TestOptions.DebugDll);
+            var tree = compilation.SyntaxTrees.Single();
+            var identifier = tree.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().First(id => id.Identifier.Text == "var");
+            var model = compilation.GetSemanticModel(tree);
+            var anonymousType = model.GetSymbolInfo(identifier).Symbol.GetSymbol<TypeSymbol>();
+
+            Assert.True(anonymousType.ContainsTypeParameter());
+        }
+
+        [Fact]
+        public void VisitType_AnonymousDelegateWithAnonymousClass()
+        {
+            var source = @"
+void F<T>(T t)
+{
+    var f = (ref int x) => new { t };
+}
+";
+            var compilation = CreateCompilation(source, options: TestOptions.DebugDll);
+            var tree = compilation.SyntaxTrees.Single();
+            var identifier = tree.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().First(id => id.Identifier.Text == "var");
+            var model = compilation.GetSemanticModel(tree);
+            var anonymousType = model.GetSymbolInfo(identifier).Symbol.GetSymbol<TypeSymbol>();
+
+            Assert.True(anonymousType.ContainsTypeParameter());
+        }
+
+        [Fact]
+        public void VisitType_AnonymousClass()
+        {
+            var source = @"
+void F<T>(T t)
+{
+    var f = new { t };
+}
+";
+            var compilation = CreateCompilation(source, options: TestOptions.DebugDll);
+            var tree = compilation.SyntaxTrees.Single();
+            var identifier = tree.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().First(id => id.Identifier.Text == "var");
+            var model = compilation.GetSemanticModel(tree);
+            var anonymousType = model.GetSymbolInfo(identifier).Symbol.GetSymbol<TypeSymbol>();
+
+            Assert.True(anonymousType.ContainsTypeParameter());
+        }
+
+        [Fact]
+        public void VisitType_AnonymousClassWithAnonymousDelegate()
+        {
+            var source = @"
+void F<T>(T t)
+{
+    var f = (ref int x) => t;
+    var g = new { f };
+}
+";
+            var compilation = CreateCompilation(source, options: TestOptions.DebugDll);
+            var tree = compilation.SyntaxTrees.Single();
+            var identifier = tree.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().Last(id => id.Identifier.Text == "var");
+            var model = compilation.GetSemanticModel(tree);
+            var anonymousType = model.GetSymbolInfo(identifier).Symbol.GetSymbol<TypeSymbol>();
+
+            Assert.True(anonymousType.ContainsTypeParameter());
+        }
+
+        [Fact]
+        public void VisitType_CustomModifiers()
+        {
+            var ilSource = @"
+.class public auto ansi beforefieldinit C1`1<T>
+    extends System.Object
+{
+    // Methods
+    .method public hidebysig static 
+        string Method () cil managed 
+    {
+        // Method begins at RVA 0x2050
+        // Code size 6 (0x6)
+        .maxstack 8
+
+        IL_0000: ldstr ""Method""
+        IL_0005: ret
+    } // end of method C1`1::Method
+
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        // Method begins at RVA 0x2057
+        // Code size 7 (0x7)
+        .maxstack 8
+
+        IL_0000: ldarg.0
+        IL_0001: call instance void System.Object::.ctor()
+        IL_0006: ret
+    } // end of method C1`1::.ctor
+
+} // end of class C1`1
+
+.class public auto ansi beforefieldinit C2`1<T>
+    extends System.Object
+{
+    // Methods
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        // Method begins at RVA 0x2057
+        // Code size 7 (0x7)
+        .maxstack 8
+
+        IL_0000: ldarg.0
+        IL_0001: call instance void System.Object::.ctor()
+        IL_0006: ret
+    } // end of method C2`1::.ctor
+
+} // end of class C2`1
+
+.class public auto ansi beforefieldinit C3`1<T>
+    extends class C1`1<int32 modopt(class C2`1<!T>)>
+{
+    // Methods
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        // Method begins at RVA 0x205f
+        // Code size 7 (0x7)
+        .maxstack 8
+
+        IL_0000: ldarg.0
+        IL_0001: call instance void class C1`1<int32>::.ctor()
+        IL_0006: ret
+    } // end of method C3`1::.ctor
+
+} // end of class C3`1
+";
+
+            var source = @"
+class Test
+{
+    static void Main()
+    {
+        M<int>();
+    }
+
+    static void M<G>()
+    {
+        System.Func<string> x = C3<G>.Method;
+        System.Console.WriteLine(x());
+    }
+}
+";
+            var compilation = CreateCompilationWithIL(source, ilSource, options: TestOptions.ReleaseExe);
+
+            var tree = compilation.SyntaxTrees.Single();
+            var model = compilation.GetSemanticModel(tree);
+            var method = model.GetSymbolInfo(tree.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().Where(id => id.Identifier.ValueText == "Method").Single()).Symbol.GetSymbol<MethodSymbol>();
+
+            AssertEx.Equal("System.String C1<System.Int32 modopt(C2<G>)>.Method()", method.ToTestDisplayString());
+
+            var typeParameters = PooledHashSet<TypeParameterSymbol>.GetInstance();
+            try
+            {
+                method.ContainingType.VisitType(static (typeSymbol, typeParameters, _) =>
+                {
+                    if (typeSymbol is TypeParameterSymbol typeParameter)
+                    {
+                        typeParameters.Add(typeParameter);
+                    }
+
+                    return false;
+                },
+                typeParameters, visitCustomModifiers: true);
+
+                var typeParameter = typeParameters.Single();
+                Assert.Equal("G", typeParameter.Name);
+                Assert.Equal("M", typeParameter.ContainingSymbol.Name);
+            }
+            finally
+            {
+                typeParameters.Free();
+            }
+        }
+
         private void HasNameQualifierCore(string[] namespaceNames, NamedTypeSymbol type, string expectedName)
         {
             Assert.True(Array.IndexOf(namespaceNames, expectedName) >= 0);

From 5b63c7708a7e7e71c89d415cfe3f56145cfea5af Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Sun, 2 Jan 2022 17:31:54 -0800
Subject: [PATCH 188/444] Do not offer pattern matching inside an
 Expression-Tree

---
 ...CheckWithoutNameDiagnosticAnalyzerTests.cs | 32 ++++++++++++++-
 ...sAndCastCheckWithoutNameCodeFixProvider.cs |  4 +-
 ...dCastCheckWithoutNameDiagnosticAnalyzer.cs | 40 +++++++++++--------
 3 files changed, 57 insertions(+), 19 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/UsePatternMatching/CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzerTests.cs b/src/EditorFeatures/CSharpTest/UsePatternMatching/CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzerTests.cs
index 13de75b825b34..4d50874330cee 100644
--- a/src/EditorFeatures/CSharpTest/UsePatternMatching/CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzerTests.cs
+++ b/src/EditorFeatures/CSharpTest/UsePatternMatching/CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzerTests.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp;
@@ -546,6 +544,36 @@ where aGenericTh[||]ing is SpecificThingType
 class SpecificThingType
 {
     public SpecificThingType Prop { get; }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInlineTypeCheck)]
+        [WorkItem(58558, "https://github.com/dotnet/roslyn/issues/58558")]
+        public async Task TestInExpressionTree1()
+        {
+            await TestMissingAsync(
+@"
+using System.Linq.Expressions;
+
+object? o = null;
+Expression<Func<bool>> test = () => [||]o is int && (int)o > 5;");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInlineTypeCheck)]
+        [WorkItem(58558, "https://github.com/dotnet/roslyn/issues/58558")]
+        public async Task TestInExpressionTree2()
+        {
+            await TestMissingAsync(
+@"
+using System.Linq.Expressions;
+
+class C
+{
+    void M()
+    {
+        object? o = null;
+        Expression<Func<bool>> test = () => [||]o is int && (int)o > 5;
+    }
 }");
         }
     }
diff --git a/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameCodeFixProvider.cs b/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameCodeFixProvider.cs
index b3c76b2a70494..82b4f48740fdc 100644
--- a/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameCodeFixProvider.cs
@@ -55,8 +55,10 @@ protected override async Task FixAllAsync(
                 getInnermostNodeForTie: true, cancellationToken: cancellationToken);
 
             var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            var expressionTypeOpt = semanticModel.Compilation.GetTypeByMetadataName("System.Linq.Expressions.Expression`1");
+
             var (matches, localName) = CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.Instance.AnalyzeExpression(
-                semanticModel, isExpression, cancellationToken);
+                semanticModel, isExpression, expressionTypeOpt, cancellationToken);
 
             var updatedSemanticModel = CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.ReplaceMatches(
                 semanticModel, isExpression, localName, matches, cancellationToken);
diff --git a/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.cs
index c75fc8548e1a5..11bdec7d1600d 100644
--- a/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
@@ -16,6 +14,7 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Shared.Utilities;
 using Roslyn.Utilities;
@@ -36,9 +35,9 @@ internal class CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer : AbstractBuilt
     {
         private const string CS0165 = nameof(CS0165); // Use of unassigned local variable 's'
         private const string CS0103 = nameof(CS0103); // Name of the variable doesn't live in context
-        private static readonly SyntaxAnnotation s_referenceAnnotation = new SyntaxAnnotation();
+        private static readonly SyntaxAnnotation s_referenceAnnotation = new();
 
-        public static readonly CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer Instance = new CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer();
+        public static readonly CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer Instance = new();
 
         public CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer()
             : base(IDEDiagnosticIds.InlineIsTypeWithoutNameCheckDiagnosticsId,
@@ -54,9 +53,17 @@ public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
             => DiagnosticAnalyzerCategory.SemanticSpanAnalysis;
 
         protected override void InitializeWorker(AnalysisContext context)
-            => context.RegisterSyntaxNodeAction(SyntaxNodeAction, SyntaxKind.IsExpression);
+        {
+            context.RegisterCompilationStartAction(context =>
+            {
+                var expressionTypeOpt = context.Compilation.GetTypeByMetadataName("System.Linq.Expressions.Expression`1");
+                context.RegisterSyntaxNodeAction(context => SyntaxNodeAction(context, expressionTypeOpt), SyntaxKind.IsExpression);
+            });
+        }
 
-        private void SyntaxNodeAction(SyntaxNodeAnalysisContext context)
+        private void SyntaxNodeAction(
+            SyntaxNodeAnalysisContext context,
+            INamedTypeSymbol? expressionType)
         {
             var cancellationToken = context.CancellationToken;
             var semanticModel = context.SemanticModel;
@@ -86,30 +93,31 @@ private void SyntaxNodeAction(SyntaxNodeAnalysisContext context)
                 return;
             }
 
-            var (matches, _) = AnalyzeExpression(semanticModel, isExpression, cancellationToken);
+            var (matches, _) = AnalyzeExpression(semanticModel, isExpression, expressionType, cancellationToken);
             if (matches == null || matches.Count == 0)
-            {
                 return;
-            }
 
             context.ReportDiagnostic(
                 DiagnosticHelper.Create(
                     Descriptor, isExpression.GetLocation(),
                     styleOption.Notification.Severity,
                     SpecializedCollections.EmptyCollection<Location>(),
-                    ImmutableDictionary<string, string>.Empty));
+                    ImmutableDictionary<string, string?>.Empty));
         }
 
         public (HashSet<CastExpressionSyntax>, string localName) AnalyzeExpression(
             SemanticModel semanticModel,
             BinaryExpressionSyntax isExpression,
+            INamedTypeSymbol? expressionType,
             CancellationToken cancellationToken)
         {
             var container = GetContainer(isExpression);
             if (container == null)
-            {
                 return default;
-            }
+
+            // Pattern matching is not supported in expression tree.  So we can't fix this up.
+            if (CSharpSemanticFactsService.Instance.IsInExpressionTree(semanticModel, isExpression, expressionType, cancellationToken))
+                return default;
 
             var expr = isExpression.Left.WalkDownParentheses();
             var type = (TypeSyntax)isExpression.Right;
@@ -216,9 +224,9 @@ public static SemanticModel ReplaceMatches(
 #pragma warning restore RS1030 // Do not invoke Compilation.GetSemanticModel() method within a diagnostic analyzer
         }
 
-        private static SyntaxNode GetContainer(BinaryExpressionSyntax isExpression)
+        private static SyntaxNode? GetContainer(BinaryExpressionSyntax isExpression)
         {
-            for (SyntaxNode current = isExpression; current != null; current = current.Parent)
+            for (SyntaxNode? current = isExpression; current != null; current = current.Parent)
             {
                 switch (current)
                 {
@@ -242,7 +250,7 @@ private void AddMatches(
             // Don't bother recursing down nodes that are before the type in the is-expression.
             if (node.Span.End >= type.Span.End)
             {
-                if (node.IsKind(SyntaxKind.CastExpression, out CastExpressionSyntax castExpression))
+                if (node.IsKind(SyntaxKind.CastExpression, out CastExpressionSyntax? castExpression))
                 {
                     if (SyntaxFactory.AreEquivalent(castExpression.Type, type) &&
                         SyntaxFactory.AreEquivalent(castExpression.Expression.WalkDownParentheses(), expr))
@@ -255,7 +263,7 @@ private void AddMatches(
                 {
                     if (child.IsNode)
                     {
-                        AddMatches(child.AsNode(), expr, type, matches);
+                        AddMatches(child.AsNode()!, expr, type, matches);
                     }
                 }
             }

From 9bd26d85d4f2de447b18ff7f3af6ee6e5329351d Mon Sep 17 00:00:00 2001
From: Charles Stoner <10732005+cston@users.noreply.github.com>
Date: Mon, 3 Jan 2022 09:37:22 -0800
Subject: [PATCH 189/444] Improve error reporting for 'this()' initializer from
 'record struct' constructor

---
 .../Portable/Binder/Binder_Statements.cs      | 33 +++++++++----
 .../CSharp/Portable/CSharpResources.resx      |  2 +-
 .../Portable/xlf/CSharpResources.cs.xlf       |  4 +-
 .../Portable/xlf/CSharpResources.de.xlf       |  4 +-
 .../Portable/xlf/CSharpResources.es.xlf       |  4 +-
 .../Portable/xlf/CSharpResources.fr.xlf       |  4 +-
 .../Portable/xlf/CSharpResources.it.xlf       |  4 +-
 .../Portable/xlf/CSharpResources.ja.xlf       |  4 +-
 .../Portable/xlf/CSharpResources.ko.xlf       |  4 +-
 .../Portable/xlf/CSharpResources.pl.xlf       |  4 +-
 .../Portable/xlf/CSharpResources.pt-BR.xlf    |  4 +-
 .../Portable/xlf/CSharpResources.ru.xlf       |  4 +-
 .../Portable/xlf/CSharpResources.tr.xlf       |  4 +-
 .../Portable/xlf/CSharpResources.zh-Hans.xlf  |  4 +-
 .../Portable/xlf/CSharpResources.zh-Hant.xlf  |  4 +-
 .../Semantic/Semantics/RecordStructTests.cs   | 47 +++++++++++++++++--
 16 files changed, 93 insertions(+), 41 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
index 55c775eec99ee..707ffc0eb1c27 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
@@ -3497,10 +3497,9 @@ private BoundNode BindConstructorBody(ConstructorDeclarationSyntax constructor,
 
             bool thisInitializer = initializer?.IsKind(SyntaxKind.ThisConstructorInitializer) == true;
             if (!thisInitializer &&
-                hasAnyRecordConstructors())
+                hasRecordPrimaryConstructor())
             {
-                var constructorSymbol = (MethodSymbol)this.ContainingMember();
-                if (!constructorSymbol.IsStatic &&
+                if (isInstanceConstructor(out MethodSymbol constructorSymbol) &&
                     !SynthesizedRecordCopyCtor.IsCopyConstructor(constructorSymbol))
                 {
                     // Note: we check the constructor initializer of copy constructors elsewhere
@@ -3508,18 +3507,21 @@ private BoundNode BindConstructorBody(ConstructorDeclarationSyntax constructor,
                 }
             }
 
-            // The `: this()` initializer is ignored when it is a default value type constructor
-            // and we need to include field initializers into the constructor.
-            bool skipInitializer = includesFieldInitializers
-                && thisInitializer
+            bool isDefaultValueTypeInitializer = thisInitializer
                 && ContainingType.IsDefaultValueTypeConstructor(initializer);
 
-            if (skipInitializer &&
-                hasAnyRecordConstructors())
+            if (isDefaultValueTypeInitializer &&
+                isInstanceConstructor(out _) &&
+                hasRecordPrimaryConstructor())
             {
                 Error(diagnostics, ErrorCode.ERR_RecordStructConstructorCallsDefaultConstructor, initializer.ThisOrBaseKeyword);
             }
 
+            // The `: this()` initializer is ignored when it is a default value type constructor
+            // and we need to include field initializers into the constructor.
+            bool skipInitializer = includesFieldInitializers
+                && isDefaultValueTypeInitializer;
+
             // Using BindStatement to bind block to make sure we are reusing results of partial binding in SemanticModel
             return new BoundConstructorMethodBody(constructor,
                                                   bodyBinder.GetDeclaredLocalsForScope(constructor),
@@ -3531,8 +3533,19 @@ private BoundNode BindConstructorBody(ConstructorDeclarationSyntax constructor,
                                                       bodyBinder.BindExpressionBodyAsBlock(constructor.ExpressionBody,
                                                                                            constructor.Body == null ? diagnostics : BindingDiagnosticBag.Discarded));
 
-            bool hasAnyRecordConstructors() =>
+            bool hasRecordPrimaryConstructor() =>
                 ContainingType.GetMembersUnordered().OfType<SynthesizedRecordConstructor>().Any();
+
+            bool isInstanceConstructor(out MethodSymbol constructorSymbol)
+            {
+                if (this.ContainingMember() is MethodSymbol { IsStatic: false } method)
+                {
+                    constructorSymbol = method;
+                    return true;
+                }
+                constructorSymbol = null;
+                return false;
+            }
         }
 
         internal virtual BoundExpressionStatement BindConstructorInitializer(ConstructorInitializerSyntax initializer, BindingDiagnosticBag diagnostics)
diff --git a/src/Compilers/CSharp/Portable/CSharpResources.resx b/src/Compilers/CSharp/Portable/CSharpResources.resx
index 832ef7bcb07ea..a2d8a9e377099 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.resx
+++ b/src/Compilers/CSharp/Portable/CSharpResources.resx
@@ -6912,7 +6912,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
     <value>A lambda expression with attributes cannot be converted to an expression tree</value>
   </data>
   <data name="ERR_RecordStructConstructorCallsDefaultConstructor" xml:space="preserve">
-    <value>A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</value>
+    <value>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</value>
   </data>
   <data name="WRN_CompileTimeCheckedOverflow" xml:space="preserve">
     <value>The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</value>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
index 51e3062746355..4dc96dd386ae2 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
@@ -1068,8 +1068,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
-        <source>A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</target>
+        <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
+        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
index f003de40a6536..0a1f31f89a18a 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
@@ -1068,8 +1068,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
-        <source>A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</target>
+        <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
+        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
index 2ef18a017050e..5c52bac5afa6b 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
@@ -1068,8 +1068,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
-        <source>A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</target>
+        <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
+        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
index aa31d18909afa..2b392f5e2785a 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
@@ -1068,8 +1068,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
-        <source>A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</target>
+        <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
+        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
index 12da28eec7bc7..7d59f370dd547 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
@@ -1068,8 +1068,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
-        <source>A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</target>
+        <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
+        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
index 3249543ebb564..7e90412db3885 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
@@ -1068,8 +1068,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
-        <source>A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</target>
+        <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
+        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
index a9da4b08745aa..0efe3191f37f8 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
@@ -1068,8 +1068,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
-        <source>A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</target>
+        <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
+        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
index 3531567c78565..2f856498d1a40 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
@@ -1068,8 +1068,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
-        <source>A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</target>
+        <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
+        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
index 9c6f7af393549..be8b3c36d676d 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
@@ -1068,8 +1068,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
-        <source>A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</target>
+        <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
+        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
index 09ba053829a96..060db145dfa6e 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
@@ -1068,8 +1068,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
-        <source>A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</target>
+        <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
+        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
index 0598069f64e54..83cb76209ee3f 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
@@ -1068,8 +1068,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
-        <source>A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</target>
+        <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
+        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
index 0b34568dc2dca..de52f51125798 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
@@ -1068,8 +1068,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
-        <source>A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</target>
+        <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
+        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
index 9c55bdd59ab77..49532a745b040 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
@@ -1068,8 +1068,8 @@
         <note />
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
-        <source>A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.</target>
+        <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
+        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/RecordStructTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/RecordStructTests.cs
index a9c28b9af2914..8b5a495e1044c 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/RecordStructTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/RecordStructTests.cs
@@ -10780,10 +10780,10 @@ public S4(object o) : this() { }
 }";
             var comp = CreateCompilation(source);
             comp.VerifyDiagnostics(
-                // (3,27): error CS8982: A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.
+                // (3,27): error CS8982: A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.
                 //     public S3(object o) : this() { }
                 Diagnostic(ErrorCode.ERR_RecordStructConstructorCallsDefaultConstructor, "this").WithLocation(3, 27),
-                // (7,27): error CS8982: A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.
+                // (7,27): error CS8982: A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.
                 //     public S4(object o) : this() { }
                 Diagnostic(ErrorCode.ERR_RecordStructConstructorCallsDefaultConstructor, "this").WithLocation(7, 27));
         }
@@ -10805,10 +10805,10 @@ record struct S4(char A, char B)
 }";
             var comp = CreateCompilation(source);
             comp.VerifyDiagnostics(
-                // (4,27): error CS8982: A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.
+                // (4,27): error CS8982: A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.
                 //     public S3(object o) : this() { F = o; }
                 Diagnostic(ErrorCode.ERR_RecordStructConstructorCallsDefaultConstructor, "this").WithLocation(4, 27),
-                // (9,27): error CS8982: A 'this' initializer for a 'record struct' constructor must call the primary constructor or an explicitly declared constructor.
+                // (9,27): error CS8982: A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.
                 //     public S4(object o) : this() { F = o; }
                 Diagnostic(ErrorCode.ERR_RecordStructConstructorCallsDefaultConstructor, "this").WithLocation(9, 27));
         }
@@ -10960,5 +10960,44 @@ public S3(object o) : base() { }
                 //     public S3(object o) : base() { }
                 Diagnostic(ErrorCode.ERR_UnexpectedOrMissingConstructorInitializerInRecord, "base").WithLocation(11, 27));
         }
+
+        [Fact]
+        [WorkItem(58328, "https://github.com/dotnet/roslyn/issues/58328")]
+        public void ExplicitConstructors_10()
+        {
+            var source =
+@"record struct S(object F)
+{
+    public object F;
+    public S(int i) : this() { F = i; }
+}";
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (1,15): error CS0171: Field 'S.F' must be fully assigned before control is returned to the caller
+                // record struct S(object F)
+                Diagnostic(ErrorCode.ERR_UnassignedThis, "S").WithArguments("S.F").WithLocation(1, 15),
+                // (1,24): warning CS8907: Parameter 'F' is unread. Did you forget to use it to initialize the property with that name?
+                // record struct S(object F)
+                Diagnostic(ErrorCode.WRN_UnreadRecordParameter, "F").WithArguments("F").WithLocation(1, 24),
+                // (4,23): error CS8982: A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.
+                //     public S(int i) : this() { F = i; }
+                Diagnostic(ErrorCode.ERR_RecordStructConstructorCallsDefaultConstructor, "this").WithLocation(4, 23));
+        }
+
+        [Fact]
+        public void ExplicitConstructors_11()
+        {
+            var source =
+@"record struct S(int X)
+{
+    static internal int F = 1;
+    static S() : this() { }
+}";
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (4,18): error CS0514: 'S': static constructor cannot have an explicit 'this' or 'base' constructor call
+                //     static S() : this() { }
+                Diagnostic(ErrorCode.ERR_StaticConstructorWithExplicitConstructorCall, "this").WithArguments("S").WithLocation(4, 18));
+        }
     }
 }

From 82cff972e9afae50578654bf8c627e485006f7b6 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Mon, 3 Jan 2022 10:07:53 -0800
Subject: [PATCH 190/444] Use existing extension

---
 .../CSharpUsePatternCombinatorsDiagnosticAnalyzer.cs           | 3 ++-
 .../AbstractUseNullPropagationDiagnosticAnalyzer.cs            | 3 ++-
 .../AbstractUseThrowExpressionDiagnosticAnalyzer.cs            | 2 +-
 .../UseCoalesceExpressionCodeFixProvider.cs                    | 2 +-
 .../UseCoalesceExpressionForNullableCodeFixProvider.cs         | 2 +-
 .../CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzerTests.cs  | 1 +
 .../CSharpIsAndCastCheckWithoutNameCodeFixProvider.cs          | 2 +-
 .../CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.cs       | 2 +-
 8 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/src/Analyzers/CSharp/Analyzers/UsePatternCombinators/CSharpUsePatternCombinatorsDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UsePatternCombinators/CSharpUsePatternCombinatorsDiagnosticAnalyzer.cs
index 574dc7b83c156..c10714973ca04 100644
--- a/src/Analyzers/CSharp/Analyzers/UsePatternCombinators/CSharpUsePatternCombinatorsDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UsePatternCombinators/CSharpUsePatternCombinatorsDiagnosticAnalyzer.cs
@@ -10,6 +10,7 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Operations;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 
 namespace Microsoft.CodeAnalysis.CSharp.UsePatternCombinators
 {
@@ -70,7 +71,7 @@ private void AnalyzeNode(SyntaxNodeAnalysisContext context)
                 return;
 
             var semanticModel = context.SemanticModel;
-            var expressionType = semanticModel.Compilation.GetTypeByMetadataName("System.Linq.Expressions.Expression`1");
+            var expressionType = semanticModel.Compilation.ExpressionOfTType();
             if (expression.IsInExpressionTree(semanticModel, expressionType, cancellationToken))
                 return;
 
diff --git a/src/Analyzers/Core/Analyzers/UseNullPropagation/AbstractUseNullPropagationDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/UseNullPropagation/AbstractUseNullPropagationDiagnosticAnalyzer.cs
index e498e23f805fc..6b1c9183d870d 100644
--- a/src/Analyzers/Core/Analyzers/UseNullPropagation/AbstractUseNullPropagationDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/UseNullPropagation/AbstractUseNullPropagationDiagnosticAnalyzer.cs
@@ -9,6 +9,7 @@
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.LanguageServices;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 
 namespace Microsoft.CodeAnalysis.UseNullPropagation
 {
@@ -65,7 +66,7 @@ protected override void InitializeWorker(AnalysisContext context)
                     return;
                 }
 
-                var expressionTypeOpt = startContext.Compilation.GetTypeByMetadataName("System.Linq.Expressions.Expression`1");
+                var expressionTypeOpt = startContext.Compilation.ExpressionOfTType();
 
                 var objectType = startContext.Compilation.GetSpecialType(SpecialType.System_Object);
                 var referenceEqualsMethodOpt = objectType?.GetMembers(nameof(ReferenceEquals))
diff --git a/src/Analyzers/Core/Analyzers/UseThrowExpression/AbstractUseThrowExpressionDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/UseThrowExpression/AbstractUseThrowExpressionDiagnosticAnalyzer.cs
index 35874a59db62a..22cd0fa3dffea 100644
--- a/src/Analyzers/Core/Analyzers/UseThrowExpression/AbstractUseThrowExpressionDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/UseThrowExpression/AbstractUseThrowExpressionDiagnosticAnalyzer.cs
@@ -63,7 +63,7 @@ protected override void InitializeWorker(AnalysisContext context)
                     return;
                 }
 
-                var expressionTypeOpt = startContext.Compilation.GetTypeByMetadataName("System.Linq.Expressions.Expression`1");
+                var expressionTypeOpt = startContext.Compilation.ExpressionOfTType();
                 startContext.RegisterOperationAction(operationContext => AnalyzeOperation(operationContext, expressionTypeOpt), OperationKind.Throw);
             });
         }
diff --git a/src/Analyzers/Core/CodeFixes/UseCoalesceExpression/UseCoalesceExpressionCodeFixProvider.cs b/src/Analyzers/Core/CodeFixes/UseCoalesceExpression/UseCoalesceExpressionCodeFixProvider.cs
index 7b5176384e03e..f572e087a4fe9 100644
--- a/src/Analyzers/Core/CodeFixes/UseCoalesceExpression/UseCoalesceExpressionCodeFixProvider.cs
+++ b/src/Analyzers/Core/CodeFixes/UseCoalesceExpression/UseCoalesceExpressionCodeFixProvider.cs
@@ -48,7 +48,7 @@ protected override async Task FixAllAsync(
             SyntaxEditor editor, CancellationToken cancellationToken)
         {
             var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
-            var expressionTypeOpt = semanticModel.Compilation.GetTypeByMetadataName("System.Linq.Expressions.Expression`1");
+            var expressionTypeOpt = semanticModel.Compilation.ExpressionOfTType();
             var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
             var semanticFacts = document.GetRequiredLanguageService<ISemanticFactsService>();
 
diff --git a/src/Analyzers/Core/CodeFixes/UseCoalesceExpression/UseCoalesceExpressionForNullableCodeFixProvider.cs b/src/Analyzers/Core/CodeFixes/UseCoalesceExpression/UseCoalesceExpressionForNullableCodeFixProvider.cs
index f967e4f4fc5d7..b189fa68e52b1 100644
--- a/src/Analyzers/Core/CodeFixes/UseCoalesceExpression/UseCoalesceExpressionForNullableCodeFixProvider.cs
+++ b/src/Analyzers/Core/CodeFixes/UseCoalesceExpression/UseCoalesceExpressionForNullableCodeFixProvider.cs
@@ -47,7 +47,7 @@ protected override async Task FixAllAsync(
             SyntaxEditor editor, CancellationToken cancellationToken)
         {
             var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
-            var expressionTypeOpt = semanticModel.Compilation.GetTypeByMetadataName("System.Linq.Expressions.Expression`1");
+            var expressionTypeOpt = semanticModel.Compilation.ExpressionOfTType();
 
             var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
             var semanticFacts = document.GetRequiredLanguageService<ISemanticFactsService>();
diff --git a/src/EditorFeatures/CSharpTest/UsePatternMatching/CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzerTests.cs b/src/EditorFeatures/CSharpTest/UsePatternMatching/CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzerTests.cs
index 4d50874330cee..dfa5452e6963f 100644
--- a/src/EditorFeatures/CSharpTest/UsePatternMatching/CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzerTests.cs
+++ b/src/EditorFeatures/CSharpTest/UsePatternMatching/CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzerTests.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.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp;
diff --git a/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameCodeFixProvider.cs b/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameCodeFixProvider.cs
index 82b4f48740fdc..77045f1fd4069 100644
--- a/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameCodeFixProvider.cs
@@ -55,7 +55,7 @@ protected override async Task FixAllAsync(
                 getInnermostNodeForTie: true, cancellationToken: cancellationToken);
 
             var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
-            var expressionTypeOpt = semanticModel.Compilation.GetTypeByMetadataName("System.Linq.Expressions.Expression`1");
+            var expressionTypeOpt = semanticModel.Compilation.ExpressionOfTType();
 
             var (matches, localName) = CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.Instance.AnalyzeExpression(
                 semanticModel, isExpression, expressionTypeOpt, cancellationToken);
diff --git a/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.cs
index 11bdec7d1600d..8fd22d2e3a2db 100644
--- a/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.cs
@@ -56,7 +56,7 @@ protected override void InitializeWorker(AnalysisContext context)
         {
             context.RegisterCompilationStartAction(context =>
             {
-                var expressionTypeOpt = context.Compilation.GetTypeByMetadataName("System.Linq.Expressions.Expression`1");
+                var expressionTypeOpt = context.Compilation.ExpressionOfTType();
                 context.RegisterSyntaxNodeAction(context => SyntaxNodeAction(context, expressionTypeOpt), SyntaxKind.IsExpression);
             });
         }

From 546ccb81f4c6b20f5e0edac2a5c81fe728765adf Mon Sep 17 00:00:00 2001
From: David Barbet <dabarbet@microsoft.com>
Date: Mon, 3 Jan 2022 10:47:53 -0800
Subject: [PATCH 191/444] Revert "Update System.Text.Json to 6.0.0 (#58365)"

This reverts commit 2fa822ba950fb25ac529b2e236810f04cc65fec1.
---
 eng/Versions.props | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/eng/Versions.props b/eng/Versions.props
index 5f8c358c92b7d..f0ffd74e8c5fe 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -237,7 +237,7 @@
     <SystemTextEncodingCodePagesVersion>4.5.1</SystemTextEncodingCodePagesVersion>
     <SystemTextEncodingExtensionsVersion>4.3.0</SystemTextEncodingExtensionsVersion>
     <!-- Note: When updating SystemTextJsonVersion ensure that the version is no higher than what is used by MSBuild. -->
-    <SystemTextJsonVersion>6.0.0</SystemTextJsonVersion>
+    <SystemTextJsonVersion>4.7.0</SystemTextJsonVersion>
     <SystemThreadingTasksDataflowVersion>5.0.0</SystemThreadingTasksDataflowVersion>
     <!-- We need System.ValueTuple assembly version at least 4.0.3.0 on net47 to make F5 work against Dev15 - see https://github.com/dotnet/roslyn/issues/29705 -->
     <SystemValueTupleVersion>4.5.0</SystemValueTupleVersion>
@@ -279,7 +279,7 @@
     -->
     <SystemCollectionsImmutableVersion>5.0.0</SystemCollectionsImmutableVersion>
     <SystemReflectionMetadataVersion>5.0.0</SystemReflectionMetadataVersion>
-    <MicrosoftBclAsyncInterfacesVersion>6.0.0</MicrosoftBclAsyncInterfacesVersion>
+    <MicrosoftBclAsyncInterfacesVersion>5.0.0</MicrosoftBclAsyncInterfacesVersion>
   </PropertyGroup>
   <PropertyGroup>
     <UsingToolPdbConverter>true</UsingToolPdbConverter>

From d21980410ef4425bc70bb32deaee6cb5f6325b41 Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Mon, 3 Jan 2022 14:16:35 -0800
Subject: [PATCH 192/444] Exclude service config files for .Net 6 host from
 ServiceHub folder

---
 .../Roslyn.VisualStudio.Setup.ServiceHub.csproj              | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/Setup/DevDivVsix/ServiceHubConfig/Roslyn.VisualStudio.Setup.ServiceHub.csproj b/src/Setup/DevDivVsix/ServiceHubConfig/Roslyn.VisualStudio.Setup.ServiceHub.csproj
index f77061c898dc0..b1a85e04a8c93 100644
--- a/src/Setup/DevDivVsix/ServiceHubConfig/Roslyn.VisualStudio.Setup.ServiceHub.csproj
+++ b/src/Setup/DevDivVsix/ServiceHubConfig/Roslyn.VisualStudio.Setup.ServiceHub.csproj
@@ -27,10 +27,11 @@
           Outputs="$(_SwrFilePath)">
 
     <ItemGroup>
+      <!-- We are shipping a copy of config files for Roslyn desktop services in ServiceHub folder, which is to mitigate an issue where the VsixDiscoveryService is 
+           flaky and occasionally not finding the Roslyn services properly. However, we can't do the same for services running on .Net Core host because the config
+           file location is used as default path to resolve service assemblies. -->
       <_ServiceHubConfigFiles Include="@(ServiceHubService)" FileSuffix="64" />
       <_ServiceHubConfigFiles Include="@(ServiceHubService)" FileSuffix="64S" />
-      <_ServiceHubConfigFiles Include="@(ServiceHubService)" FileSuffix="Core64" />
-      <_ServiceHubConfigFiles Include="@(ServiceHubService)" FileSuffix="Core64S" />
       <_FileEntries Include='file source="$(IntermediateOutputPath)%(_ServiceHubConfigFiles.Identity)%(_ServiceHubConfigFiles.FileSuffix).servicehub.service.json"'/>
     </ItemGroup>
 

From 966a26ce2d3a8bb2437688e4ea8f112d602f976f Mon Sep 17 00:00:00 2001
From: Thijs Brobbel <thijsbrobbel@gmail.com>
Date: Tue, 4 Jan 2022 00:10:50 +0100
Subject: [PATCH 193/444] Add nullability annotation to CopyAnnotationsTo()
 (#57992)

Fixes #56949.
---
 src/Compilers/Core/Portable/Syntax/SyntaxNode.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Compilers/Core/Portable/Syntax/SyntaxNode.cs b/src/Compilers/Core/Portable/Syntax/SyntaxNode.cs
index 17ea066d21b8e..e26e7f61f374f 100644
--- a/src/Compilers/Core/Portable/Syntax/SyntaxNode.cs
+++ b/src/Compilers/Core/Portable/Syntax/SyntaxNode.cs
@@ -1251,6 +1251,7 @@ internal SyntaxNode GetNodeWithoutAnnotations(IEnumerable<SyntaxAnnotation> anno
         /// modification, even if the type of a node changes.
         /// </para>
         /// </remarks>
+        [return: NotNullIfNotNull("node")]
         public T? CopyAnnotationsTo<T>(T? node) where T : SyntaxNode
         {
             if (node == null)

From 7b06584f007d07df52225a1556ed6698369c5b08 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Mon, 3 Jan 2022 15:53:00 -0800
Subject: [PATCH 194/444] Track nullability information in publicAPI files for
 C# compiler (#41000)

---
 ...ding, Debugging, and Testing on Windows.md |   11 +
 .../CSharp/Portable/PublicAPI.Shipped.txt     | 8347 +++++++++--------
 .../CSharp/Portable/PublicAPI.Unshipped.txt   |  356 +-
 .../Syntax/AnonymousMethodExpressionSyntax.cs |    1 +
 .../Portable/Syntax/LambdaExpressionSyntax.cs |    1 +
 5 files changed, 4365 insertions(+), 4351 deletions(-)

diff --git a/docs/contributing/Building, Debugging, and Testing on Windows.md b/docs/contributing/Building, Debugging, and Testing on Windows.md
index d550919ebf3ad..aa8bd58444844 100644
--- a/docs/contributing/Building, Debugging, and Testing on Windows.md	
+++ b/docs/contributing/Building, Debugging, and Testing on Windows.md	
@@ -182,6 +182,17 @@ Run `build.cmd -testIOperation` which sets the `ROSLYN_TEST_IOPERATION` environm
 For running those tests in an IDE, the easiest is to find the `//#define ROSLYN_TEST_IOPERATION` directive and uncomment it.
 See more details in the [IOperation test hook](https://github.com/dotnet/roslyn/blob/main/docs/compilers/IOperation%20Test%20Hook.md) doc.
 
+### Running the PublicAPI fixer
+
+1. Install `dotnet-format` as a global tool. It does ship as part of the SDK, but a separate version can be installed as a global tool and invoked with `dotnet-format {options}`.
+`C:\Source\roslyn> dotnet tool install -g dotnet-format --version "6.*" --add-source https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet6/nuget/v3/index.json`
+2. Restore and build `Compilers.sln`. This is necessary to ensure the source generator project is built and we can load the generator assembly when running `dotnet-format`.
+`C:\Source\roslyn> .\restore.cmd`
+`C:\Source\roslyn> .\build.cmd`
+3. Invoke the `dotnet-format` global tool. Running only the analyzers subcommand and fixing only the "missing Public API signature" diagnostic. We must also pass the `--include-generated` flag to include source generated documents in the analysis.
+`C:\Source\roslyn> cd ..`
+`C:\Source> dotnet-format analyzers .\roslyn\Compilers.sln --diagnostics=RS0016 --no-restore --include-generated -v diag`
+
 ## Contributing
 
 Please see [Contributing Code](https://github.com/dotnet/roslyn/blob/main/CONTRIBUTING.md) for details on contributing changes back to the code.
diff --git a/src/Compilers/CSharp/Portable/PublicAPI.Shipped.txt b/src/Compilers/CSharp/Portable/PublicAPI.Shipped.txt
index 9bc884ddfdfef..4394c73ed1a6f 100644
--- a/src/Compilers/CSharp/Portable/PublicAPI.Shipped.txt
+++ b/src/Compilers/CSharp/Portable/PublicAPI.Shipped.txt
@@ -1,70 +1,71 @@
-abstract Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-abstract Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-abstract Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetRoot(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode
-abstract Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.Options.get -> Microsoft.CodeAnalysis.CSharp.CSharpParseOptions
-abstract Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.TryGetRoot(out Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode root) -> bool
+#nullable enable
+abstract Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+abstract Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+abstract Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetRoot(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode!
+abstract Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.Options.get -> Microsoft.CodeAnalysis.CSharp.CSharpParseOptions!
+abstract Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.TryGetRoot(out Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode? root) -> bool
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.AsyncKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.Block.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.Block.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax?
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax?
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseArgumentListSyntax.Arguments.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax>
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseCrefParameterListSyntax.Parameters.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax>
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.Declaration.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseArgumentListSyntax.Arguments.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!>
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseCrefParameterListSyntax.Parameters.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax!>
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.Declaration.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax!
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.Body.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.Body.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax?
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax?
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax!
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax?
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax?
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.NewKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterListSyntax.Parameters.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax>
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterListSyntax.Parameters.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!>
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.AccessorList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.ExplicitInterfaceSpecifier.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.BaseList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax?
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.AccessorList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax?
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.ExplicitInterfaceSpecifier.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax?
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.BaseList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax?
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.CloseBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.OpenBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.BranchingDirectiveTriviaSyntax.BranchTaken.get -> bool
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.AwaitKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.ForEachKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.InKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalDirectiveTriviaSyntax.Condition.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalDirectiveTriviaSyntax.Condition.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalDirectiveTriviaSyntax.ConditionValue.get -> bool
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.EndOfDirectiveToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.HashToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.IsActive.get -> bool
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.ArrowToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax.ColonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax.Keyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.ConstraintClauses.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.ConstraintClauses.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!>
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.Keyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.Members.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax>
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.TypeParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.Members.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!>
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.TypeParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax?
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.EndQuoteToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.EqualsToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax!
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.StartQuoteToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo
 Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.AwaitExpressionInfo() -> void
 Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.Equals(Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo other) -> bool
-Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.GetAwaiterMethod.get -> Microsoft.CodeAnalysis.IMethodSymbol
-Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.GetResultMethod.get -> Microsoft.CodeAnalysis.IMethodSymbol
-Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.IsCompletedProperty.get -> Microsoft.CodeAnalysis.IPropertySymbol
+Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.GetAwaiterMethod.get -> Microsoft.CodeAnalysis.IMethodSymbol?
+Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.GetResultMethod.get -> Microsoft.CodeAnalysis.IMethodSymbol?
+Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.IsCompletedProperty.get -> Microsoft.CodeAnalysis.IPropertySymbol?
 Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.IsDynamic.get -> bool
 Microsoft.CodeAnalysis.CSharp.Conversion
 Microsoft.CodeAnalysis.CSharp.Conversion.Conversion() -> void
@@ -95,120 +96,120 @@ Microsoft.CodeAnalysis.CSharp.Conversion.IsTupleConversion.get -> bool
 Microsoft.CodeAnalysis.CSharp.Conversion.IsTupleLiteralConversion.get -> bool
 Microsoft.CodeAnalysis.CSharp.Conversion.IsUnboxing.get -> bool
 Microsoft.CodeAnalysis.CSharp.Conversion.IsUserDefined.get -> bool
-Microsoft.CodeAnalysis.CSharp.Conversion.MethodSymbol.get -> Microsoft.CodeAnalysis.IMethodSymbol
+Microsoft.CodeAnalysis.CSharp.Conversion.MethodSymbol.get -> Microsoft.CodeAnalysis.IMethodSymbol?
 Microsoft.CodeAnalysis.CSharp.Conversion.ToCommonConversion() -> Microsoft.CodeAnalysis.Operations.CommonConversion
 Microsoft.CodeAnalysis.CSharp.CSharpCommandLineArguments
-Microsoft.CodeAnalysis.CSharp.CSharpCommandLineArguments.CompilationOptions.get -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCommandLineArguments.ParseOptions.get -> Microsoft.CodeAnalysis.CSharp.CSharpParseOptions
+Microsoft.CodeAnalysis.CSharp.CSharpCommandLineArguments.CompilationOptions.get -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCommandLineArguments.ParseOptions.get -> Microsoft.CodeAnalysis.CSharp.CSharpParseOptions!
 Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser
-Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.Parse(System.Collections.Generic.IEnumerable<string> args, string baseDirectory, string sdkDirectory, string additionalReferenceDirectories = null) -> Microsoft.CodeAnalysis.CSharp.CSharpCommandLineArguments
+Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.Parse(System.Collections.Generic.IEnumerable<string!>! args, string? baseDirectory, string? sdkDirectory, string? additionalReferenceDirectories = null) -> Microsoft.CodeAnalysis.CSharp.CSharpCommandLineArguments!
 Microsoft.CodeAnalysis.CSharp.CSharpCompilation
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.AddReferences(params Microsoft.CodeAnalysis.MetadataReference[] references) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.AddReferences(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.MetadataReference> references) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.AddSyntaxTrees(params Microsoft.CodeAnalysis.SyntaxTree[] trees) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.AddSyntaxTrees(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxTree> trees) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ClassifyConversion(Microsoft.CodeAnalysis.ITypeSymbol source, Microsoft.CodeAnalysis.ITypeSymbol destination) -> Microsoft.CodeAnalysis.CSharp.Conversion
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Clone() -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ContainsSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree syntaxTree) -> bool
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetDirectiveReference(Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax directive) -> Microsoft.CodeAnalysis.MetadataReference
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetMetadataReference(Microsoft.CodeAnalysis.IAssemblySymbol assemblySymbol) -> Microsoft.CodeAnalysis.MetadataReference
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree syntaxTree, bool ignoreAccessibility) -> Microsoft.CodeAnalysis.SemanticModel
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.AddReferences(params Microsoft.CodeAnalysis.MetadataReference![]! references) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.AddReferences(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.MetadataReference!>! references) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.AddSyntaxTrees(params Microsoft.CodeAnalysis.SyntaxTree![]! trees) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.AddSyntaxTrees(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxTree!>! trees) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ClassifyConversion(Microsoft.CodeAnalysis.ITypeSymbol! source, Microsoft.CodeAnalysis.ITypeSymbol! destination) -> Microsoft.CodeAnalysis.CSharp.Conversion
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Clone() -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ContainsSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree? syntaxTree) -> bool
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetDirectiveReference(Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax! directive) -> Microsoft.CodeAnalysis.MetadataReference?
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetMetadataReference(Microsoft.CodeAnalysis.IAssemblySymbol! assemblySymbol) -> Microsoft.CodeAnalysis.MetadataReference?
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree! syntaxTree, bool ignoreAccessibility) -> Microsoft.CodeAnalysis.SemanticModel!
 Microsoft.CodeAnalysis.CSharp.CSharpCompilation.LanguageVersion.get -> Microsoft.CodeAnalysis.CSharp.LanguageVersion
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Options.get -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveAllReferences() -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveAllSyntaxTrees() -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveReferences(params Microsoft.CodeAnalysis.MetadataReference[] references) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveReferences(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.MetadataReference> references) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveSyntaxTrees(params Microsoft.CodeAnalysis.SyntaxTree[] trees) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveSyntaxTrees(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxTree> trees) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ReplaceReference(Microsoft.CodeAnalysis.MetadataReference oldReference, Microsoft.CodeAnalysis.MetadataReference newReference) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ReplaceSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree oldTree, Microsoft.CodeAnalysis.SyntaxTree newTree) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ScriptCompilationInfo.get -> Microsoft.CodeAnalysis.CSharp.CSharpScriptCompilationInfo
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.SyntaxTrees.get -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.SyntaxTree>
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithAssemblyName(string assemblyName) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithOptions(Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions options) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithReferences(params Microsoft.CodeAnalysis.MetadataReference[] references) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithReferences(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.MetadataReference> references) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation
-Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithScriptCompilationInfo(Microsoft.CodeAnalysis.CSharp.CSharpScriptCompilationInfo info) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Options.get -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveAllReferences() -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveAllSyntaxTrees() -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveReferences(params Microsoft.CodeAnalysis.MetadataReference![]! references) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveReferences(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.MetadataReference!>! references) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveSyntaxTrees(params Microsoft.CodeAnalysis.SyntaxTree![]! trees) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.RemoveSyntaxTrees(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxTree!>! trees) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ReplaceReference(Microsoft.CodeAnalysis.MetadataReference! oldReference, Microsoft.CodeAnalysis.MetadataReference! newReference) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ReplaceSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree! oldTree, Microsoft.CodeAnalysis.SyntaxTree? newTree) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ScriptCompilationInfo.get -> Microsoft.CodeAnalysis.CSharp.CSharpScriptCompilationInfo?
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.SyntaxTrees.get -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.SyntaxTree!>
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithAssemblyName(string? assemblyName) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithOptions(Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions! options) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithReferences(params Microsoft.CodeAnalysis.MetadataReference![]! references) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithReferences(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.MetadataReference!>? references) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilation.WithScriptCompilationInfo(Microsoft.CodeAnalysis.CSharp.CSharpScriptCompilationInfo? info) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation!
 Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
 Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.AllowUnsafe.get -> bool
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CSharpCompilationOptions(Microsoft.CodeAnalysis.OutputKind outputKind, bool reportSuppressedDiagnostics = false, string moduleName = null, string mainTypeName = null, string scriptClassName = null, System.Collections.Generic.IEnumerable<string> usings = null, Microsoft.CodeAnalysis.OptimizationLevel optimizationLevel = Microsoft.CodeAnalysis.OptimizationLevel.Debug, bool checkOverflow = false, bool allowUnsafe = false, string cryptoKeyContainer = null, string cryptoKeyFile = null, System.Collections.Immutable.ImmutableArray<byte> cryptoPublicKey = default(System.Collections.Immutable.ImmutableArray<byte>), bool? delaySign = null, Microsoft.CodeAnalysis.Platform platform = Microsoft.CodeAnalysis.Platform.AnyCpu, Microsoft.CodeAnalysis.ReportDiagnostic generalDiagnosticOption = Microsoft.CodeAnalysis.ReportDiagnostic.Default, int warningLevel = 4, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, Microsoft.CodeAnalysis.ReportDiagnostic>> specificDiagnosticOptions = null, bool concurrentBuild = true, bool deterministic = false, Microsoft.CodeAnalysis.XmlReferenceResolver xmlReferenceResolver = null, Microsoft.CodeAnalysis.SourceReferenceResolver sourceReferenceResolver = null, Microsoft.CodeAnalysis.MetadataReferenceResolver metadataReferenceResolver = null, Microsoft.CodeAnalysis.AssemblyIdentityComparer assemblyIdentityComparer = null, Microsoft.CodeAnalysis.StrongNameProvider strongNameProvider = null, bool publicSign = false, Microsoft.CodeAnalysis.MetadataImportOptions metadataImportOptions = Microsoft.CodeAnalysis.MetadataImportOptions.Public, Microsoft.CodeAnalysis.NullableContextOptions nullableContextOptions = Microsoft.CodeAnalysis.NullableContextOptions.Disable) -> void
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CSharpCompilationOptions(Microsoft.CodeAnalysis.OutputKind outputKind, bool reportSuppressedDiagnostics, string moduleName, string mainTypeName, string scriptClassName, System.Collections.Generic.IEnumerable<string> usings, Microsoft.CodeAnalysis.OptimizationLevel optimizationLevel, bool checkOverflow, bool allowUnsafe, string cryptoKeyContainer, string cryptoKeyFile, System.Collections.Immutable.ImmutableArray<byte> cryptoPublicKey, bool? delaySign, Microsoft.CodeAnalysis.Platform platform, Microsoft.CodeAnalysis.ReportDiagnostic generalDiagnosticOption, int warningLevel, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, Microsoft.CodeAnalysis.ReportDiagnostic>> specificDiagnosticOptions, bool concurrentBuild, bool deterministic, Microsoft.CodeAnalysis.XmlReferenceResolver xmlReferenceResolver, Microsoft.CodeAnalysis.SourceReferenceResolver sourceReferenceResolver, Microsoft.CodeAnalysis.MetadataReferenceResolver metadataReferenceResolver, Microsoft.CodeAnalysis.AssemblyIdentityComparer assemblyIdentityComparer, Microsoft.CodeAnalysis.StrongNameProvider strongNameProvider) -> void
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CSharpCompilationOptions(Microsoft.CodeAnalysis.OutputKind outputKind, bool reportSuppressedDiagnostics, string moduleName, string mainTypeName, string scriptClassName, System.Collections.Generic.IEnumerable<string> usings, Microsoft.CodeAnalysis.OptimizationLevel optimizationLevel, bool checkOverflow, bool allowUnsafe, string cryptoKeyContainer, string cryptoKeyFile, System.Collections.Immutable.ImmutableArray<byte> cryptoPublicKey, bool? delaySign, Microsoft.CodeAnalysis.Platform platform, Microsoft.CodeAnalysis.ReportDiagnostic generalDiagnosticOption, int warningLevel, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, Microsoft.CodeAnalysis.ReportDiagnostic>> specificDiagnosticOptions, bool concurrentBuild, bool deterministic, Microsoft.CodeAnalysis.XmlReferenceResolver xmlReferenceResolver, Microsoft.CodeAnalysis.SourceReferenceResolver sourceReferenceResolver, Microsoft.CodeAnalysis.MetadataReferenceResolver metadataReferenceResolver, Microsoft.CodeAnalysis.AssemblyIdentityComparer assemblyIdentityComparer, Microsoft.CodeAnalysis.StrongNameProvider strongNameProvider, bool publicSign) -> void
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CSharpCompilationOptions(Microsoft.CodeAnalysis.OutputKind outputKind, bool reportSuppressedDiagnostics, string moduleName, string mainTypeName, string scriptClassName, System.Collections.Generic.IEnumerable<string> usings, Microsoft.CodeAnalysis.OptimizationLevel optimizationLevel, bool checkOverflow, bool allowUnsafe, string cryptoKeyContainer, string cryptoKeyFile, System.Collections.Immutable.ImmutableArray<byte> cryptoPublicKey, bool? delaySign, Microsoft.CodeAnalysis.Platform platform, Microsoft.CodeAnalysis.ReportDiagnostic generalDiagnosticOption, int warningLevel, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, Microsoft.CodeAnalysis.ReportDiagnostic>> specificDiagnosticOptions, bool concurrentBuild, bool deterministic, Microsoft.CodeAnalysis.XmlReferenceResolver xmlReferenceResolver, Microsoft.CodeAnalysis.SourceReferenceResolver sourceReferenceResolver, Microsoft.CodeAnalysis.MetadataReferenceResolver metadataReferenceResolver, Microsoft.CodeAnalysis.AssemblyIdentityComparer assemblyIdentityComparer, Microsoft.CodeAnalysis.StrongNameProvider strongNameProvider, bool publicSign, Microsoft.CodeAnalysis.MetadataImportOptions metadataImportOptions) -> void
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CSharpCompilationOptions(Microsoft.CodeAnalysis.OutputKind outputKind, string moduleName, string mainTypeName, string scriptClassName, System.Collections.Generic.IEnumerable<string> usings, Microsoft.CodeAnalysis.OptimizationLevel optimizationLevel, bool checkOverflow, bool allowUnsafe, string cryptoKeyContainer, string cryptoKeyFile, System.Collections.Immutable.ImmutableArray<byte> cryptoPublicKey, bool? delaySign, Microsoft.CodeAnalysis.Platform platform, Microsoft.CodeAnalysis.ReportDiagnostic generalDiagnosticOption, int warningLevel, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, Microsoft.CodeAnalysis.ReportDiagnostic>> specificDiagnosticOptions, bool concurrentBuild, bool deterministic, Microsoft.CodeAnalysis.XmlReferenceResolver xmlReferenceResolver, Microsoft.CodeAnalysis.SourceReferenceResolver sourceReferenceResolver, Microsoft.CodeAnalysis.MetadataReferenceResolver metadataReferenceResolver, Microsoft.CodeAnalysis.AssemblyIdentityComparer assemblyIdentityComparer, Microsoft.CodeAnalysis.StrongNameProvider strongNameProvider) -> void
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CSharpCompilationOptions(Microsoft.CodeAnalysis.OutputKind outputKind, string moduleName, string mainTypeName, string scriptClassName, System.Collections.Generic.IEnumerable<string> usings, Microsoft.CodeAnalysis.OptimizationLevel optimizationLevel, bool checkOverflow, bool allowUnsafe, string cryptoKeyContainer, string cryptoKeyFile, System.Collections.Immutable.ImmutableArray<byte> cryptoPublicKey, bool? delaySign, Microsoft.CodeAnalysis.Platform platform, Microsoft.CodeAnalysis.ReportDiagnostic generalDiagnosticOption, int warningLevel, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, Microsoft.CodeAnalysis.ReportDiagnostic>> specificDiagnosticOptions, bool concurrentBuild, Microsoft.CodeAnalysis.XmlReferenceResolver xmlReferenceResolver, Microsoft.CodeAnalysis.SourceReferenceResolver sourceReferenceResolver, Microsoft.CodeAnalysis.MetadataReferenceResolver metadataReferenceResolver, Microsoft.CodeAnalysis.AssemblyIdentityComparer assemblyIdentityComparer, Microsoft.CodeAnalysis.StrongNameProvider strongNameProvider) -> void
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.Equals(Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions other) -> bool
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.Usings.get -> System.Collections.Immutable.ImmutableArray<string>
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithAllowUnsafe(bool enabled) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithAssemblyIdentityComparer(Microsoft.CodeAnalysis.AssemblyIdentityComparer comparer) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithConcurrentBuild(bool concurrentBuild) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithCryptoKeyContainer(string name) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithCryptoKeyFile(string path) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithCryptoPublicKey(System.Collections.Immutable.ImmutableArray<byte> value) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithDelaySign(bool? value) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithDeterministic(bool deterministic) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithGeneralDiagnosticOption(Microsoft.CodeAnalysis.ReportDiagnostic value) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithMainTypeName(string name) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithMetadataImportOptions(Microsoft.CodeAnalysis.MetadataImportOptions value) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithMetadataReferenceResolver(Microsoft.CodeAnalysis.MetadataReferenceResolver resolver) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithModuleName(string moduleName) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithNullableContextOptions(Microsoft.CodeAnalysis.NullableContextOptions options) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithOptimizationLevel(Microsoft.CodeAnalysis.OptimizationLevel value) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithOutputKind(Microsoft.CodeAnalysis.OutputKind kind) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithOverflowChecks(bool enabled) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithPlatform(Microsoft.CodeAnalysis.Platform platform) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithPublicSign(bool publicSign) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithReportSuppressedDiagnostics(bool reportSuppressedDiagnostics) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithScriptClassName(string name) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithSourceReferenceResolver(Microsoft.CodeAnalysis.SourceReferenceResolver resolver) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithSpecificDiagnosticOptions(System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, Microsoft.CodeAnalysis.ReportDiagnostic>> values) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithSpecificDiagnosticOptions(System.Collections.Immutable.ImmutableDictionary<string, Microsoft.CodeAnalysis.ReportDiagnostic> values) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithStrongNameProvider(Microsoft.CodeAnalysis.StrongNameProvider provider) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithSyntaxTreeOptionsProvider(Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider provider) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithUsings(params string[] usings) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithUsings(System.Collections.Generic.IEnumerable<string> usings) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithUsings(System.Collections.Immutable.ImmutableArray<string> usings) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithWarningLevel(int warningLevel) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithXmlReferenceResolver(Microsoft.CodeAnalysis.XmlReferenceResolver resolver) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CSharpCompilationOptions(Microsoft.CodeAnalysis.OutputKind outputKind, bool reportSuppressedDiagnostics = false, string? moduleName = null, string? mainTypeName = null, string? scriptClassName = null, System.Collections.Generic.IEnumerable<string!>? usings = null, Microsoft.CodeAnalysis.OptimizationLevel optimizationLevel = Microsoft.CodeAnalysis.OptimizationLevel.Debug, bool checkOverflow = false, bool allowUnsafe = false, string? cryptoKeyContainer = null, string? cryptoKeyFile = null, System.Collections.Immutable.ImmutableArray<byte> cryptoPublicKey = default(System.Collections.Immutable.ImmutableArray<byte>), bool? delaySign = null, Microsoft.CodeAnalysis.Platform platform = Microsoft.CodeAnalysis.Platform.AnyCpu, Microsoft.CodeAnalysis.ReportDiagnostic generalDiagnosticOption = Microsoft.CodeAnalysis.ReportDiagnostic.Default, int warningLevel = 4, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string!, Microsoft.CodeAnalysis.ReportDiagnostic>>? specificDiagnosticOptions = null, bool concurrentBuild = true, bool deterministic = false, Microsoft.CodeAnalysis.XmlReferenceResolver? xmlReferenceResolver = null, Microsoft.CodeAnalysis.SourceReferenceResolver? sourceReferenceResolver = null, Microsoft.CodeAnalysis.MetadataReferenceResolver? metadataReferenceResolver = null, Microsoft.CodeAnalysis.AssemblyIdentityComparer? assemblyIdentityComparer = null, Microsoft.CodeAnalysis.StrongNameProvider? strongNameProvider = null, bool publicSign = false, Microsoft.CodeAnalysis.MetadataImportOptions metadataImportOptions = Microsoft.CodeAnalysis.MetadataImportOptions.Public, Microsoft.CodeAnalysis.NullableContextOptions nullableContextOptions = Microsoft.CodeAnalysis.NullableContextOptions.Disable) -> void
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CSharpCompilationOptions(Microsoft.CodeAnalysis.OutputKind outputKind, bool reportSuppressedDiagnostics, string? moduleName, string? mainTypeName, string? scriptClassName, System.Collections.Generic.IEnumerable<string!>? usings, Microsoft.CodeAnalysis.OptimizationLevel optimizationLevel, bool checkOverflow, bool allowUnsafe, string? cryptoKeyContainer, string? cryptoKeyFile, System.Collections.Immutable.ImmutableArray<byte> cryptoPublicKey, bool? delaySign, Microsoft.CodeAnalysis.Platform platform, Microsoft.CodeAnalysis.ReportDiagnostic generalDiagnosticOption, int warningLevel, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string!, Microsoft.CodeAnalysis.ReportDiagnostic>>? specificDiagnosticOptions, bool concurrentBuild, bool deterministic, Microsoft.CodeAnalysis.XmlReferenceResolver? xmlReferenceResolver, Microsoft.CodeAnalysis.SourceReferenceResolver? sourceReferenceResolver, Microsoft.CodeAnalysis.MetadataReferenceResolver? metadataReferenceResolver, Microsoft.CodeAnalysis.AssemblyIdentityComparer? assemblyIdentityComparer, Microsoft.CodeAnalysis.StrongNameProvider? strongNameProvider) -> void
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CSharpCompilationOptions(Microsoft.CodeAnalysis.OutputKind outputKind, bool reportSuppressedDiagnostics, string? moduleName, string? mainTypeName, string? scriptClassName, System.Collections.Generic.IEnumerable<string!>? usings, Microsoft.CodeAnalysis.OptimizationLevel optimizationLevel, bool checkOverflow, bool allowUnsafe, string? cryptoKeyContainer, string? cryptoKeyFile, System.Collections.Immutable.ImmutableArray<byte> cryptoPublicKey, bool? delaySign, Microsoft.CodeAnalysis.Platform platform, Microsoft.CodeAnalysis.ReportDiagnostic generalDiagnosticOption, int warningLevel, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string!, Microsoft.CodeAnalysis.ReportDiagnostic>>? specificDiagnosticOptions, bool concurrentBuild, bool deterministic, Microsoft.CodeAnalysis.XmlReferenceResolver? xmlReferenceResolver, Microsoft.CodeAnalysis.SourceReferenceResolver? sourceReferenceResolver, Microsoft.CodeAnalysis.MetadataReferenceResolver? metadataReferenceResolver, Microsoft.CodeAnalysis.AssemblyIdentityComparer? assemblyIdentityComparer, Microsoft.CodeAnalysis.StrongNameProvider? strongNameProvider, bool publicSign) -> void
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CSharpCompilationOptions(Microsoft.CodeAnalysis.OutputKind outputKind, bool reportSuppressedDiagnostics, string? moduleName, string? mainTypeName, string? scriptClassName, System.Collections.Generic.IEnumerable<string!>? usings, Microsoft.CodeAnalysis.OptimizationLevel optimizationLevel, bool checkOverflow, bool allowUnsafe, string? cryptoKeyContainer, string? cryptoKeyFile, System.Collections.Immutable.ImmutableArray<byte> cryptoPublicKey, bool? delaySign, Microsoft.CodeAnalysis.Platform platform, Microsoft.CodeAnalysis.ReportDiagnostic generalDiagnosticOption, int warningLevel, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string!, Microsoft.CodeAnalysis.ReportDiagnostic>>? specificDiagnosticOptions, bool concurrentBuild, bool deterministic, Microsoft.CodeAnalysis.XmlReferenceResolver? xmlReferenceResolver, Microsoft.CodeAnalysis.SourceReferenceResolver? sourceReferenceResolver, Microsoft.CodeAnalysis.MetadataReferenceResolver? metadataReferenceResolver, Microsoft.CodeAnalysis.AssemblyIdentityComparer? assemblyIdentityComparer, Microsoft.CodeAnalysis.StrongNameProvider? strongNameProvider, bool publicSign, Microsoft.CodeAnalysis.MetadataImportOptions metadataImportOptions) -> void
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CSharpCompilationOptions(Microsoft.CodeAnalysis.OutputKind outputKind, string? moduleName, string? mainTypeName, string? scriptClassName, System.Collections.Generic.IEnumerable<string!>? usings, Microsoft.CodeAnalysis.OptimizationLevel optimizationLevel, bool checkOverflow, bool allowUnsafe, string? cryptoKeyContainer, string? cryptoKeyFile, System.Collections.Immutable.ImmutableArray<byte> cryptoPublicKey, bool? delaySign, Microsoft.CodeAnalysis.Platform platform, Microsoft.CodeAnalysis.ReportDiagnostic generalDiagnosticOption, int warningLevel, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string!, Microsoft.CodeAnalysis.ReportDiagnostic>>? specificDiagnosticOptions, bool concurrentBuild, bool deterministic, Microsoft.CodeAnalysis.XmlReferenceResolver? xmlReferenceResolver, Microsoft.CodeAnalysis.SourceReferenceResolver? sourceReferenceResolver, Microsoft.CodeAnalysis.MetadataReferenceResolver? metadataReferenceResolver, Microsoft.CodeAnalysis.AssemblyIdentityComparer? assemblyIdentityComparer, Microsoft.CodeAnalysis.StrongNameProvider? strongNameProvider) -> void
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.CSharpCompilationOptions(Microsoft.CodeAnalysis.OutputKind outputKind, string? moduleName, string? mainTypeName, string? scriptClassName, System.Collections.Generic.IEnumerable<string!>? usings, Microsoft.CodeAnalysis.OptimizationLevel optimizationLevel, bool checkOverflow, bool allowUnsafe, string? cryptoKeyContainer, string? cryptoKeyFile, System.Collections.Immutable.ImmutableArray<byte> cryptoPublicKey, bool? delaySign, Microsoft.CodeAnalysis.Platform platform, Microsoft.CodeAnalysis.ReportDiagnostic generalDiagnosticOption, int warningLevel, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string!, Microsoft.CodeAnalysis.ReportDiagnostic>>? specificDiagnosticOptions, bool concurrentBuild, Microsoft.CodeAnalysis.XmlReferenceResolver? xmlReferenceResolver, Microsoft.CodeAnalysis.SourceReferenceResolver? sourceReferenceResolver, Microsoft.CodeAnalysis.MetadataReferenceResolver? metadataReferenceResolver, Microsoft.CodeAnalysis.AssemblyIdentityComparer? assemblyIdentityComparer, Microsoft.CodeAnalysis.StrongNameProvider? strongNameProvider) -> void
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.Equals(Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions? other) -> bool
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.Usings.get -> System.Collections.Immutable.ImmutableArray<string!>
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithAllowUnsafe(bool enabled) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithAssemblyIdentityComparer(Microsoft.CodeAnalysis.AssemblyIdentityComparer? comparer) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithConcurrentBuild(bool concurrentBuild) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithCryptoKeyContainer(string? name) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithCryptoKeyFile(string? path) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithCryptoPublicKey(System.Collections.Immutable.ImmutableArray<byte> value) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithDelaySign(bool? value) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithDeterministic(bool deterministic) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithGeneralDiagnosticOption(Microsoft.CodeAnalysis.ReportDiagnostic value) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithMainTypeName(string? name) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithMetadataImportOptions(Microsoft.CodeAnalysis.MetadataImportOptions value) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithMetadataReferenceResolver(Microsoft.CodeAnalysis.MetadataReferenceResolver? resolver) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithModuleName(string? moduleName) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithNullableContextOptions(Microsoft.CodeAnalysis.NullableContextOptions options) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithOptimizationLevel(Microsoft.CodeAnalysis.OptimizationLevel value) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithOutputKind(Microsoft.CodeAnalysis.OutputKind kind) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithOverflowChecks(bool enabled) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithPlatform(Microsoft.CodeAnalysis.Platform platform) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithPublicSign(bool publicSign) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithReportSuppressedDiagnostics(bool reportSuppressedDiagnostics) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithScriptClassName(string? name) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithSourceReferenceResolver(Microsoft.CodeAnalysis.SourceReferenceResolver? resolver) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithSpecificDiagnosticOptions(System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string!, Microsoft.CodeAnalysis.ReportDiagnostic>>? values) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithSpecificDiagnosticOptions(System.Collections.Immutable.ImmutableDictionary<string!, Microsoft.CodeAnalysis.ReportDiagnostic>? values) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithStrongNameProvider(Microsoft.CodeAnalysis.StrongNameProvider? provider) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithSyntaxTreeOptionsProvider(Microsoft.CodeAnalysis.SyntaxTreeOptionsProvider? provider) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithUsings(params string![]? usings) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithUsings(System.Collections.Generic.IEnumerable<string!>? usings) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithUsings(System.Collections.Immutable.ImmutableArray<string!> usings) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithWarningLevel(int warningLevel) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.WithXmlReferenceResolver(Microsoft.CodeAnalysis.XmlReferenceResolver? resolver) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions!
 Microsoft.CodeAnalysis.CSharp.CSharpDiagnosticFormatter
 Microsoft.CodeAnalysis.CSharp.CSharpExtensions
 Microsoft.CodeAnalysis.CSharp.CSharpFileSystemExtensions
 Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver
 Microsoft.CodeAnalysis.CSharp.CSharpParseOptions
-Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.CSharpParseOptions(Microsoft.CodeAnalysis.CSharp.LanguageVersion languageVersion = Microsoft.CodeAnalysis.CSharp.LanguageVersion.Default, Microsoft.CodeAnalysis.DocumentationMode documentationMode = Microsoft.CodeAnalysis.DocumentationMode.Parse, Microsoft.CodeAnalysis.SourceCodeKind kind = Microsoft.CodeAnalysis.SourceCodeKind.Regular, System.Collections.Generic.IEnumerable<string> preprocessorSymbols = null) -> void
-Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.Equals(Microsoft.CodeAnalysis.CSharp.CSharpParseOptions other) -> bool
+Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.CSharpParseOptions(Microsoft.CodeAnalysis.CSharp.LanguageVersion languageVersion = Microsoft.CodeAnalysis.CSharp.LanguageVersion.Default, Microsoft.CodeAnalysis.DocumentationMode documentationMode = Microsoft.CodeAnalysis.DocumentationMode.Parse, Microsoft.CodeAnalysis.SourceCodeKind kind = Microsoft.CodeAnalysis.SourceCodeKind.Regular, System.Collections.Generic.IEnumerable<string!>? preprocessorSymbols = null) -> void
+Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.Equals(Microsoft.CodeAnalysis.CSharp.CSharpParseOptions? other) -> bool
 Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.LanguageVersion.get -> Microsoft.CodeAnalysis.CSharp.LanguageVersion
 Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.SpecifiedLanguageVersion.get -> Microsoft.CodeAnalysis.CSharp.LanguageVersion
-Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithDocumentationMode(Microsoft.CodeAnalysis.DocumentationMode documentationMode) -> Microsoft.CodeAnalysis.CSharp.CSharpParseOptions
-Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithFeatures(System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, string>> features) -> Microsoft.CodeAnalysis.CSharp.CSharpParseOptions
-Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithKind(Microsoft.CodeAnalysis.SourceCodeKind kind) -> Microsoft.CodeAnalysis.CSharp.CSharpParseOptions
-Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithLanguageVersion(Microsoft.CodeAnalysis.CSharp.LanguageVersion version) -> Microsoft.CodeAnalysis.CSharp.CSharpParseOptions
-Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithPreprocessorSymbols(params string[] preprocessorSymbols) -> Microsoft.CodeAnalysis.CSharp.CSharpParseOptions
-Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithPreprocessorSymbols(System.Collections.Generic.IEnumerable<string> preprocessorSymbols) -> Microsoft.CodeAnalysis.CSharp.CSharpParseOptions
-Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithPreprocessorSymbols(System.Collections.Immutable.ImmutableArray<string> symbols) -> Microsoft.CodeAnalysis.CSharp.CSharpParseOptions
+Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithDocumentationMode(Microsoft.CodeAnalysis.DocumentationMode documentationMode) -> Microsoft.CodeAnalysis.CSharp.CSharpParseOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithFeatures(System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string!, string!>>? features) -> Microsoft.CodeAnalysis.CSharp.CSharpParseOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithKind(Microsoft.CodeAnalysis.SourceCodeKind kind) -> Microsoft.CodeAnalysis.CSharp.CSharpParseOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithLanguageVersion(Microsoft.CodeAnalysis.CSharp.LanguageVersion version) -> Microsoft.CodeAnalysis.CSharp.CSharpParseOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithPreprocessorSymbols(params string![]? preprocessorSymbols) -> Microsoft.CodeAnalysis.CSharp.CSharpParseOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithPreprocessorSymbols(System.Collections.Generic.IEnumerable<string!>? preprocessorSymbols) -> Microsoft.CodeAnalysis.CSharp.CSharpParseOptions!
+Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.WithPreprocessorSymbols(System.Collections.Immutable.ImmutableArray<string!> symbols) -> Microsoft.CodeAnalysis.CSharp.CSharpParseOptions!
 Microsoft.CodeAnalysis.CSharp.CSharpScriptCompilationInfo
-Microsoft.CodeAnalysis.CSharp.CSharpScriptCompilationInfo.PreviousScriptCompilation.get -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation
-Microsoft.CodeAnalysis.CSharp.CSharpScriptCompilationInfo.WithPreviousScriptCompilation(Microsoft.CodeAnalysis.CSharp.CSharpCompilation compilation) -> Microsoft.CodeAnalysis.CSharp.CSharpScriptCompilationInfo
+Microsoft.CodeAnalysis.CSharp.CSharpScriptCompilationInfo.PreviousScriptCompilation.get -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation?
+Microsoft.CodeAnalysis.CSharp.CSharpScriptCompilationInfo.WithPreviousScriptCompilation(Microsoft.CodeAnalysis.CSharp.CSharpCompilation? compilation) -> Microsoft.CodeAnalysis.CSharp.CSharpScriptCompilationInfo!
 Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode
 Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.FindToken(int position, bool findInsideTrivia = false) -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.FindTrivia(int position, bool findInsideTrivia = false) -> Microsoft.CodeAnalysis.SyntaxTrivia
-Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.FindTrivia(int position, System.Func<Microsoft.CodeAnalysis.SyntaxTrivia, bool> stepInto) -> Microsoft.CodeAnalysis.SyntaxTrivia
-Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetDiagnostics() -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.Diagnostic>
-Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetFirstDirective(System.Func<Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax, bool> predicate = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.FindTrivia(int position, System.Func<Microsoft.CodeAnalysis.SyntaxTrivia, bool>! stepInto) -> Microsoft.CodeAnalysis.SyntaxTrivia
+Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetDiagnostics() -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.Diagnostic!>!
+Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetFirstDirective(System.Func<Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax!, bool>? predicate = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax?
 Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetFirstToken(bool includeZeroWidth = false, bool includeSkipped = false, bool includeDirectives = false, bool includeDocumentationComments = false) -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetLastDirective(System.Func<Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax, bool> predicate = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetLastDirective(System.Func<Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax!, bool>? predicate = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax?
 Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetLastToken(bool includeZeroWidth = false, bool includeSkipped = false, bool includeDirectives = false, bool includeDocumentationComments = false) -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetLeadingTrivia() -> Microsoft.CodeAnalysis.SyntaxTriviaList
-Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetLocation() -> Microsoft.CodeAnalysis.Location
+Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetLocation() -> Microsoft.CodeAnalysis.Location!
 Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.GetTrailingTrivia() -> Microsoft.CodeAnalysis.SyntaxTriviaList
 Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.Kind() -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
 Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter
 Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.CSharpSyntaxRewriter(bool visitIntoStructuredTrivia = false) -> void
 Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree
-Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.CloneNodeAsRoot<T>(T node) -> T
+Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.CloneNodeAsRoot<T>(T! node) -> T!
 Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.CSharpSyntaxTree() -> void
-Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetCompilationUnitRoot(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax
+Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetCompilationUnitRoot(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax!
 Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor
 Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.CSharpSyntaxVisitor() -> void
 Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>
@@ -219,19 +220,19 @@ Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.Depth.get -> Microsoft.CodeAnal
 Microsoft.CodeAnalysis.CSharp.DeconstructionInfo
 Microsoft.CodeAnalysis.CSharp.DeconstructionInfo.Conversion.get -> Microsoft.CodeAnalysis.CSharp.Conversion?
 Microsoft.CodeAnalysis.CSharp.DeconstructionInfo.DeconstructionInfo() -> void
-Microsoft.CodeAnalysis.CSharp.DeconstructionInfo.Method.get -> Microsoft.CodeAnalysis.IMethodSymbol
+Microsoft.CodeAnalysis.CSharp.DeconstructionInfo.Method.get -> Microsoft.CodeAnalysis.IMethodSymbol?
 Microsoft.CodeAnalysis.CSharp.DeconstructionInfo.Nested.get -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.CSharp.DeconstructionInfo>
 Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo
 Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.CurrentConversion.get -> Microsoft.CodeAnalysis.CSharp.Conversion
-Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.CurrentProperty.get -> Microsoft.CodeAnalysis.IPropertySymbol
-Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.DisposeMethod.get -> Microsoft.CodeAnalysis.IMethodSymbol
+Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.CurrentProperty.get -> Microsoft.CodeAnalysis.IPropertySymbol?
+Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.DisposeMethod.get -> Microsoft.CodeAnalysis.IMethodSymbol?
 Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.ElementConversion.get -> Microsoft.CodeAnalysis.CSharp.Conversion
-Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.ElementType.get -> Microsoft.CodeAnalysis.ITypeSymbol
+Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.ElementType.get -> Microsoft.CodeAnalysis.ITypeSymbol?
 Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.Equals(Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo other) -> bool
 Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.ForEachStatementInfo() -> void
-Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.GetEnumeratorMethod.get -> Microsoft.CodeAnalysis.IMethodSymbol
+Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.GetEnumeratorMethod.get -> Microsoft.CodeAnalysis.IMethodSymbol?
 Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.IsAsynchronous.get -> bool
-Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.MoveNextMethod.get -> Microsoft.CodeAnalysis.IMethodSymbol
+Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.MoveNextMethod.get -> Microsoft.CodeAnalysis.IMethodSymbol?
 Microsoft.CodeAnalysis.CSharp.LanguageVersion
 Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp1 = 1 -> Microsoft.CodeAnalysis.CSharp.LanguageVersion
 Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp2 = 2 -> Microsoft.CodeAnalysis.CSharp.LanguageVersion
@@ -257,1460 +258,1460 @@ Microsoft.CodeAnalysis.CSharp.QueryClauseInfo.OperationInfo.get -> Microsoft.Cod
 Microsoft.CodeAnalysis.CSharp.QueryClauseInfo.QueryClauseInfo() -> void
 Microsoft.CodeAnalysis.CSharp.SymbolDisplay
 Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.AddBodyAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.AddBodyStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Body.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.AddBodyAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.AddBodyStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Body.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Keyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
 Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.Accessors.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.AddAccessors(params Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.Accessors.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.AddAccessors(params Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.CloseBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.OpenBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax> accessors, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.WithAccessors(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax> accessors) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!> accessors, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.WithAccessors(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!> accessors) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.Alias.get -> Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.Alias.get -> Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.ColonColonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax alias, Microsoft.CodeAnalysis.SyntaxToken colonColonToken, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.WithAlias(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax alias) -> Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.WithColonColonToken(Microsoft.CodeAnalysis.SyntaxToken colonColonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! alias, Microsoft.CodeAnalysis.SyntaxToken colonColonToken, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.WithAlias(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! alias) -> Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.WithColonColonToken(Microsoft.CodeAnalysis.SyntaxToken colonColonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.AddBlockAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.AddBlockStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.Body.get -> Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode body) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.AddBlockAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.AddBlockStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.Body.get -> Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode!
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.AddBlockAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.AddBlockStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.AddBlockAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.AddBlockStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.DelegateKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode body) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode body) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithDelegateKeyword(Microsoft.CodeAnalysis.SyntaxToken delegateKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax?
+~Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode body) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
+~Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax? parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax!
+~Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax!
+~Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode body) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithDelegateKeyword(Microsoft.CodeAnalysis.SyntaxToken delegateKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax? parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.AddInitializers(params Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.AddInitializers(params Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.CloseBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.Initializers.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax>
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.Initializers.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax!>
 Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.NewKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.OpenBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax> initializers, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.WithInitializers(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax> initializers) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken newKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax!> initializers, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.WithInitializers(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax!> initializers) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken newKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.NameEquals.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax nameEquals, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.WithNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax nameEquals) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.NameEquals.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax? nameEquals, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.WithNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax? nameEquals) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.AddArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.AddArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax> arguments, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax> arguments) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!> arguments, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!> arguments) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.NameColon.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.NameColon.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.RefKindKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.RefOrOutKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax nameColon, Microsoft.CodeAnalysis.SyntaxToken refKindKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.WithNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax nameColon) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.WithRefKindKeyword(Microsoft.CodeAnalysis.SyntaxToken refKindKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.WithRefOrOutKeyword(Microsoft.CodeAnalysis.SyntaxToken refOrOutKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax? nameColon, Microsoft.CodeAnalysis.SyntaxToken refKindKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.WithNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax? nameColon) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.WithRefKindKeyword(Microsoft.CodeAnalysis.SyntaxToken refKindKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.WithRefOrOutKeyword(Microsoft.CodeAnalysis.SyntaxToken refOrOutKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.AddTypeRankSpecifiers(params Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.AddTypeRankSpecifiers(params Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.NewKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken newKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken newKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.AddSizes(params Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.AddSizes(params Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.CloseBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.OpenBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.Rank.get -> int
-Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.Sizes.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> sizes, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken openBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.WithSizes(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> sizes) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.Sizes.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> sizes, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken openBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.WithSizes(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> sizes) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.AddRankSpecifiers(params Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.ElementType.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.RankSpecifiers.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax elementType, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax> rankSpecifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.WithElementType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax elementType) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.WithRankSpecifiers(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax> rankSpecifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.AddRankSpecifiers(params Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.ElementType.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.RankSpecifiers.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! elementType, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax!> rankSpecifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.WithElementType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! elementType) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.WithRankSpecifiers(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax!> rankSpecifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.ArrowToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.WithArrowToken(Microsoft.CodeAnalysis.SyntaxToken arrowToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.WithArrowToken(Microsoft.CodeAnalysis.SyntaxToken arrowToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.Left.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.Left.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.OperatorToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.Right.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax left, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax right) -> Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.WithLeft(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax left) -> Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.WithRight(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax right) -> Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.Right.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! left, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! right) -> Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.WithLeft(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! left) -> Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.WithRight(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! right) -> Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.AddArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.Arguments.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax>
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.AddArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.Arguments.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax!>
 Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax> arguments, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax> arguments) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax!> arguments, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax!> arguments) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.NameColon.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.NameEquals.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax nameEquals, Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax nameColon, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.WithNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax nameColon) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.WithNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax nameEquals) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.NameColon.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.NameEquals.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax? nameEquals, Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax? nameColon, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.WithNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax? nameColon) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.WithNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax? nameEquals) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.AddAttributes(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.Attributes.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax>
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.AddAttributes(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.Attributes.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax!>
 Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.CloseBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.OpenBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.Target.get -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax target, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax> attributes, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.WithAttributes(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax> attributes) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken openBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.WithTarget(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax target) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.Target.get -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax? target, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax!> attributes, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.WithAttributes(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax!> attributes) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken openBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.WithTarget(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax? target) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name, Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax? argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax? argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.ColonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.AwaitKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BaseArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseArgumentListSyntax.AddArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax> arguments) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseArgumentListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseArgumentListSyntax.AddArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseArgumentListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!> arguments) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseArgumentListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BaseCrefParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseCrefParameterListSyntax.AddParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseCrefParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseCrefParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax> parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseCrefParameterListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseCrefParameterListSyntax.AddParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseCrefParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseCrefParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax!> parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseCrefParameterListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.Token.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken token) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.WithToken(Microsoft.CodeAnalysis.SyntaxToken token) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken token) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.WithToken(Microsoft.CodeAnalysis.SyntaxToken token) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.AddDeclarationVariables(params Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.AddDeclarationVariables(params Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.AddTypes(params Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.AddTypes(params Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.ColonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.Types.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax> types) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.WithTypes(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax> types) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.Types.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax!> types) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.WithTypes(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax!> types) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddBodyAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddBodyStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddBodyAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddBodyStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken newKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax? argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken newKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterListSyntax.AddParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax> parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterListSyntax.AddParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!> parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.AddAccessorListAccessors(params Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.AddAccessorListAccessors(params Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax? accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.AddBaseListTypes(params Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.AddBaseListTypes(params Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.Left.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.Left.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.OperatorToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.Right.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax left, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax right) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.WithLeft(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax left) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.WithRight(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax right) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.Right.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! left, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! right) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.WithLeft(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! left) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.WithRight(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! right) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.Left.get -> Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.Left.get -> Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.OperatorToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.Right.get -> Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax left, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax right) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.WithLeft(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax left) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.WithRight(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax right) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.Right.get -> Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! left, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! right) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.WithLeft(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! left) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.WithRight(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! right) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.AddStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.AddStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.CloseBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.OpenBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.Statements.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax> statements, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax> statements, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.WithStatements(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax> statements) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.Statements.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!> statements, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!> statements, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.WithStatements(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!> statements) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.AddArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.AddArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.CloseBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.OpenBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax> arguments, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax> arguments) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken openBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!> arguments, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!> arguments) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken openBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.AddParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.AddParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.CloseBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.OpenBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax> parameters, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken openBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax> parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!> parameters, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken openBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!> parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BranchingDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BranchingDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BranchingDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BranchingDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BranchingDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BranchingDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BranchingDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BranchingDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BranchingDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.BreakKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken breakKeyword, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken breakKeyword, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.WithBreakKeyword(Microsoft.CodeAnalysis.SyntaxToken breakKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken breakKeyword, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken breakKeyword, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.WithBreakKeyword(Microsoft.CodeAnalysis.SyntaxToken breakKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.Pattern.get -> Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern, Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax whenClause, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.WhenClause.get -> Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.WithWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax whenClause) -> Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.Pattern.get -> Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern, Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax? whenClause, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.WhenClause.get -> Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.WithWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax? whenClause) -> Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax value, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.Value.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.WithValue(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax value) -> Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! value, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.Value.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.WithValue(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! value) -> Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.AddBlockAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.AddBlockStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.Block.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.AddBlockAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.AddBlockStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.Block.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.CatchKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.Declaration.get -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.Filter.get -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken catchKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax declaration, Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax filter, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.WithCatchKeyword(Microsoft.CodeAnalysis.SyntaxToken catchKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.WithFilter(Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax filter) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.Declaration.get -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.Filter.get -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken catchKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax? declaration, Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax? filter, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.WithCatchKeyword(Microsoft.CodeAnalysis.SyntaxToken catchKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax? declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.WithFilter(Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax? filter) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.FilterExpression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.FilterExpression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken whenKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax filterExpression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken whenKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! filterExpression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.WhenKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.WithFilterExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax filterExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.WithWhenKeyword(Microsoft.CodeAnalysis.SyntaxToken whenKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.WithFilterExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! filterExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.WithWhenKeyword(Microsoft.CodeAnalysis.SyntaxToken whenKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.Keyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.AddBlockAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.AddBlockStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.Block.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.AddBlockAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.AddBlockStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.Block.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.Keyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddBaseListTypes(params Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddConstraintClauses(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddMembers(params Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddTypeParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddBaseListTypes(params Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddConstraintClauses(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddMembers(params Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AddTypeParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.ClassOrStructKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.QuestionToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken classOrStructKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken classOrStructKeyword, Microsoft.CodeAnalysis.SyntaxToken questionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.WithClassOrStructKeyword(Microsoft.CodeAnalysis.SyntaxToken classOrStructKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.WithQuestionToken(Microsoft.CodeAnalysis.SyntaxToken questionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken classOrStructKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken classOrStructKeyword, Microsoft.CodeAnalysis.SyntaxToken questionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.WithClassOrStructKeyword(Microsoft.CodeAnalysis.SyntaxToken classOrStructKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.WithQuestionToken(Microsoft.CodeAnalysis.SyntaxToken questionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithForEachKeyword(Microsoft.CodeAnalysis.SyntaxToken forEachKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken inKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithForEachKeyword(Microsoft.CodeAnalysis.SyntaxToken forEachKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken inKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.AddExterns(params Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.AddMembers(params Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.AddUsings(params Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
+Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.AddExterns(params Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.AddMembers(params Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.AddUsings(params Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
 Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.EndOfFileToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.Externs.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.GetLoadDirectives() -> System.Collections.Generic.IList<Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.GetReferenceDirectives() -> System.Collections.Generic.IList<Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.Members.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, Microsoft.CodeAnalysis.SyntaxToken endOfFileToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.Usings.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithEndOfFileToken(Microsoft.CodeAnalysis.SyntaxToken endOfFileToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithExterns(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithUsings(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.Externs.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.GetLoadDirectives() -> System.Collections.Generic.IList<Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax!>!
+Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.GetReferenceDirectives() -> System.Collections.Generic.IList<Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax!>!
+Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.Members.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members, Microsoft.CodeAnalysis.SyntaxToken endOfFileToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.Usings.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithEndOfFileToken(Microsoft.CodeAnalysis.SyntaxToken endOfFileToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithExterns(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!> externs) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.WithUsings(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!> usings) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.OperatorToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax whenNotNull) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.WhenNotNull.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.WithWhenNotNull(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax whenNotNull) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! whenNotNull) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.WhenNotNull.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.WithWhenNotNull(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! whenNotNull) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalDirectiveTriviaSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalDirectiveTriviaSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.ColonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.Condition.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.Condition.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.QuestionToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SyntaxToken questionToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax whenTrue, Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax whenFalse) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WhenFalse.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WhenTrue.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithQuestionToken(Microsoft.CodeAnalysis.SyntaxToken questionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithWhenFalse(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax whenFalse) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithWhenTrue(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax whenTrue) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.SyntaxToken questionToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! whenTrue, Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! whenFalse) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WhenFalse.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WhenTrue.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithQuestionToken(Microsoft.CodeAnalysis.SyntaxToken questionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithWhenFalse(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! whenFalse) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.WithWhenTrue(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! whenTrue) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.NewKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken newKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken newKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddBodyAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddBodyStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddBodyAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddBodyStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax initializer, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax initializer, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax? initializer, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax! initializer, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax? initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.ColonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.ThisOrBaseKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.SyntaxToken thisOrBaseKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.WithThisOrBaseKeyword(Microsoft.CodeAnalysis.SyntaxToken thisOrBaseKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.SyntaxToken thisOrBaseKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax! argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax! argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.WithThisOrBaseKeyword(Microsoft.CodeAnalysis.SyntaxToken thisOrBaseKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.ContinueKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken continueKeyword, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken continueKeyword, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.WithContinueKeyword(Microsoft.CodeAnalysis.SyntaxToken continueKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken continueKeyword, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken continueKeyword, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.WithContinueKeyword(Microsoft.CodeAnalysis.SyntaxToken continueKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddBodyAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddBodyStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddBodyAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddBodyStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.ImplicitOrExplicitKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.OperatorKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithImplicitOrExplicitKeyword(Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithOperatorKeyword(Microsoft.CodeAnalysis.SyntaxToken operatorKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithImplicitOrExplicitKeyword(Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithOperatorKeyword(Microsoft.CodeAnalysis.SyntaxToken operatorKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.AddParametersParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.AddParametersParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.ImplicitOrExplicitKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.OperatorKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.Parameters.get -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.WithImplicitOrExplicitKeyword(Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.WithOperatorKeyword(Microsoft.CodeAnalysis.SyntaxToken operatorKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.WithParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.Parameters.get -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax? parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.WithImplicitOrExplicitKeyword(Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.WithOperatorKeyword(Microsoft.CodeAnalysis.SyntaxToken operatorKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.WithParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax? parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.AddParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.AddParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.CloseBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.OpenBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax> parameters, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken openBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax> parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax!> parameters, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken openBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax!> parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.AddParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.AddParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax> parameters, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax> parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax!> parameters, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax!> parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.RefKindKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.RefOrOutKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken refKindKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.WithRefKindKeyword(Microsoft.CodeAnalysis.SyntaxToken refKindKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.WithRefOrOutKeyword(Microsoft.CodeAnalysis.SyntaxToken refOrOutKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken refKindKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.WithRefKindKeyword(Microsoft.CodeAnalysis.SyntaxToken refKindKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.WithRefOrOutKeyword(Microsoft.CodeAnalysis.SyntaxToken refOrOutKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.Designation.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.Designation.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax! designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax! designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.Designation.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.Designation.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax! designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax! designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.DefaultKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken defaultKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.WithDefaultKeyword(Microsoft.CodeAnalysis.SyntaxToken defaultKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken defaultKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.WithDefaultKeyword(Microsoft.CodeAnalysis.SyntaxToken defaultKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.Keyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.DefineKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.Name.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken defineKeyword, Microsoft.CodeAnalysis.SyntaxToken name, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithDefineKeyword(Microsoft.CodeAnalysis.SyntaxToken defineKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithName(Microsoft.CodeAnalysis.SyntaxToken name) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken defineKeyword, Microsoft.CodeAnalysis.SyntaxToken name, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithDefineKeyword(Microsoft.CodeAnalysis.SyntaxToken defineKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.WithName(Microsoft.CodeAnalysis.SyntaxToken name) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddConstraintClauses(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddTypeParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddConstraintClauses(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AddTypeParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.Arity.get -> int
-Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.ConstraintClauses.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>
+Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.ConstraintClauses.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!>
 Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.DelegateKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.ReturnType.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.ReturnType.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.TypeParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithDelegateKeyword(Microsoft.CodeAnalysis.SyntaxToken delegateKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.TypeParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithDelegateKeyword(Microsoft.CodeAnalysis.SyntaxToken delegateKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddBodyAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddBodyStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddBodyAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddBodyStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.TildeToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken tildeToken, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken tildeToken, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithTildeToken(Microsoft.CodeAnalysis.SyntaxToken tildeToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken tildeToken, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken tildeToken, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.WithTildeToken(Microsoft.CodeAnalysis.SyntaxToken tildeToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.DirectiveNameToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.GetNextDirective(System.Func<Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax, bool> predicate = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.GetPreviousDirective(System.Func<Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax, bool> predicate = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.GetRelatedDirectives() -> System.Collections.Generic.List<Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.GetNextDirective(System.Func<Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax!, bool>? predicate = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.GetPreviousDirective(System.Func<Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax!, bool>? predicate = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.GetRelatedDirectives() -> System.Collections.Generic.List<Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax!>!
+Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.UnderscoreToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken underscoreToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.WithUnderscoreToken(Microsoft.CodeAnalysis.SyntaxToken underscoreToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken underscoreToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.WithUnderscoreToken(Microsoft.CodeAnalysis.SyntaxToken underscoreToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.UnderscoreToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken underscoreToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.WithUnderscoreToken(Microsoft.CodeAnalysis.SyntaxToken underscoreToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken underscoreToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.WithUnderscoreToken(Microsoft.CodeAnalysis.SyntaxToken underscoreToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.AddContent(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.Content.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax>
+Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.AddContent(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.Content.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!>
 Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.EndOfComment.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content, Microsoft.CodeAnalysis.SyntaxToken endOfComment) -> Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.WithContent(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.WithEndOfComment(Microsoft.CodeAnalysis.SyntaxToken endOfComment) -> Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!> content, Microsoft.CodeAnalysis.SyntaxToken endOfComment) -> Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.WithContent(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.WithEndOfComment(Microsoft.CodeAnalysis.SyntaxToken endOfComment) -> Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Condition.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Condition.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.DoKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken doKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement, Microsoft.CodeAnalysis.SyntaxToken whileKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken doKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement, Microsoft.CodeAnalysis.SyntaxToken whileKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken doKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement, Microsoft.CodeAnalysis.SyntaxToken whileKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken doKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement, Microsoft.CodeAnalysis.SyntaxToken whileKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WhileKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithDoKeyword(Microsoft.CodeAnalysis.SyntaxToken doKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithWhileKeyword(Microsoft.CodeAnalysis.SyntaxToken whileKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithDoKeyword(Microsoft.CodeAnalysis.SyntaxToken doKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.WithWhileKeyword(Microsoft.CodeAnalysis.SyntaxToken whileKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax! argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax! argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax! argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax! argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.ElifKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken elifKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive, bool branchTaken, bool conditionValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithBranchTaken(bool branchTaken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithConditionValue(bool conditionValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithElifKeyword(Microsoft.CodeAnalysis.SyntaxToken elifKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken elifKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive, bool branchTaken, bool conditionValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithBranchTaken(bool branchTaken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithConditionValue(bool conditionValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithElifKeyword(Microsoft.CodeAnalysis.SyntaxToken elifKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.ElseKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken elseKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.WithElseKeyword(Microsoft.CodeAnalysis.SyntaxToken elseKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken elseKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.WithElseKeyword(Microsoft.CodeAnalysis.SyntaxToken elseKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.ElseKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken elseKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive, bool branchTaken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithBranchTaken(bool branchTaken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithElseKeyword(Microsoft.CodeAnalysis.SyntaxToken elseKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken elseKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive, bool branchTaken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithBranchTaken(bool branchTaken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithElseKeyword(Microsoft.CodeAnalysis.SyntaxToken elseKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.EndIfKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken endIfKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.WithEndIfKeyword(Microsoft.CodeAnalysis.SyntaxToken endIfKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken endIfKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.WithEndIfKeyword(Microsoft.CodeAnalysis.SyntaxToken endIfKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.EndRegionKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken endRegionKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.WithEndRegionKeyword(Microsoft.CodeAnalysis.SyntaxToken endRegionKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken endRegionKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.WithEndRegionKeyword(Microsoft.CodeAnalysis.SyntaxToken endRegionKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.AddBaseListTypes(params Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.AddMembers(params Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.AddBaseListTypes(params Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.AddMembers(params Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.EnumKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.Members.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken enumKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithEnumKeyword(Microsoft.CodeAnalysis.SyntaxToken enumKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.Members.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken enumKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax!> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithEnumKeyword(Microsoft.CodeAnalysis.SyntaxToken enumKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.EqualsValue.get -> Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.EqualsValue.get -> Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax equalsValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax equalsValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.WithEqualsValue(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax equalsValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax! equalsValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax? equalsValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.WithEqualsValue(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax? equalsValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.EqualsToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken equalsToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax value) -> Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.Value.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken equalsToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.WithValue(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax value) -> Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken equalsToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! value) -> Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.Value.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken equalsToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.WithValue(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! value) -> Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.ErrorKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken errorKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.WithErrorKeyword(Microsoft.CodeAnalysis.SyntaxToken errorKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken errorKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.WithErrorKeyword(Microsoft.CodeAnalysis.SyntaxToken errorKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.AddAccessorListAccessors(params Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.AddAccessorListAccessors(params Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.EventKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken eventKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken eventKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax accessorList, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken eventKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithEventKeyword(Microsoft.CodeAnalysis.SyntaxToken eventKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken eventKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax! explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax! accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken eventKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax? accessorList, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken eventKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax! explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax? accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithEventKeyword(Microsoft.CodeAnalysis.SyntaxToken eventKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.AddDeclarationVariables(params Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.AddDeclarationVariables(params Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.EventKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken eventKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithEventKeyword(Microsoft.CodeAnalysis.SyntaxToken eventKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken eventKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithEventKeyword(Microsoft.CodeAnalysis.SyntaxToken eventKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.DotToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, Microsoft.CodeAnalysis.SyntaxToken dotToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.WithDotToken(Microsoft.CodeAnalysis.SyntaxToken dotToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken dotToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.WithDotToken(Microsoft.CodeAnalysis.SyntaxToken dotToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionOrPatternSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.AllowsAnyExpression.get -> bool
-Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.AliasKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.ExternKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken externKeyword, Microsoft.CodeAnalysis.SyntaxToken aliasKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.WithAliasKeyword(Microsoft.CodeAnalysis.SyntaxToken aliasKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.WithExternKeyword(Microsoft.CodeAnalysis.SyntaxToken externKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken externKeyword, Microsoft.CodeAnalysis.SyntaxToken aliasKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.WithAliasKeyword(Microsoft.CodeAnalysis.SyntaxToken aliasKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.WithExternKeyword(Microsoft.CodeAnalysis.SyntaxToken externKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.AddDeclarationVariables(params Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.AddDeclarationVariables(params Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.AddBlockAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.AddBlockStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.Block.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.AddBlockAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.AddBlockStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.Block.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.FinallyKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken finallyKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.WithFinallyKeyword(Microsoft.CodeAnalysis.SyntaxToken finallyKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken finallyKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block) -> Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block) -> Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.WithFinallyKeyword(Microsoft.CodeAnalysis.SyntaxToken finallyKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.AddDeclarationVariables(params Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.AddDeclarationVariables(params Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Declaration.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Declaration.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.FixedKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken fixedKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken fixedKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithFixedKeyword(Microsoft.CodeAnalysis.SyntaxToken fixedKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken fixedKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken fixedKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithFixedKeyword(Microsoft.CodeAnalysis.SyntaxToken fixedKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithForEachKeyword(Microsoft.CodeAnalysis.SyntaxToken forEachKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken inKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithForEachKeyword(Microsoft.CodeAnalysis.SyntaxToken forEachKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken inKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax variable, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax variable, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax variable, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Variable.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithForEachKeyword(Microsoft.CodeAnalysis.SyntaxToken forEachKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken inKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithVariable(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax variable) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! variable, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! variable, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! variable, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Variable.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithForEachKeyword(Microsoft.CodeAnalysis.SyntaxToken forEachKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken inKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.WithVariable(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! variable) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.AddIncrementors(params Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.AddInitializers(params Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.AddIncrementors(params Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.AddInitializers(params Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Condition.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Declaration.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Condition.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Declaration.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.FirstSemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.ForKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Incrementors.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Initializers.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax>
+Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Incrementors.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Initializers.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!>
 Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.SecondSemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken forKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> initializers, Microsoft.CodeAnalysis.SyntaxToken firstSemicolonToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SyntaxToken secondSemicolonToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> incrementors, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken forKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> initializers, Microsoft.CodeAnalysis.SyntaxToken firstSemicolonToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SyntaxToken secondSemicolonToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> incrementors, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithFirstSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken firstSemicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithForKeyword(Microsoft.CodeAnalysis.SyntaxToken forKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithIncrementors(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> incrementors) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithInitializers(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> initializers) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithSecondSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken secondSemicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken forKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> initializers, Microsoft.CodeAnalysis.SyntaxToken firstSemicolonToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? condition, Microsoft.CodeAnalysis.SyntaxToken secondSemicolonToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> incrementors, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken forKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> initializers, Microsoft.CodeAnalysis.SyntaxToken firstSemicolonToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? condition, Microsoft.CodeAnalysis.SyntaxToken secondSemicolonToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> incrementors, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithFirstSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken firstSemicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithForKeyword(Microsoft.CodeAnalysis.SyntaxToken forKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithIncrementors(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> incrementors) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithInitializers(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> initializers) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithSecondSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken secondSemicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.FromKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.InKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken fromKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithFromKeyword(Microsoft.CodeAnalysis.SyntaxToken fromKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken inKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken fromKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithFromKeyword(Microsoft.CodeAnalysis.SyntaxToken fromKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken inKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type) -> Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.AddUnmanagedCallingConventionListCallingConventions(params Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.AddUnmanagedCallingConventionListCallingConventions(params Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.ManagedOrUnmanagedKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.UnmanagedCallingConventionList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken managedOrUnmanagedKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.WithManagedOrUnmanagedKeyword(Microsoft.CodeAnalysis.SyntaxToken managedOrUnmanagedKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.WithUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.UnmanagedCallingConventionList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken managedOrUnmanagedKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.WithManagedOrUnmanagedKeyword(Microsoft.CodeAnalysis.SyntaxToken managedOrUnmanagedKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.WithUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.AddParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.AddParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.GreaterThanToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.LessThanToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.Parameters.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax> parameters, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken lessThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax> parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.Parameters.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax!> parameters, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken lessThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax!> parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.AsteriskToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.CallingConvention.get -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.CallingConvention.get -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.DelegateKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.SyntaxToken asteriskToken, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax callingConvention, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithAsteriskToken(Microsoft.CodeAnalysis.SyntaxToken asteriskToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax callingConvention) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithDelegateKeyword(Microsoft.CodeAnalysis.SyntaxToken delegateKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.SyntaxToken asteriskToken, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax? callingConvention, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax! parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithAsteriskToken(Microsoft.CodeAnalysis.SyntaxToken asteriskToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax? callingConvention) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithDelegateKeyword(Microsoft.CodeAnalysis.SyntaxToken delegateKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax! parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.AddCallingConventions(params Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.CallingConventions.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax>
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.AddCallingConventions(params Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.CallingConventions.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax!>
 Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.CloseBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.OpenBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax> callingConventions, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.WithCallingConventions(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax> callingConventions) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken openBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax!> callingConventions, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.WithCallingConventions(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax!> callingConventions) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken openBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Name.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken name) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.WithName(Microsoft.CodeAnalysis.SyntaxToken name) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken name) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.WithName(Microsoft.CodeAnalysis.SyntaxToken name) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.AddTypeArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.AddTypeArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.IsUnboundGenericName.get -> bool
-Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.TypeArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax typeArgumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.WithTypeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax typeArgumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.TypeArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax! typeArgumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.WithTypeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax! typeArgumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.CaseOrDefaultKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.GotoKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken gotoKeyword, Microsoft.CodeAnalysis.SyntaxToken caseOrDefaultKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken gotoKeyword, Microsoft.CodeAnalysis.SyntaxToken caseOrDefaultKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithCaseOrDefaultKeyword(Microsoft.CodeAnalysis.SyntaxToken caseOrDefaultKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithGotoKeyword(Microsoft.CodeAnalysis.SyntaxToken gotoKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken gotoKeyword, Microsoft.CodeAnalysis.SyntaxToken caseOrDefaultKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken gotoKeyword, Microsoft.CodeAnalysis.SyntaxToken caseOrDefaultKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithCaseOrDefaultKeyword(Microsoft.CodeAnalysis.SyntaxToken caseOrDefaultKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithGotoKeyword(Microsoft.CodeAnalysis.SyntaxToken gotoKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.ByExpression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.ByExpression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.ByKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.GroupExpression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.GroupExpression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.GroupKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken groupKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax groupExpression, Microsoft.CodeAnalysis.SyntaxToken byKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax byExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.WithByExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax byExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.WithByKeyword(Microsoft.CodeAnalysis.SyntaxToken byKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.WithGroupExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax groupExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.WithGroupKeyword(Microsoft.CodeAnalysis.SyntaxToken groupKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken groupKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! groupExpression, Microsoft.CodeAnalysis.SyntaxToken byKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! byExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.WithByExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! byExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.WithByKeyword(Microsoft.CodeAnalysis.SyntaxToken byKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.WithGroupExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! groupExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.WithGroupKeyword(Microsoft.CodeAnalysis.SyntaxToken groupKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.IfKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken ifKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive, bool branchTaken, bool conditionValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithBranchTaken(bool branchTaken) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithConditionValue(bool conditionValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithIfKeyword(Microsoft.CodeAnalysis.SyntaxToken ifKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken ifKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive, bool branchTaken, bool conditionValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithBranchTaken(bool branchTaken) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithConditionValue(bool conditionValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithIfKeyword(Microsoft.CodeAnalysis.SyntaxToken ifKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Condition.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Else.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Condition.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Else.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.IfKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken ifKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement, Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax else) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken ifKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement, Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax else) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithElse(Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax else) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithIfKeyword(Microsoft.CodeAnalysis.SyntaxToken ifKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken ifKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement, Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax? else) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken ifKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement, Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax? else) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithElse(Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax? else) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithIfKeyword(Microsoft.CodeAnalysis.SyntaxToken ifKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.AddCommas(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.AddInitializerExpressions(params Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.AddCommas(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.AddInitializerExpressions(params Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.CloseBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.Commas.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.NewKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.OpenBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SyntaxTokenList commas, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithCommas(Microsoft.CodeAnalysis.SyntaxTokenList commas) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken newKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken openBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SyntaxTokenList commas, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax! initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithCommas(Microsoft.CodeAnalysis.SyntaxTokenList commas) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax! initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken newKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken openBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax! argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax! argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken newKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax! argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax! argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken newKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.AddInitializerExpressions(params Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.AddInitializerExpressions(params Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.CloseBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.OpenBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.StackAllocKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken stackAllocKeyword, Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken openBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.WithStackAllocKeyword(Microsoft.CodeAnalysis.SyntaxToken stackAllocKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken stackAllocKeyword, Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax! initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax! initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken openBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.WithStackAllocKeyword(Microsoft.CodeAnalysis.SyntaxToken stackAllocKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type) -> Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type) -> Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AddAccessorListAccessors(params Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AddAccessorListAccessors(params Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.Semicolon.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.ThisKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken thisKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax accessorList, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithSemicolon(Microsoft.CodeAnalysis.SyntaxToken semicolon) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithThisKeyword(Microsoft.CodeAnalysis.SyntaxToken thisKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken thisKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax? accessorList, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax? accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax! parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithSemicolon(Microsoft.CodeAnalysis.SyntaxToken semicolon) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithThisKeyword(Microsoft.CodeAnalysis.SyntaxToken thisKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.AddParametersParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.Parameters.get -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.AddParametersParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.Parameters.get -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.ThisKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken thisKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.WithParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.WithThisKeyword(Microsoft.CodeAnalysis.SyntaxToken thisKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken thisKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax? parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.WithParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax? parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.WithThisKeyword(Microsoft.CodeAnalysis.SyntaxToken thisKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.AddExpressions(params Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.AddExpressions(params Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.CloseBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.Expressions.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax>
+Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.Expressions.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!>
 Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.OpenBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> expressions, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.WithExpressions(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> expressions) -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> expressions, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.WithExpressions(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> expressions) -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.InstanceExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddBaseListTypes(params Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddConstraintClauses(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddMembers(params Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddTypeParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddBaseListTypes(params Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddConstraintClauses(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddMembers(params Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AddTypeParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.AddContents(params Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.Contents.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax>
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.AddContents(params Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.Contents.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax!>
 Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.StringEndToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.StringStartToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken stringStartToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax> contents, Microsoft.CodeAnalysis.SyntaxToken stringEndToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.WithContents(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax> contents) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.WithStringEndToken(Microsoft.CodeAnalysis.SyntaxToken stringEndToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.WithStringStartToken(Microsoft.CodeAnalysis.SyntaxToken stringStartToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken stringStartToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax!> contents, Microsoft.CodeAnalysis.SyntaxToken stringEndToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.WithContents(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax!> contents) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.WithStringEndToken(Microsoft.CodeAnalysis.SyntaxToken stringEndToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.WithStringStartToken(Microsoft.CodeAnalysis.SyntaxToken stringStartToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.TextToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken textToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.WithTextToken(Microsoft.CodeAnalysis.SyntaxToken textToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken textToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.WithTextToken(Microsoft.CodeAnalysis.SyntaxToken textToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.CommaToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken commaToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax value) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.Value.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.WithCommaToken(Microsoft.CodeAnalysis.SyntaxToken commaToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.WithValue(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax value) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken commaToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! value) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.Value.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.WithCommaToken(Microsoft.CodeAnalysis.SyntaxToken commaToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.WithValue(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! value) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.ColonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.FormatStringToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.SyntaxToken formatStringToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.WithFormatStringToken(Microsoft.CodeAnalysis.SyntaxToken formatStringToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.SyntaxToken formatStringToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.WithFormatStringToken(Microsoft.CodeAnalysis.SyntaxToken formatStringToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.AlignmentClause.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.AlignmentClause.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.CloseBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.FormatClause.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.FormatClause.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.OpenBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax alignmentClause, Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax formatClause, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithAlignmentClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax alignmentClause) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithFormatClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax formatClause) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax? alignmentClause, Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax? formatClause, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithAlignmentClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax? alignmentClause) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithFormatClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax? formatClause) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax! argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax! argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.IsKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.Pattern.get -> Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken isKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.WithIsKeyword(Microsoft.CodeAnalysis.SyntaxToken isKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.Pattern.get -> Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken isKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.WithIsKeyword(Microsoft.CodeAnalysis.SyntaxToken isKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.EqualsKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.InExpression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.InExpression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.InKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.Into.get -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.Into.get -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.JoinKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.LeftExpression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.LeftExpression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.OnKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.RightExpression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken joinKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax inExpression, Microsoft.CodeAnalysis.SyntaxToken onKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax leftExpression, Microsoft.CodeAnalysis.SyntaxToken equalsKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax rightExpression, Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax into) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithEqualsKeyword(Microsoft.CodeAnalysis.SyntaxToken equalsKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithInExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax inExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken inKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithInto(Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax into) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithJoinKeyword(Microsoft.CodeAnalysis.SyntaxToken joinKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithLeftExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax leftExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithOnKeyword(Microsoft.CodeAnalysis.SyntaxToken onKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithRightExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax rightExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.RightExpression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken joinKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! inExpression, Microsoft.CodeAnalysis.SyntaxToken onKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! leftExpression, Microsoft.CodeAnalysis.SyntaxToken equalsKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! rightExpression, Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax? into) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithEqualsKeyword(Microsoft.CodeAnalysis.SyntaxToken equalsKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithInExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! inExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithInKeyword(Microsoft.CodeAnalysis.SyntaxToken inKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithInto(Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax? into) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithJoinKeyword(Microsoft.CodeAnalysis.SyntaxToken joinKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithLeftExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! leftExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithOnKeyword(Microsoft.CodeAnalysis.SyntaxToken onKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithRightExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! rightExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.IntoKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken intoKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.WithIntoKeyword(Microsoft.CodeAnalysis.SyntaxToken intoKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken intoKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.WithIntoKeyword(Microsoft.CodeAnalysis.SyntaxToken intoKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.ColonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.AddBlockAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.AddBlockStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithArrowToken(Microsoft.CodeAnalysis.SyntaxToken arrowToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode body) -> Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.AddBlockAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.AddBlockStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousFunctionExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithArrowToken(Microsoft.CodeAnalysis.SyntaxToken arrowToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax!
+~Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block) -> Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax!
+~Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode body) -> Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.EqualsToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.LetKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken letKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken equalsToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken equalsToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.WithLetKeyword(Microsoft.CodeAnalysis.SyntaxToken letKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken letKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken equalsToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken equalsToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.WithLetKeyword(Microsoft.CodeAnalysis.SyntaxToken letKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.File.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.Line.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.LineKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken lineKeyword, Microsoft.CodeAnalysis.SyntaxToken line, Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken file) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithLine(Microsoft.CodeAnalysis.SyntaxToken line) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithLineKeyword(Microsoft.CodeAnalysis.SyntaxToken lineKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken lineKeyword, Microsoft.CodeAnalysis.SyntaxToken line, Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken file) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithLine(Microsoft.CodeAnalysis.SyntaxToken line) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.WithLineKeyword(Microsoft.CodeAnalysis.SyntaxToken lineKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.Token.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken token) -> Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.WithToken(Microsoft.CodeAnalysis.SyntaxToken token) -> Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken token) -> Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.WithToken(Microsoft.CodeAnalysis.SyntaxToken token) -> Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.File.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.LoadKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken loadKeyword, Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken file) -> Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithLoadKeyword(Microsoft.CodeAnalysis.SyntaxToken loadKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken loadKeyword, Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken file) -> Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.WithLoadKeyword(Microsoft.CodeAnalysis.SyntaxToken loadKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.AddDeclarationVariables(params Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.AddDeclarationVariables(params Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.AwaitKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Declaration.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Declaration.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.IsConst.get -> bool
 Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
 Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.UsingKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithUsingKeyword(Microsoft.CodeAnalysis.SyntaxToken usingKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.WithUsingKeyword(Microsoft.CodeAnalysis.SyntaxToken usingKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddBodyAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddBodyStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddConstraintClauses(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddTypeParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Body.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.ConstraintClauses.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddBodyAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddBodyStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddConstraintClauses(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AddTypeParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Body.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.ConstraintClauses.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.ReturnType.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.ReturnType.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.TypeParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.TypeParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax! typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax! expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.LockKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken lockKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken lockKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithLockKeyword(Microsoft.CodeAnalysis.SyntaxToken lockKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken lockKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken lockKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithLockKeyword(Microsoft.CodeAnalysis.SyntaxToken lockKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.Keyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.OperatorToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.OperatorToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddBodyAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddBodyStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddConstraintClauses(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddTypeParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddBodyAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddBodyStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddConstraintClauses(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AddTypeParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.Arity.get -> int
-Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.ConstraintClauses.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.ExplicitInterfaceSpecifier.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.ConstraintClauses.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.ExplicitInterfaceSpecifier.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.ReturnType.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.TypeParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.ReturnType.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.TypeParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.ColonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax name, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.EqualsToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax name, Microsoft.CodeAnalysis.SyntaxToken equalsToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken equalsToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken equalsToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken equalsToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.AddParametersParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.Parameters.get -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax name, Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.WithParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.AddParametersParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.Parameters.get -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! name, Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax? parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.WithParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax? parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddExterns(params Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddMembers(params Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddUsings(params Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddExterns(params Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddMembers(params Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AddUsings(params Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.CloseBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Externs.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax>
 Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Members.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax>
@@ -1718,695 +1719,695 @@ Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Name.get -> Micr
 Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.NamespaceKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.OpenBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken namespaceKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken namespaceKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken namespaceKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken namespaceKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Usings.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithExterns(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithNamespaceKeyword(Microsoft.CodeAnalysis.SyntaxToken namespaceKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithUsings(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithExterns(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!> externs) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithNamespaceKeyword(Microsoft.CodeAnalysis.SyntaxToken namespaceKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.WithUsings(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!> usings) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax.Arity.get -> int
 Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.NullableKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.SettingToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.TargetToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken nullableKeyword, Microsoft.CodeAnalysis.SyntaxToken settingToken, Microsoft.CodeAnalysis.SyntaxToken targetToken, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithNullableKeyword(Microsoft.CodeAnalysis.SyntaxToken nullableKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithSettingToken(Microsoft.CodeAnalysis.SyntaxToken settingToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithTargetToken(Microsoft.CodeAnalysis.SyntaxToken targetToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken nullableKeyword, Microsoft.CodeAnalysis.SyntaxToken settingToken, Microsoft.CodeAnalysis.SyntaxToken targetToken, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithNullableKeyword(Microsoft.CodeAnalysis.SyntaxToken nullableKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithSettingToken(Microsoft.CodeAnalysis.SyntaxToken settingToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.WithTargetToken(Microsoft.CodeAnalysis.SyntaxToken targetToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.ElementType.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.ElementType.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.QuestionToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax elementType, Microsoft.CodeAnalysis.SyntaxToken questionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.WithElementType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax elementType) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.WithQuestionToken(Microsoft.CodeAnalysis.SyntaxToken questionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! elementType, Microsoft.CodeAnalysis.SyntaxToken questionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.WithElementType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! elementType) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.WithQuestionToken(Microsoft.CodeAnalysis.SyntaxToken questionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken newKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax? argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax? argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.WithNewKeyword(Microsoft.CodeAnalysis.SyntaxToken newKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.OmittedArraySizeExpressionToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken omittedArraySizeExpressionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.WithOmittedArraySizeExpressionToken(Microsoft.CodeAnalysis.SyntaxToken omittedArraySizeExpressionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken omittedArraySizeExpressionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.WithOmittedArraySizeExpressionToken(Microsoft.CodeAnalysis.SyntaxToken omittedArraySizeExpressionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.OmittedTypeArgumentToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken omittedTypeArgumentToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.WithOmittedTypeArgumentToken(Microsoft.CodeAnalysis.SyntaxToken omittedTypeArgumentToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken omittedTypeArgumentToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.WithOmittedTypeArgumentToken(Microsoft.CodeAnalysis.SyntaxToken omittedTypeArgumentToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddBodyAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddBodyStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddBodyAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddBodyStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.OperatorKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.OperatorToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.ReturnType.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithOperatorKeyword(Microsoft.CodeAnalysis.SyntaxToken operatorKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.ReturnType.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithOperatorKeyword(Microsoft.CodeAnalysis.SyntaxToken operatorKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.AddParametersParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.AddParametersParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.OperatorKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.OperatorToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.Parameters.get -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.WithOperatorKeyword(Microsoft.CodeAnalysis.SyntaxToken operatorKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.WithParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.Parameters.get -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax? parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.WithOperatorKeyword(Microsoft.CodeAnalysis.SyntaxToken operatorKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.WithParameters(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax? parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.AddOrderings(params Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.AddOrderings(params Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.OrderByKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.Orderings.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken orderByKeyword, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax> orderings) -> Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.WithOrderByKeyword(Microsoft.CodeAnalysis.SyntaxToken orderByKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.WithOrderings(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax> orderings) -> Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.Orderings.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken orderByKeyword, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax!> orderings) -> Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.WithOrderByKeyword(Microsoft.CodeAnalysis.SyntaxToken orderByKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.WithOrderings(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax!> orderings) -> Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.AscendingOrDescendingKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken ascendingOrDescendingKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.WithAscendingOrDescendingKeyword(Microsoft.CodeAnalysis.SyntaxToken ascendingOrDescendingKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken ascendingOrDescendingKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.WithAscendingOrDescendingKeyword(Microsoft.CodeAnalysis.SyntaxToken ascendingOrDescendingKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.AddParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.AddParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax> parameters, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax> parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!> parameters, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!> parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Default.get -> Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Default.get -> Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax default) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithDefault(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax default) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax! default) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithDefault(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax? default) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddBlockAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddBlockStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode body) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithArrowToken(Microsoft.CodeAnalysis.SyntaxToken arrowToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode body) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddBlockAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddBlockStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithArrowToken(Microsoft.CodeAnalysis.SyntaxToken arrowToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.Pattern.get -> Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.Pattern.get -> Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.AddVariables(params Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.AddVariables(params Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax> variables, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.Variables.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.WithVariables(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax> variables) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax!> variables, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.Variables.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.WithVariables(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax!> variables) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.AsteriskToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.ElementType.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax elementType, Microsoft.CodeAnalysis.SyntaxToken asteriskToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.WithAsteriskToken(Microsoft.CodeAnalysis.SyntaxToken asteriskToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.WithElementType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax elementType) -> Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.ElementType.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! elementType, Microsoft.CodeAnalysis.SyntaxToken asteriskToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.WithAsteriskToken(Microsoft.CodeAnalysis.SyntaxToken asteriskToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.WithElementType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! elementType) -> Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.AddSubpatterns(params Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.AddSubpatterns(params Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.Subpatterns.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax> subpatterns, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.WithSubpatterns(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax> subpatterns) -> Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.Subpatterns.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax!> subpatterns, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.WithSubpatterns(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax!> subpatterns) -> Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.Operand.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.Operand.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.OperatorToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax operand, Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.WithOperand(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax operand) -> Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! operand, Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.WithOperand(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! operand) -> Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.Bytes.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.ChecksumKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.File.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.Guid.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.PragmaKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken pragmaKeyword, Microsoft.CodeAnalysis.SyntaxToken checksumKeyword, Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken guid, Microsoft.CodeAnalysis.SyntaxToken bytes, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithBytes(Microsoft.CodeAnalysis.SyntaxToken bytes) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithChecksumKeyword(Microsoft.CodeAnalysis.SyntaxToken checksumKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken file) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithGuid(Microsoft.CodeAnalysis.SyntaxToken guid) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithPragmaKeyword(Microsoft.CodeAnalysis.SyntaxToken pragmaKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken pragmaKeyword, Microsoft.CodeAnalysis.SyntaxToken checksumKeyword, Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken guid, Microsoft.CodeAnalysis.SyntaxToken bytes, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithBytes(Microsoft.CodeAnalysis.SyntaxToken bytes) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithChecksumKeyword(Microsoft.CodeAnalysis.SyntaxToken checksumKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken file) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithGuid(Microsoft.CodeAnalysis.SyntaxToken guid) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.WithPragmaKeyword(Microsoft.CodeAnalysis.SyntaxToken pragmaKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.AddErrorCodes(params Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.AddErrorCodes(params Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.DisableOrRestoreKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.ErrorCodes.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax>
+Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.ErrorCodes.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!>
 Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.PragmaKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken pragmaKeyword, Microsoft.CodeAnalysis.SyntaxToken warningKeyword, Microsoft.CodeAnalysis.SyntaxToken disableOrRestoreKeyword, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> errorCodes, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken pragmaKeyword, Microsoft.CodeAnalysis.SyntaxToken warningKeyword, Microsoft.CodeAnalysis.SyntaxToken disableOrRestoreKeyword, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> errorCodes, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WarningKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithDisableOrRestoreKeyword(Microsoft.CodeAnalysis.SyntaxToken disableOrRestoreKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithErrorCodes(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> errorCodes) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithPragmaKeyword(Microsoft.CodeAnalysis.SyntaxToken pragmaKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithWarningKeyword(Microsoft.CodeAnalysis.SyntaxToken warningKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithDisableOrRestoreKeyword(Microsoft.CodeAnalysis.SyntaxToken disableOrRestoreKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithErrorCodes(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> errorCodes) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithPragmaKeyword(Microsoft.CodeAnalysis.SyntaxToken pragmaKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.WithWarningKeyword(Microsoft.CodeAnalysis.SyntaxToken warningKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.Keyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.Operand.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.Operand.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.OperatorToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax operand) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.WithOperand(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax operand) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! operand) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.WithOperand(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! operand) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax! argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax! argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.AddAccessorListAccessors(params Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.AddAccessorListAccessors(params Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.Semicolon.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax accessorList, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax initializer, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithSemicolon(Microsoft.CodeAnalysis.SyntaxToken semicolon) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax? accessorList, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax? initializer, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax? accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax? initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithSemicolon(Microsoft.CodeAnalysis.SyntaxToken semicolon) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.AddSubpatterns(params Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.AddSubpatterns(params Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.CloseBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.OpenBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.Subpatterns.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax> subpatterns, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.WithSubpatterns(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax> subpatterns) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.Subpatterns.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax!> subpatterns, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.WithSubpatterns(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax!> subpatterns) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.Container.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.Container.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.DotToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.Member.get -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax container, Microsoft.CodeAnalysis.SyntaxToken dotToken, Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax member) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.WithContainer(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax container) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.WithDotToken(Microsoft.CodeAnalysis.SyntaxToken dotToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.WithMember(Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax member) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.Member.get -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! container, Microsoft.CodeAnalysis.SyntaxToken dotToken, Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax! member) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.WithContainer(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! container) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.WithDotToken(Microsoft.CodeAnalysis.SyntaxToken dotToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.WithMember(Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax! member) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.DotToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.Left.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.Right.get -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax left, Microsoft.CodeAnalysis.SyntaxToken dotToken, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax right) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.WithDotToken(Microsoft.CodeAnalysis.SyntaxToken dotToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.WithLeft(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax left) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.WithRight(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax right) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.Left.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.Right.get -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! left, Microsoft.CodeAnalysis.SyntaxToken dotToken, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax! right) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.WithDotToken(Microsoft.CodeAnalysis.SyntaxToken dotToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.WithLeft(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! left) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.WithRight(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax! right) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.AddClauses(params Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.Clauses.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.Continuation.get -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.SelectOrGroup.get -> Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax> clauses, Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax selectOrGroup, Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax continuation) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.WithClauses(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax> clauses) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.WithContinuation(Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax continuation) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.WithSelectOrGroup(Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax selectOrGroup) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.AddClauses(params Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.Clauses.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.Continuation.get -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.SelectOrGroup.get -> Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax!> clauses, Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax! selectOrGroup, Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax? continuation) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.WithClauses(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax!> clauses) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.WithContinuation(Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax? continuation) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.WithSelectOrGroup(Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax! selectOrGroup) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.AddBodyClauses(params Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.Body.get -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.AddBodyClauses(params Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.Body.get -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.IntoKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken intoKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax body) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax body) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.WithIntoKeyword(Microsoft.CodeAnalysis.SyntaxToken intoKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken intoKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.WithIntoKeyword(Microsoft.CodeAnalysis.SyntaxToken intoKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.AddBodyClauses(params Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.Body.get -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.FromClause.get -> Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax fromClause, Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax body) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax body) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.WithFromClause(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax fromClause) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.AddBodyClauses(params Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.Body.get -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.FromClause.get -> Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax! fromClause, Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.WithFromClause(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax! fromClause) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.LeftOperand.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.LeftOperand.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.OperatorToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.RightOperand.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax leftOperand, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax rightOperand) -> Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.WithLeftOperand(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax leftOperand) -> Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.WithRightOperand(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax rightOperand) -> Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.RightOperand.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? leftOperand, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? rightOperand) -> Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.WithLeftOperand(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? leftOperand) -> Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.WithRightOperand(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? rightOperand) -> Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddBaseListTypes(params Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddConstraintClauses(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddMembers(params Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddTypeParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddBaseListTypes(params Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddConstraintClauses(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddMembers(params Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AddTypeParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax? parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax? parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.AddPositionalPatternClauseSubpatterns(params Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.AddPropertyPatternClauseSubpatterns(params Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.Designation.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.PositionalPatternClause.get -> Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.PropertyPatternClause.get -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax positionalPatternClause, Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax propertyPatternClause, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.WithPositionalPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax positionalPatternClause) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.WithPropertyPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax propertyPatternClause) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.AddPositionalPatternClauseSubpatterns(params Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.AddPropertyPatternClauseSubpatterns(params Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.Designation.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.PositionalPatternClause.get -> Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.PropertyPatternClause.get -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type, Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax? positionalPatternClause, Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax? propertyPatternClause, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax? designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax? designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.WithPositionalPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax? positionalPatternClause) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.WithPropertyPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax? propertyPatternClause) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.File.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.ReferenceKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken referenceKeyword, Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken file) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithReferenceKeyword(Microsoft.CodeAnalysis.SyntaxToken referenceKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken referenceKeyword, Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken file) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.WithReferenceKeyword(Microsoft.CodeAnalysis.SyntaxToken referenceKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.RefKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken refKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.WithRefKeyword(Microsoft.CodeAnalysis.SyntaxToken refKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken refKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.WithRefKeyword(Microsoft.CodeAnalysis.SyntaxToken refKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.Keyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.ReadOnlyKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.RefKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken refKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken refKeyword, Microsoft.CodeAnalysis.SyntaxToken readOnlyKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.WithReadOnlyKeyword(Microsoft.CodeAnalysis.SyntaxToken readOnlyKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.WithRefKeyword(Microsoft.CodeAnalysis.SyntaxToken refKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken refKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken refKeyword, Microsoft.CodeAnalysis.SyntaxToken readOnlyKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.WithReadOnlyKeyword(Microsoft.CodeAnalysis.SyntaxToken readOnlyKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.WithRefKeyword(Microsoft.CodeAnalysis.SyntaxToken refKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.Comma.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.Keyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken comma, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithComma(Microsoft.CodeAnalysis.SyntaxToken comma) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken comma, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithComma(Microsoft.CodeAnalysis.SyntaxToken comma) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.RegionKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken regionKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.WithRegionKeyword(Microsoft.CodeAnalysis.SyntaxToken regionKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken regionKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.WithRegionKeyword(Microsoft.CodeAnalysis.SyntaxToken regionKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.OperatorToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.ReturnKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken returnKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken returnKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.WithReturnKeyword(Microsoft.CodeAnalysis.SyntaxToken returnKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken returnKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken returnKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.WithReturnKeyword(Microsoft.CodeAnalysis.SyntaxToken returnKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.SelectKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken selectKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.WithSelectKeyword(Microsoft.CodeAnalysis.SyntaxToken selectKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken selectKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.WithSelectKeyword(Microsoft.CodeAnalysis.SyntaxToken selectKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.ExclamationToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken exclamationToken, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.WithExclamationToken(Microsoft.CodeAnalysis.SyntaxToken exclamationToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken exclamationToken, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.WithExclamationToken(Microsoft.CodeAnalysis.SyntaxToken exclamationToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddBlockAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddBlockStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddParameterAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddParameterModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Parameter.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax parameter, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode body) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax parameter, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax parameter, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithArrowToken(Microsoft.CodeAnalysis.SyntaxToken arrowToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode body) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithParameter(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax parameter) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddBlockAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddBlockStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddParameterAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddParameterModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Parameter.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax! parameter, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax! parameter, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax! parameter, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithArrowToken(Microsoft.CodeAnalysis.SyntaxToken arrowToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithAsyncKeyword(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithBody(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithExpressionBody(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithParameter(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax! parameter) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.Keyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.AddTokens(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.AddTokens(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.Tokens.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList tokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.WithTokens(Microsoft.CodeAnalysis.SyntaxTokenList tokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList tokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.WithTokens(Microsoft.CodeAnalysis.SyntaxTokenList tokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.StackAllocKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken stackAllocKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken stackAllocKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.WithStackAllocKeyword(Microsoft.CodeAnalysis.SyntaxToken stackAllocKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken stackAllocKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken stackAllocKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.WithStackAllocKeyword(Microsoft.CodeAnalysis.SyntaxToken stackAllocKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddBaseListTypes(params Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddConstraintClauses(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddMembers(params Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddTypeParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddBaseListTypes(params Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddConstraintClauses(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddMembers(params Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AddTypeParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.StructuredTriviaSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.NameColon.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.Pattern.get -> Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax nameColon, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.WithNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax nameColon) -> Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.NameColon.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.Pattern.get -> Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax? nameColon, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.WithNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax? nameColon) -> Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.EqualsGreaterThanToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.Pattern.get -> Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern, Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax whenClause, Microsoft.CodeAnalysis.SyntaxToken equalsGreaterThanToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.WhenClause.get -> Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.WithEqualsGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken equalsGreaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.WithWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax whenClause) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.Pattern.get -> Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern, Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax? whenClause, Microsoft.CodeAnalysis.SyntaxToken equalsGreaterThanToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.WhenClause.get -> Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.WithEqualsGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken equalsGreaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.WithWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax? whenClause) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.AddArms(params Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.Arms.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax>
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.AddArms(params Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.Arms.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax!>
 Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.CloseBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.GoverningExpression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.GoverningExpression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.OpenBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.SwitchKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax governingExpression, Microsoft.CodeAnalysis.SyntaxToken switchKeyword, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax> arms, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithArms(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax> arms) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithGoverningExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax governingExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithSwitchKeyword(Microsoft.CodeAnalysis.SyntaxToken switchKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! governingExpression, Microsoft.CodeAnalysis.SyntaxToken switchKeyword, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax!> arms, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithArms(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax!> arms) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithGoverningExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! governingExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.WithSwitchKeyword(Microsoft.CodeAnalysis.SyntaxToken switchKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.AddLabels(params Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.AddStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.Labels.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.Statements.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax> labels, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax> statements) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.WithLabels(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax> labels) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.WithStatements(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax> statements) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.AddLabels(params Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.AddStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.Labels.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.Statements.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax!> labels, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!> statements) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.WithLabels(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax!> labels) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.WithStatements(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!> statements) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.AddSections(params Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.AddSections(params Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.CloseBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.OpenBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Sections.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax>
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Sections.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax!>
 Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.SwitchKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken switchKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax> sections, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken switchKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax> sections, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithSections(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax> sections) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithSwitchKeyword(Microsoft.CodeAnalysis.SyntaxToken switchKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken switchKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax!> sections, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken switchKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax!> sections, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithSections(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax!> sections) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.WithSwitchKeyword(Microsoft.CodeAnalysis.SyntaxToken switchKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.Token.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken token) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.WithToken(Microsoft.CodeAnalysis.SyntaxToken token) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken token) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.WithToken(Microsoft.CodeAnalysis.SyntaxToken token) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.ThrowKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken throwKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.WithThrowKeyword(Microsoft.CodeAnalysis.SyntaxToken throwKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken throwKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.WithThrowKeyword(Microsoft.CodeAnalysis.SyntaxToken throwKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.ThrowKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken throwKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken throwKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.WithThrowKeyword(Microsoft.CodeAnalysis.SyntaxToken throwKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken throwKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken throwKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.WithThrowKeyword(Microsoft.CodeAnalysis.SyntaxToken throwKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AddBlockAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AddBlockStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AddCatches(params Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Block.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Catches.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Finally.get -> Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AddBlockAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AddBlockStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AddCatches(params Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Block.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Catches.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Finally.get -> Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.TryKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken tryKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax> catches, Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax finally) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken tryKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax> catches, Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax finally) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithCatches(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax> catches) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithFinally(Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax finally) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithTryKeyword(Microsoft.CodeAnalysis.SyntaxToken tryKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken tryKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!> catches, Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax? finally) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken tryKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!> catches, Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax! finally) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithCatches(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!> catches) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithFinally(Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax? finally) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithTryKeyword(Microsoft.CodeAnalysis.SyntaxToken tryKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.AddArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.Arguments.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax>
+Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.AddArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.Arguments.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!>
 Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax> arguments, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax> arguments) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!> arguments, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!> arguments) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.AddElements(params Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.AddElements(params Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.Elements.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax>
+Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.Elements.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax!>
 Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax> elements, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.WithElements(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax> elements) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax!> elements, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.WithElements(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax!> elements) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.AddArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.Arguments.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax>
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.AddArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.Arguments.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!>
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.GreaterThanToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.LessThanToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax> arguments, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax> arguments) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken lessThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!> arguments, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.WithArguments(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!> arguments) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken lessThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddBaseListTypes(params Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddConstraintClauses(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddMembers(params Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddTypeParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddBaseListTypes(params Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddConstraintClauses(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddMembers(params Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.AddTypeParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.Arity.get -> int
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithCloseBraceToken(Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithConstraintClauses(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithOpenBraceToken(Microsoft.CodeAnalysis.SyntaxToken openBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.Keyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.WithKeyword(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.AddConstraints(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.AddConstraints(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.ColonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.Constraints.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken whereKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax name, Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax> constraints) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.Constraints.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken whereKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax!> constraints) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.WhereKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.WithConstraints(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax> constraints) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.WithWhereKeyword(Microsoft.CodeAnalysis.SyntaxToken whereKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.WithConstraints(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax!> constraints) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.WithWhereKeyword(Microsoft.CodeAnalysis.SyntaxToken whereKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.AddParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.AddParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.GreaterThanToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.LessThanToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.Parameters.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax> parameters, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken lessThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax> parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.Parameters.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax!> parameters, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken lessThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax!> parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken varianceKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken varianceKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.VarianceKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.WithVarianceKeyword(Microsoft.CodeAnalysis.SyntaxToken varianceKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.WithVarianceKeyword(Microsoft.CodeAnalysis.SyntaxToken varianceKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax.IsNint.get -> bool
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax.IsNotNull.get -> bool
@@ -2415,262 +2416,262 @@ Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax.IsUnmanaged.get -> bool
 Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax.IsVar.get -> bool
 Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.OperatorToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.Pattern.get -> Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.Pattern.get -> Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.WithOperatorToken(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.Name.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.UndefKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken undefKeyword, Microsoft.CodeAnalysis.SyntaxToken name, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithName(Microsoft.CodeAnalysis.SyntaxToken name) -> Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithUndefKeyword(Microsoft.CodeAnalysis.SyntaxToken undefKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken undefKeyword, Microsoft.CodeAnalysis.SyntaxToken name, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithName(Microsoft.CodeAnalysis.SyntaxToken name) -> Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.WithUndefKeyword(Microsoft.CodeAnalysis.SyntaxToken undefKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.AddBlockAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.AddBlockStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.Block.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.AddBlockAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.AddBlockStatements(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.Block.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.UnsafeKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken unsafeKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken unsafeKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.WithUnsafeKeyword(Microsoft.CodeAnalysis.SyntaxToken unsafeKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken unsafeKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken unsafeKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.WithBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.WithUnsafeKeyword(Microsoft.CodeAnalysis.SyntaxToken unsafeKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Alias.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Alias.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.StaticKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxToken staticKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax alias, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxToken staticKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax? alias, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.UsingKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithAlias(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax alias) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithStaticKeyword(Microsoft.CodeAnalysis.SyntaxToken staticKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithUsingKeyword(Microsoft.CodeAnalysis.SyntaxToken usingKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithAlias(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax? alias) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithStaticKeyword(Microsoft.CodeAnalysis.SyntaxToken staticKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithUsingKeyword(Microsoft.CodeAnalysis.SyntaxToken usingKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.AwaitKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Declaration.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Declaration.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.UsingKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithUsingKeyword(Microsoft.CodeAnalysis.SyntaxToken usingKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithAwaitKeyword(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.WithUsingKeyword(Microsoft.CodeAnalysis.SyntaxToken usingKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.AddVariables(params Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax> variables) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.Variables.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.WithVariables(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax> variables) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.AddVariables(params Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax!> variables) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.Variables.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.WithVariables(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax!> variables) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax? argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax? initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax? argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax? initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.Designation.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken varKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.Designation.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken varKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax! designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.VarKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.WithVarKeyword(Microsoft.CodeAnalysis.SyntaxToken varKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax! designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.WithVarKeyword(Microsoft.CodeAnalysis.SyntaxToken varKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken warningKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken warningKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.WarningKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.WithWarningKeyword(Microsoft.CodeAnalysis.SyntaxToken warningKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.WithWarningKeyword(Microsoft.CodeAnalysis.SyntaxToken warningKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.Condition.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken whenKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.Condition.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken whenKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.WhenKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.WithWhenKeyword(Microsoft.CodeAnalysis.SyntaxToken whenKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.WithWhenKeyword(Microsoft.CodeAnalysis.SyntaxToken whenKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.Condition.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken whereKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.Condition.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken whereKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.WhereKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.WithWhereKeyword(Microsoft.CodeAnalysis.SyntaxToken whereKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.WithWhereKeyword(Microsoft.CodeAnalysis.SyntaxToken whereKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Condition.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Condition.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken whileKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken whileKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken whileKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken whileKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WhileKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithWhileKeyword(Microsoft.CodeAnalysis.SyntaxToken whileKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithCondition(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.WithWhileKeyword(Microsoft.CodeAnalysis.SyntaxToken whileKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.AddInitializerExpressions(params Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken withKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.AddInitializerExpressions(params Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken withKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax! initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.WithInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax! initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.WithKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.WithWithKeyword(Microsoft.CodeAnalysis.SyntaxToken withKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.WithWithKeyword(Microsoft.CodeAnalysis.SyntaxToken withKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.WithEndQuoteToken(Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken equalsToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.WithStartQuoteToken(Microsoft.CodeAnalysis.SyntaxToken startQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.WithEndQuoteToken(Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken equalsToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax.WithStartQuoteToken(Microsoft.CodeAnalysis.SyntaxToken startQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.AddTextTokens(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.AddTextTokens(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.EndCDataToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.StartCDataToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.TextTokens.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken startCDataToken, Microsoft.CodeAnalysis.SyntaxTokenList textTokens, Microsoft.CodeAnalysis.SyntaxToken endCDataToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.WithEndCDataToken(Microsoft.CodeAnalysis.SyntaxToken endCDataToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.WithStartCDataToken(Microsoft.CodeAnalysis.SyntaxToken startCDataToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken startCDataToken, Microsoft.CodeAnalysis.SyntaxTokenList textTokens, Microsoft.CodeAnalysis.SyntaxToken endCDataToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.WithEndCDataToken(Microsoft.CodeAnalysis.SyntaxToken endCDataToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.WithStartCDataToken(Microsoft.CodeAnalysis.SyntaxToken startCDataToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.AddTextTokens(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.AddTextTokens(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.LessThanExclamationMinusMinusToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.MinusMinusGreaterThanToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.TextTokens.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken lessThanExclamationMinusMinusToken, Microsoft.CodeAnalysis.SyntaxTokenList textTokens, Microsoft.CodeAnalysis.SyntaxToken minusMinusGreaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.WithLessThanExclamationMinusMinusToken(Microsoft.CodeAnalysis.SyntaxToken lessThanExclamationMinusMinusToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.WithMinusMinusGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken minusMinusGreaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken lessThanExclamationMinusMinusToken, Microsoft.CodeAnalysis.SyntaxTokenList textTokens, Microsoft.CodeAnalysis.SyntaxToken minusMinusGreaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.WithLessThanExclamationMinusMinusToken(Microsoft.CodeAnalysis.SyntaxToken lessThanExclamationMinusMinusToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.WithMinusMinusGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken minusMinusGreaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.Cref.get -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxToken equalsToken, Microsoft.CodeAnalysis.SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax cref, Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithCref(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax cref) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithEndQuoteToken(Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken equalsToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithStartQuoteToken(Microsoft.CodeAnalysis.SyntaxToken startQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.Cref.get -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken equalsToken, Microsoft.CodeAnalysis.SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax! cref, Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithCref(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax! cref) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithEndQuoteToken(Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken equalsToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.WithStartQuoteToken(Microsoft.CodeAnalysis.SyntaxToken startQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.GreaterThanToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.LessThanSlashToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken lessThanSlashToken, Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.WithLessThanSlashToken(Microsoft.CodeAnalysis.SyntaxToken lessThanSlashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken lessThanSlashToken, Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.WithLessThanSlashToken(Microsoft.CodeAnalysis.SyntaxToken lessThanSlashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.AddAttributes(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.Attributes.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax>
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.AddAttributes(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.Attributes.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax!>
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.GreaterThanToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.LessThanToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax> attributes, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.WithAttributes(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax> attributes) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken lessThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax!> attributes, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.WithAttributes(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax!> attributes) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken lessThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.AddContent(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.AddStartTagAttributes(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.Content.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.EndTag.get -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.StartTag.get -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax startTag, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content, Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax endTag) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.WithContent(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.WithEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax endTag) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.WithStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax startTag) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.AddContent(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.AddStartTagAttributes(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.Content.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.EndTag.get -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.StartTag.get -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax! startTag, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!> content, Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax! endTag) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.WithContent(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.WithEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax! endTag) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.WithStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax! startTag) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.AddAttributes(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.Attributes.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax>
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.AddAttributes(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.Attributes.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax!>
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.LessThanToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.SlashGreaterThanToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax> attributes, Microsoft.CodeAnalysis.SyntaxToken slashGreaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.WithAttributes(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax> attributes) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken lessThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.WithSlashGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken slashGreaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax!> attributes, Microsoft.CodeAnalysis.SyntaxToken slashGreaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.WithAttributes(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax!> attributes) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken lessThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.WithSlashGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken slashGreaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind.Parameter = 0 -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind.ParameterReference = 1 -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind.TypeParameter = 2 -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind.TypeParameterReference = 3 -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeElementKind
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.Identifier.get -> Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxToken equalsToken, Microsoft.CodeAnalysis.SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax identifier, Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithEndQuoteToken(Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken equalsToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithIdentifier(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithStartQuoteToken(Microsoft.CodeAnalysis.SyntaxToken startQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.Identifier.get -> Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken equalsToken, Microsoft.CodeAnalysis.SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! identifier, Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithEndQuoteToken(Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken equalsToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithIdentifier(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.WithStartQuoteToken(Microsoft.CodeAnalysis.SyntaxToken startQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.LocalName.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.Prefix.get -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax prefix, Microsoft.CodeAnalysis.SyntaxToken localName) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.WithLocalName(Microsoft.CodeAnalysis.SyntaxToken localName) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.WithPrefix(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax prefix) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.Prefix.get -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax? prefix, Microsoft.CodeAnalysis.SyntaxToken localName) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.WithLocalName(Microsoft.CodeAnalysis.SyntaxToken localName) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.WithPrefix(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax? prefix) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.ColonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.Prefix.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken prefix, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.WithPrefix(Microsoft.CodeAnalysis.SyntaxToken prefix) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken prefix, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.WithPrefix(Microsoft.CodeAnalysis.SyntaxToken prefix) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.AddTextTokens(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.AddTextTokens(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.EndProcessingInstructionToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.StartProcessingInstructionToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.TextTokens.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken startProcessingInstructionToken, Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxTokenList textTokens, Microsoft.CodeAnalysis.SyntaxToken endProcessingInstructionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.WithEndProcessingInstructionToken(Microsoft.CodeAnalysis.SyntaxToken endProcessingInstructionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.WithStartProcessingInstructionToken(Microsoft.CodeAnalysis.SyntaxToken startProcessingInstructionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken startProcessingInstructionToken, Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxTokenList textTokens, Microsoft.CodeAnalysis.SyntaxToken endProcessingInstructionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.WithEndProcessingInstructionToken(Microsoft.CodeAnalysis.SyntaxToken endProcessingInstructionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.WithStartProcessingInstructionToken(Microsoft.CodeAnalysis.SyntaxToken startProcessingInstructionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.AddTextTokens(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.AddTextTokens(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.TextTokens.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxToken equalsToken, Microsoft.CodeAnalysis.SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.SyntaxTokenList textTokens, Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithEndQuoteToken(Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken equalsToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithStartQuoteToken(Microsoft.CodeAnalysis.SyntaxToken startQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken equalsToken, Microsoft.CodeAnalysis.SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.SyntaxTokenList textTokens, Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithEndQuoteToken(Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithEqualsToken(Microsoft.CodeAnalysis.SyntaxToken equalsToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithStartQuoteToken(Microsoft.CodeAnalysis.SyntaxToken startQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.AddTextTokens(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.AddTextTokens(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.TextTokens.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.Update(Microsoft.CodeAnalysis.SyntaxTokenList textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.WithTextTokens(Microsoft.CodeAnalysis.SyntaxTokenList textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.ReturnOrBreakKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken yieldKeyword, Microsoft.CodeAnalysis.SyntaxToken returnOrBreakKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken yieldKeyword, Microsoft.CodeAnalysis.SyntaxToken returnOrBreakKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithReturnOrBreakKeyword(Microsoft.CodeAnalysis.SyntaxToken returnOrBreakKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithYieldKeyword(Microsoft.CodeAnalysis.SyntaxToken yieldKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken yieldKeyword, Microsoft.CodeAnalysis.SyntaxToken returnOrBreakKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken yieldKeyword, Microsoft.CodeAnalysis.SyntaxToken returnOrBreakKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithReturnOrBreakKeyword(Microsoft.CodeAnalysis.SyntaxToken returnOrBreakKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.WithYieldKeyword(Microsoft.CodeAnalysis.SyntaxToken yieldKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.YieldKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.SyntaxExtensions
 Microsoft.CodeAnalysis.CSharp.SyntaxFactory
@@ -3213,2038 +3214,2038 @@ Microsoft.CodeAnalysis.CSharp.SyntaxKind.YieldKeyword = 8405 -> Microsoft.CodeAn
 Microsoft.CodeAnalysis.CSharp.SyntaxKind.YieldReturnStatement = 8806 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
 Microsoft.CodeAnalysis.CSharp.TypedConstantExtensions
 Microsoft.CodeAnalysis.CSharpExtensions
-override abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
+override abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
 override abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseFieldDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-override abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
+override abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
 override abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-override abstract Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
+override abstract Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
 override abstract Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-override Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.Equals(object obj) -> bool
+override Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.Equals(object? obj) -> bool
 override Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo.GetHashCode() -> int
-override Microsoft.CodeAnalysis.CSharp.Conversion.Equals(object obj) -> bool
+override Microsoft.CodeAnalysis.CSharp.Conversion.Equals(object? obj) -> bool
 override Microsoft.CodeAnalysis.CSharp.Conversion.GetHashCode() -> int
-override Microsoft.CodeAnalysis.CSharp.Conversion.ToString() -> string
-override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ClassifyCommonConversion(Microsoft.CodeAnalysis.ITypeSymbol source, Microsoft.CodeAnalysis.ITypeSymbol destination) -> Microsoft.CodeAnalysis.Operations.CommonConversion
-override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ContainsSymbolsWithName(string name, Microsoft.CodeAnalysis.SymbolFilter filter = Microsoft.CodeAnalysis.SymbolFilter.TypeAndMember, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> bool
-override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ContainsSymbolsWithName(System.Func<string, bool> predicate, Microsoft.CodeAnalysis.SymbolFilter filter = Microsoft.CodeAnalysis.SymbolFilter.TypeAndMember, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> bool
-override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.DirectiveReferences.get -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.MetadataReference>
-override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetDeclarationDiagnostics(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Diagnostic>
-override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetDiagnostics(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Diagnostic>
-override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetMethodBodyDiagnostics(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Diagnostic>
-override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetParseDiagnostics(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Diagnostic>
-override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetSymbolsWithName(string name, Microsoft.CodeAnalysis.SymbolFilter filter = Microsoft.CodeAnalysis.SymbolFilter.TypeAndMember, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.ISymbol>
-override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetSymbolsWithName(System.Func<string, bool> predicate, Microsoft.CodeAnalysis.SymbolFilter filter = Microsoft.CodeAnalysis.SymbolFilter.TypeAndMember, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.ISymbol>
+override Microsoft.CodeAnalysis.CSharp.Conversion.ToString() -> string!
+override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ClassifyCommonConversion(Microsoft.CodeAnalysis.ITypeSymbol! source, Microsoft.CodeAnalysis.ITypeSymbol! destination) -> Microsoft.CodeAnalysis.Operations.CommonConversion
+override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ContainsSymbolsWithName(string! name, Microsoft.CodeAnalysis.SymbolFilter filter = Microsoft.CodeAnalysis.SymbolFilter.TypeAndMember, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> bool
+override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ContainsSymbolsWithName(System.Func<string!, bool>! predicate, Microsoft.CodeAnalysis.SymbolFilter filter = Microsoft.CodeAnalysis.SymbolFilter.TypeAndMember, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> bool
+override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.DirectiveReferences.get -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.MetadataReference!>
+override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetDeclarationDiagnostics(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Diagnostic!>
+override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetDiagnostics(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Diagnostic!>
+override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetMethodBodyDiagnostics(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Diagnostic!>
+override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetParseDiagnostics(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Diagnostic!>
+override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetSymbolsWithName(string! name, Microsoft.CodeAnalysis.SymbolFilter filter = Microsoft.CodeAnalysis.SymbolFilter.TypeAndMember, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.ISymbol!>!
+override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetSymbolsWithName(System.Func<string!, bool>! predicate, Microsoft.CodeAnalysis.SymbolFilter filter = Microsoft.CodeAnalysis.SymbolFilter.TypeAndMember, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.ISymbol!>!
 override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.IsCaseSensitive.get -> bool
-override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Language.get -> string
-override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ReferencedAssemblyNames.get -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.AssemblyIdentity>
-override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ToMetadataReference(System.Collections.Immutable.ImmutableArray<string> aliases = default(System.Collections.Immutable.ImmutableArray<string>), bool embedInteropTypes = false) -> Microsoft.CodeAnalysis.CompilationReference
-override Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.Equals(object obj) -> bool
+override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Language.get -> string!
+override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ReferencedAssemblyNames.get -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.AssemblyIdentity!>!
+override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.ToMetadataReference(System.Collections.Immutable.ImmutableArray<string!> aliases = default(System.Collections.Immutable.ImmutableArray<string!>), bool embedInteropTypes = false) -> Microsoft.CodeAnalysis.CompilationReference!
+override Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.Equals(object? obj) -> bool
 override Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.GetHashCode() -> int
-override Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.Language.get -> string
+override Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.Language.get -> string!
 override Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.NullableContextOptions.get -> Microsoft.CodeAnalysis.NullableContextOptions
-override Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.CommonWithKind(Microsoft.CodeAnalysis.SourceCodeKind kind) -> Microsoft.CodeAnalysis.ParseOptions
-override Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.Equals(object obj) -> bool
-override Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.Features.get -> System.Collections.Generic.IReadOnlyDictionary<string, string>
+override Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.CommonWithKind(Microsoft.CodeAnalysis.SourceCodeKind kind) -> Microsoft.CodeAnalysis.ParseOptions!
+override Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.Equals(object? obj) -> bool
+override Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.Features.get -> System.Collections.Generic.IReadOnlyDictionary<string!, string!>!
 override Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.GetHashCode() -> int
-override Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.Language.get -> string
-override Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.PreprocessorSymbolNames.get -> System.Collections.Generic.IEnumerable<string>
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.Language.get -> string
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.Visit(Microsoft.CodeAnalysis.SyntaxNode node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAccessorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAnonymousObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArgument(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArrayRankSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArrowExpressionClause(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAssignmentExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttributeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttributeList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttributeTargetSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAwaitExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBaseExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBinaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBinaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBracketedArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBreakStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCastExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCatchClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCatchFilterClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCheckedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCheckedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitClassDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCompilationUnit(Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConstantPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConstructorConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConstructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConstructorInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitContinueStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConversionOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConversionOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCrefBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCrefParameter(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCrefParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDeclarationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDeclarationPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDefaultConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDefaultExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDefaultSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDefineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDestructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDiscardDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDiscardPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElementBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElifDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElseClause(Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElseDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEmptyStatement(Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEndIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEndRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEnumDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEnumMemberDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEqualsValueClause(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitErrorDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEventFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExternAliasDirective(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFinallyClause(Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFixedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitForEachVariableStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFromClause(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitGenericName(Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitGlobalStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitGotoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitGroupClause(Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIdentifierName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitImplicitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitImplicitElementAccess(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIncompleteMember(Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIndexerDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIndexerMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInitializerExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterfaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolatedStringExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolatedStringText(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolation(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolationAlignmentClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolationFormatClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitJoinClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitJoinIntoClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLabeledStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLetClause(Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLiteralExpression(Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLoadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLocalDeclarationStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLockStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitMakeRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitMemberAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitMemberBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitMethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNullableDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNullableType(Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOmittedArraySizeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOmittedTypeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOrderByClause(Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOrdering(Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParameter(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParenthesizedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParenthesizedVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPositionalPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPredefinedType(Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPropertyPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQueryBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQueryContinuation(Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQueryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRecordDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRecursivePattern(Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitReferenceDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRefType(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRefTypeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRefValueExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRelationalPattern(Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitReturnStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSelectClause(Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitShebangDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSimpleBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSingleVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSizeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSkippedTokensTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitStructDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSubpattern(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSwitchSection(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitThisExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitThrowExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitThrowStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTryStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTupleExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTupleType(Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUnaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUndefDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUnsafeStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitVariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitVariableDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitVarPattern(Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWhereClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWhileStatement(Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlCDataSection(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlComment(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlElementEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlPrefix(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlText(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitYieldStatement(Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetChangedSpans(Microsoft.CodeAnalysis.SyntaxTree oldTree) -> System.Collections.Generic.IList<Microsoft.CodeAnalysis.Text.TextSpan>
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetChanges(Microsoft.CodeAnalysis.SyntaxTree oldTree) -> System.Collections.Generic.IList<Microsoft.CodeAnalysis.Text.TextChange>
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxNode node) -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.Diagnostic>
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxNodeOrToken nodeOrToken) -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.Diagnostic>
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxToken token) -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.Diagnostic>
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxTrivia trivia) -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.Diagnostic>
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.Diagnostic>
+override Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.Language.get -> string!
+override Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.PreprocessorSymbolNames.get -> System.Collections.Generic.IEnumerable<string!>!
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.Language.get -> string!
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.Visit(Microsoft.CodeAnalysis.SyntaxNode? node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAccessorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAnonymousObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArgument(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArrayRankSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitArrowExpressionClause(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAssignmentExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttributeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttributeList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAttributeTargetSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitAwaitExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBaseExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBinaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBinaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBracketedArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitBreakStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCastExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCatchClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCatchFilterClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCheckedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCheckedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitClassDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCompilationUnit(Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConstantPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConstructorConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConstructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConstructorInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitContinueStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConversionOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitConversionOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCrefBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCrefParameter(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitCrefParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDeclarationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDeclarationPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDefaultConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDefaultExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDefaultSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDefineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDestructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDiscardDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDiscardPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitDoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElementBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElifDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElseClause(Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitElseDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEmptyStatement(Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEndIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEndRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEnumDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEnumMemberDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEqualsValueClause(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitErrorDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitEventFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExternAliasDirective(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFinallyClause(Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFixedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitForEachVariableStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFromClause(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitGenericName(Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitGlobalStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitGotoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitGroupClause(Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIdentifierName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitImplicitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitImplicitElementAccess(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIncompleteMember(Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIndexerDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIndexerMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInitializerExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterfaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolatedStringExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolatedStringText(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolation(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolationAlignmentClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInterpolationFormatClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitInvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitJoinClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitJoinIntoClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLabeledStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLetClause(Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLiteralExpression(Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLoadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLocalDeclarationStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLockStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitMakeRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitMemberAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitMemberBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitMethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNullableDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitNullableType(Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOmittedArraySizeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOmittedTypeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOrderByClause(Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitOrdering(Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParameter(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParenthesizedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitParenthesizedVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPositionalPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPredefinedType(Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPropertyPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQueryBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQueryContinuation(Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitQueryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRecordDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRecursivePattern(Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitReferenceDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRefType(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRefTypeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRefValueExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRelationalPattern(Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitReturnStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSelectClause(Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitShebangDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSimpleBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSingleVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSizeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSkippedTokensTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitStructDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSubpattern(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSwitchSection(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitThisExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitThrowExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitThrowStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTryStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTupleExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTupleType(Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTypePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUnaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUndefDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUnsafeStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitUsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitVariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitVariableDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitVarPattern(Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWhereClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWhileStatement(Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitWithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlCDataSection(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlComment(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlElementEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlPrefix(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlText(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitXmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitYieldStatement(Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetChangedSpans(Microsoft.CodeAnalysis.SyntaxTree! oldTree) -> System.Collections.Generic.IList<Microsoft.CodeAnalysis.Text.TextSpan>!
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetChanges(Microsoft.CodeAnalysis.SyntaxTree! oldTree) -> System.Collections.Generic.IList<Microsoft.CodeAnalysis.Text.TextChange>!
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxNode! node) -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.Diagnostic!>!
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxNodeOrToken nodeOrToken) -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.Diagnostic!>!
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxToken token) -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.Diagnostic!>!
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(Microsoft.CodeAnalysis.SyntaxTrivia trivia) -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.Diagnostic!>!
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetDiagnostics(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.Diagnostic!>!
 override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetLineSpan(Microsoft.CodeAnalysis.Text.TextSpan span, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.FileLinePositionSpan
 override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetLineVisibility(int position, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.LineVisibility
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetLocation(Microsoft.CodeAnalysis.Text.TextSpan span) -> Microsoft.CodeAnalysis.Location
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetLocation(Microsoft.CodeAnalysis.Text.TextSpan span) -> Microsoft.CodeAnalysis.Location!
 override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetMappedLineSpan(Microsoft.CodeAnalysis.Text.TextSpan span, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.FileLinePositionSpan
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetRootAsyncCore(System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task<Microsoft.CodeAnalysis.SyntaxNode>
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetRootCore(System.Threading.CancellationToken cancellationToken) -> Microsoft.CodeAnalysis.SyntaxNode
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetRootAsyncCore(System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task<Microsoft.CodeAnalysis.SyntaxNode!>!
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetRootCore(System.Threading.CancellationToken cancellationToken) -> Microsoft.CodeAnalysis.SyntaxNode!
 override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.HasHiddenRegions() -> bool
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxTree tree, bool topLevel = false) -> bool
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.OptionsCore.get -> Microsoft.CodeAnalysis.ParseOptions
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.TryGetRootCore(out Microsoft.CodeAnalysis.SyntaxNode root) -> bool
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.WithChangedText(Microsoft.CodeAnalysis.Text.SourceText newText) -> Microsoft.CodeAnalysis.SyntaxTree
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.DefaultVisit(Microsoft.CodeAnalysis.SyntaxNode node) -> void
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.Visit(Microsoft.CodeAnalysis.SyntaxNode node) -> void
-override Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.Equals(object obj) -> bool
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.IsEquivalentTo(Microsoft.CodeAnalysis.SyntaxTree! tree, bool topLevel = false) -> bool
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.OptionsCore.get -> Microsoft.CodeAnalysis.ParseOptions!
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.TryGetRootCore(out Microsoft.CodeAnalysis.SyntaxNode? root) -> bool
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.WithChangedText(Microsoft.CodeAnalysis.Text.SourceText! newText) -> Microsoft.CodeAnalysis.SyntaxTree!
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.DefaultVisit(Microsoft.CodeAnalysis.SyntaxNode! node) -> void
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.Visit(Microsoft.CodeAnalysis.SyntaxNode? node) -> void
+override Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.Equals(object? obj) -> bool
 override Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.GetHashCode() -> int
-override Microsoft.CodeAnalysis.CSharp.QueryClauseInfo.Equals(object obj) -> bool
+override Microsoft.CodeAnalysis.CSharp.QueryClauseInfo.Equals(object? obj) -> bool
 override Microsoft.CodeAnalysis.CSharp.QueryClauseInfo.GetHashCode() -> int
-override Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.AsyncKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Block.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Block.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax!
+override Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax?
 override Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-override Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.Arguments.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax.Arguments.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.EndOfDirectiveToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.HashToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax.IsActive.get -> bool
-override Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.Arguments.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.Parameters.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax.Arguments.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax.Parameters.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.ColonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax.Keyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.ColonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax.Keyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.BaseList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.BaseList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax?
 override Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.CloseBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.ConstraintClauses.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>
+override Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.ConstraintClauses.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!>
 override Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.Keyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.Members.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax>
+override Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.Members.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!>
 override Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
 override Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.OpenBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.TypeParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Body.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax.TypeParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Body.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax?
 override Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax!
 override Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Body.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Body.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax?
 override Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax!
 override Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.Parameters.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.Parameters.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax.Parameters.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax.Parameters.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.ColonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax.Keyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.EndOfDirectiveToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.HashToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax.IsActive.get -> bool
-override Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
+override Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
 override Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-override Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Body.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Body.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax?
+override Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax?
 override Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-override Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax!
 override Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.BranchTaken.get -> bool
-override Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.Condition.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.Condition.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 override Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.ConditionValue.get -> bool
 override Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.EndOfDirectiveToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.HashToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax.IsActive.get -> bool
-override Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.BranchTaken.get -> bool
 override Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.EndOfDirectiveToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.HashToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax.IsActive.get -> bool
-override Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.EndOfDirectiveToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.HashToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax.IsActive.get -> bool
-override Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.EndOfDirectiveToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.HashToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax.IsActive.get -> bool
-override Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.BaseList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.BaseList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax?
 override Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.CloseBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
 override Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.OpenBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
+override Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
 override Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-override Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.EndOfDirectiveToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.HashToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax.IsActive.get -> bool
-override Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.AccessorList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.ExplicitInterfaceSpecifier.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.AccessorList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax?
+override Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.ExplicitInterfaceSpecifier.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax?
 override Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-override Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.Declaration.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+override Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.Declaration.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax!
 override Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
 override Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.Declaration.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.Declaration.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax!
 override Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
 override Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
+override Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
 override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.AwaitKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.ForEachKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.InKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
+override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!
+override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
 override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.AwaitKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.ForEachKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.InKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
+override Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax.Statement.get -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!
+override Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
 override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
+override Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
 override Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-override Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.BranchTaken.get -> bool
-override Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.Condition.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.Condition.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 override Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.ConditionValue.get -> bool
 override Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.EndOfDirectiveToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.HashToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax.IsActive.get -> bool
-override Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax!
+override Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax?
 override Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax.NewKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
+override Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
 override Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-override Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AccessorList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.ExplicitInterfaceSpecifier.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AccessorList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax?
+override Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.ExplicitInterfaceSpecifier.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax?
 override Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-override Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.BaseList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+override Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.BaseList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax?
 override Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.CloseBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.ConstraintClauses.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>
+override Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.ConstraintClauses.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!>
 override Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.Keyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.Members.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax>
+override Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.Members.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!>
 override Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
 override Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.OpenBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.TypeParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax.TypeParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax?
+override Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.EndOfDirectiveToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.HashToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.IsActive.get -> bool
-override Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.EndOfDirectiveToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.HashToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax.IsActive.get -> bool
-override Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.Body.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.Body.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax?
+override Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax?
 override Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-override Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax!
 override Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
+override Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
 override Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-override Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.EndOfDirectiveToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.HashToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax.IsActive.get -> bool
-override Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax?
 override Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.NewKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Body.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Body.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax?
+override Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax?
 override Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-override Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax!
 override Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.Parameters.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
+override Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.Parameters.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
 override Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-override Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.ArrowToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AsyncKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Block.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Block.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax?
 override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.EndOfDirectiveToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.HashToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax.IsActive.get -> bool
-override Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.EndOfDirectiveToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.HashToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax.IsActive.get -> bool
-override Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.AccessorList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.ExplicitInterfaceSpecifier.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+override Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.AccessorList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax?
+override Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.ExplicitInterfaceSpecifier.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax?
 override Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-override Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.BaseList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+override Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.BaseList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax?
 override Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.CloseBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.ConstraintClauses.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>
+override Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.ConstraintClauses.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!>
 override Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Keyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Members.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax>
+override Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Members.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!>
 override Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
 override Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.OpenBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.TypeParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.TypeParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax?
+override Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.EndOfDirectiveToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.HashToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax.IsActive.get -> bool
-override Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.EndOfDirectiveToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.HashToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax.IsActive.get -> bool
-override Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.EndOfDirectiveToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.HashToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax.IsActive.get -> bool
-override Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+override Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.ArrowToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AsyncKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Block.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Block.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax?
+override Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.ExpressionBody.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax?
 override Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-override Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.BaseList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.BaseList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax?
 override Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.CloseBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.ConstraintClauses.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>
+override Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.ConstraintClauses.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!>
 override Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.Keyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.Members.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax>
+override Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.Members.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!>
 override Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
 override Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.OpenBraceToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.TypeParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax.TypeParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax?
 override Microsoft.CodeAnalysis.CSharp.Syntax.StructuredTriviaSyntax.ParentTrivia.get -> Microsoft.CodeAnalysis.SyntaxTrivia
-override Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.EndOfDirectiveToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.HashToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax.IsActive.get -> bool
-override Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.EndOfDirectiveToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.HashToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax.IsActive.get -> bool
-override Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.EndQuoteToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.EqualsToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax!
 override Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax.StartQuoteToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.EndQuoteToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.EqualsToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax!
 override Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax.StartQuoteToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.EndQuoteToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.EqualsToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax!
 override Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax.StartQuoteToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
 static Microsoft.CodeAnalysis.CSharp.Conversion.operator !=(Microsoft.CodeAnalysis.CSharp.Conversion left, Microsoft.CodeAnalysis.CSharp.Conversion right) -> bool
 static Microsoft.CodeAnalysis.CSharp.Conversion.operator ==(Microsoft.CodeAnalysis.CSharp.Conversion left, Microsoft.CodeAnalysis.CSharp.Conversion right) -> bool
-static Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.Default.get -> Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser
-static Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.ParseConditionalCompilationSymbols(string value, out System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.Diagnostic> diagnostics) -> System.Collections.Generic.IEnumerable<string>
-static Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.Script.get -> Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser
-static Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Create(string assemblyName, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxTree> syntaxTrees = null, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.MetadataReference> references = null, Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions options = null) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation
-static Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CreateScriptCompilation(string assemblyName, Microsoft.CodeAnalysis.SyntaxTree syntaxTree = null, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.MetadataReference> references = null, Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions options = null, Microsoft.CodeAnalysis.CSharp.CSharpCompilation previousScriptCompilation = null, System.Type returnType = null, System.Type globalsType = null) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation
-static Microsoft.CodeAnalysis.CSharp.CSharpDiagnosticFormatter.Instance.get -> Microsoft.CodeAnalysis.CSharp.CSharpDiagnosticFormatter
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeControlFlow(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax firstStatement, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax lastStatement) -> Microsoft.CodeAnalysis.ControlFlowAnalysis
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeControlFlow(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.ControlFlowAnalysis
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.DataFlowAnalysis
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax firstStatement, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax lastStatement) -> Microsoft.CodeAnalysis.DataFlowAnalysis
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.DataFlowAnalysis
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ClassifyConversion(this Microsoft.CodeAnalysis.Compilation compilation, Microsoft.CodeAnalysis.ITypeSymbol source, Microsoft.CodeAnalysis.ITypeSymbol destination) -> Microsoft.CodeAnalysis.CSharp.Conversion
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ClassifyConversion(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.ITypeSymbol destination, bool isExplicitInSource = false) -> Microsoft.CodeAnalysis.CSharp.Conversion
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ClassifyConversion(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.ITypeSymbol destination, bool isExplicitInSource = false) -> Microsoft.CodeAnalysis.CSharp.Conversion
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetAliasInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax nameSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IAliasSymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetAwaitExpressionInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax awaitExpression) -> Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetCollectionInitializerSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SymbolInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetCompilationUnitRoot(this Microsoft.CodeAnalysis.SyntaxTree tree, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetConstantValue(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.Optional<object>
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetConversion(this Microsoft.CodeAnalysis.Operations.IConversionOperation conversionExpression) -> Microsoft.CodeAnalysis.CSharp.Conversion
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetConversion(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.SyntaxNode expression, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.CSharp.Conversion
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IMethodSymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax declaratorSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.INamedTypeSymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax declaratorSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IPropertySymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax declaratorSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ISymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IMethodSymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ISymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.INamedTypeSymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax catchDeclaration, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ILocalSymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IMethodSymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.INamedTypeSymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IFieldSymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IEventSymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IAliasSymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax forEachStatement, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ILocalSymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IPropertySymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax node, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IRangeVariableSymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ILabelSymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ISymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.INamespaceSymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IParameterSymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IPropertySymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax queryClause, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IRangeVariableSymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax node, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IRangeVariableSymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax designationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ISymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ILabelSymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ISymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax declaratorSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.INamedTypeSymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax typeParameter, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ITypeParameterSymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IAliasSymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ISymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeconstructionInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax assignment) -> Microsoft.CodeAnalysis.CSharp.DeconstructionInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeconstructionInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax foreach) -> Microsoft.CodeAnalysis.CSharp.DeconstructionInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetFirstDirective(this Microsoft.CodeAnalysis.SyntaxNode node, System.Func<Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax, bool> predicate = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetForEachStatementInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax forEachStatement) -> Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetForEachStatementInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax forEachStatement) -> Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetInConversion(this Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation compoundAssignment) -> Microsoft.CodeAnalysis.CSharp.Conversion
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetIndexerGroup(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.IPropertySymbol>
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetLastDirective(this Microsoft.CodeAnalysis.SyntaxNode node, System.Func<Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax, bool> predicate = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetMemberGroup(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax attribute, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.ISymbol>
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetMemberGroup(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax initializer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.ISymbol>
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetMemberGroup(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.ISymbol>
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetOutConversion(this Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation compoundAssignment) -> Microsoft.CodeAnalysis.CSharp.Conversion
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetQueryClauseInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax node, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.CSharp.QueryClauseInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeAliasInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax nameSyntax, Microsoft.CodeAnalysis.SpeculativeBindingOption bindingOption) -> Microsoft.CodeAnalysis.IAliasSymbol
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeConversion(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SpeculativeBindingOption bindingOption) -> Microsoft.CodeAnalysis.CSharp.Conversion
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax attribute) -> Microsoft.CodeAnalysis.SymbolInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax constructorInitializer) -> Microsoft.CodeAnalysis.SymbolInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax expression, Microsoft.CodeAnalysis.SpeculativeBindingOption bindingOption) -> Microsoft.CodeAnalysis.SymbolInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SpeculativeBindingOption bindingOption) -> Microsoft.CodeAnalysis.SymbolInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax constructorInitializer) -> Microsoft.CodeAnalysis.SymbolInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeTypeInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SpeculativeBindingOption bindingOption) -> Microsoft.CodeAnalysis.TypeInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax attributeSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SymbolInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax constructorInitializer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SymbolInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax crefSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SymbolInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SymbolInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax node, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SymbolInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax constructorInitializer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SymbolInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax node, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SymbolInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetTypeInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax attributeSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.TypeInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetTypeInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax constructorInitializer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.TypeInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetTypeInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.TypeInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetTypeInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax node, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.TypeInfo
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Insert(this Microsoft.CodeAnalysis.SyntaxTokenList list, int index, params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.SyntaxTokenList
+static Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.Default.get -> Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser!
+static Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.ParseConditionalCompilationSymbols(string! value, out System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.Diagnostic!>! diagnostics) -> System.Collections.Generic.IEnumerable<string!>!
+static Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.Script.get -> Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser!
+static Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Create(string? assemblyName, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxTree!>? syntaxTrees = null, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.MetadataReference!>? references = null, Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions? options = null) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation!
+static Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CreateScriptCompilation(string! assemblyName, Microsoft.CodeAnalysis.SyntaxTree? syntaxTree = null, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.MetadataReference!>? references = null, Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions? options = null, Microsoft.CodeAnalysis.CSharp.CSharpCompilation? previousScriptCompilation = null, System.Type? returnType = null, System.Type? globalsType = null) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation!
+static Microsoft.CodeAnalysis.CSharp.CSharpDiagnosticFormatter.Instance.get -> Microsoft.CodeAnalysis.CSharp.CSharpDiagnosticFormatter!
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeControlFlow(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! firstStatement, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! lastStatement) -> Microsoft.CodeAnalysis.ControlFlowAnalysis?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeControlFlow(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.ControlFlowAnalysis?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.DataFlowAnalysis?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! firstStatement, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! lastStatement) -> Microsoft.CodeAnalysis.DataFlowAnalysis?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.DataFlowAnalysis?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ClassifyConversion(this Microsoft.CodeAnalysis.Compilation? compilation, Microsoft.CodeAnalysis.ITypeSymbol! source, Microsoft.CodeAnalysis.ITypeSymbol! destination) -> Microsoft.CodeAnalysis.CSharp.Conversion
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ClassifyConversion(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.ITypeSymbol! destination, bool isExplicitInSource = false) -> Microsoft.CodeAnalysis.CSharp.Conversion
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ClassifyConversion(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.ITypeSymbol! destination, bool isExplicitInSource = false) -> Microsoft.CodeAnalysis.CSharp.Conversion
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetAliasInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! nameSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IAliasSymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetAwaitExpressionInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax! awaitExpression) -> Microsoft.CodeAnalysis.CSharp.AwaitExpressionInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetCollectionInitializerSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SymbolInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetCompilationUnitRoot(this Microsoft.CodeAnalysis.SyntaxTree! tree, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax!
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetConstantValue(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.Optional<object!>
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetConversion(this Microsoft.CodeAnalysis.Operations.IConversionOperation! conversionExpression) -> Microsoft.CodeAnalysis.CSharp.Conversion
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetConversion(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.SyntaxNode! expression, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.CSharp.Conversion
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax! declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IMethodSymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax! declaratorSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.INamedTypeSymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax! declaratorSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IPropertySymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax! declaratorSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ISymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax! declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IMethodSymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.BasePropertyDeclarationSyntax! declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ISymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeDeclarationSyntax! declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.INamedTypeSymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax! catchDeclaration, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ILocalSymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax! declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IMethodSymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax! declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.INamedTypeSymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax! declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IFieldSymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax! declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IEventSymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax! declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IAliasSymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax! forEachStatement, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ILocalSymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax! declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IPropertySymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax! node, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IRangeVariableSymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax! declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ILabelSymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax! declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ISymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax! declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.INamespaceSymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax! declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IParameterSymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax! declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IPropertySymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax! queryClause, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IRangeVariableSymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax! node, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IRangeVariableSymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax! designationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ISymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax! declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ILabelSymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax! declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ISymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax! declaratorSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.INamedTypeSymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax! typeParameter, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ITypeParameterSymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax! declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IAliasSymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax! declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ISymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeconstructionInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax! assignment) -> Microsoft.CodeAnalysis.CSharp.DeconstructionInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeconstructionInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax! foreach) -> Microsoft.CodeAnalysis.CSharp.DeconstructionInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetFirstDirective(this Microsoft.CodeAnalysis.SyntaxNode! node, System.Func<Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax!, bool>? predicate = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetForEachStatementInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax! forEachStatement) -> Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetForEachStatementInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax! forEachStatement) -> Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetInConversion(this Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation! compoundAssignment) -> Microsoft.CodeAnalysis.CSharp.Conversion
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetIndexerGroup(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.IPropertySymbol!>
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetLastDirective(this Microsoft.CodeAnalysis.SyntaxNode! node, System.Func<Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax!, bool>? predicate = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetMemberGroup(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax! attribute, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.ISymbol!>
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetMemberGroup(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax! initializer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.ISymbol!>
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetMemberGroup(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.ISymbol!>
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetOutConversion(this Microsoft.CodeAnalysis.Operations.ICompoundAssignmentOperation! compoundAssignment) -> Microsoft.CodeAnalysis.CSharp.Conversion
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetQueryClauseInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax! node, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.CSharp.QueryClauseInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeAliasInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! nameSyntax, Microsoft.CodeAnalysis.SpeculativeBindingOption bindingOption) -> Microsoft.CodeAnalysis.IAliasSymbol?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeConversion(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SpeculativeBindingOption bindingOption) -> Microsoft.CodeAnalysis.CSharp.Conversion
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax! attribute) -> Microsoft.CodeAnalysis.SymbolInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax! constructorInitializer) -> Microsoft.CodeAnalysis.SymbolInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax! expression, Microsoft.CodeAnalysis.SpeculativeBindingOption bindingOption) -> Microsoft.CodeAnalysis.SymbolInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SpeculativeBindingOption bindingOption) -> Microsoft.CodeAnalysis.SymbolInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax! constructorInitializer) -> Microsoft.CodeAnalysis.SymbolInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeTypeInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SpeculativeBindingOption bindingOption) -> Microsoft.CodeAnalysis.TypeInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax! attributeSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SymbolInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax! constructorInitializer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SymbolInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax! crefSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SymbolInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SymbolInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax! node, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SymbolInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax! constructorInitializer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SymbolInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax! node, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SymbolInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetTypeInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax! attributeSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.TypeInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetTypeInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax! constructorInitializer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.TypeInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetTypeInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.TypeInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetTypeInfo(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax! node, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.TypeInfo
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Insert(this Microsoft.CodeAnalysis.SyntaxTokenList list, int index, params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.SyntaxTokenList
 static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.IsContextualKeyword(this Microsoft.CodeAnalysis.SyntaxToken token) -> bool
 static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.IsKeyword(this Microsoft.CodeAnalysis.SyntaxToken token) -> bool
 static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.IsReservedKeyword(this Microsoft.CodeAnalysis.SyntaxToken token) -> bool
 static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.IsVerbatimIdentifier(this Microsoft.CodeAnalysis.SyntaxToken token) -> bool
 static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.IsVerbatimStringLiteral(this Microsoft.CodeAnalysis.SyntaxToken token) -> bool
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Kind(this Microsoft.CodeAnalysis.SyntaxNode node) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Kind(this Microsoft.CodeAnalysis.SyntaxNode! node) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
 static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Kind(this Microsoft.CodeAnalysis.SyntaxNodeOrToken nodeOrToken) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
 static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Kind(this Microsoft.CodeAnalysis.SyntaxToken token) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
 static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Kind(this Microsoft.CodeAnalysis.SyntaxTrivia trivia) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
 static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ReplaceTrivia(this Microsoft.CodeAnalysis.SyntaxToken token, Microsoft.CodeAnalysis.SyntaxTrivia oldTrivia, Microsoft.CodeAnalysis.SyntaxTrivia newTrivia) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ReplaceTrivia(this Microsoft.CodeAnalysis.SyntaxToken token, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxTrivia> trivia, System.Func<Microsoft.CodeAnalysis.SyntaxTrivia, Microsoft.CodeAnalysis.SyntaxTrivia, Microsoft.CodeAnalysis.SyntaxTrivia> computeReplacementTrivia) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, out Microsoft.CodeAnalysis.SemanticModel speculativeModel) -> bool
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax attribute, out Microsoft.CodeAnalysis.SemanticModel speculativeModel) -> bool
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax constructorInitializer, out Microsoft.CodeAnalysis.SemanticModel speculativeModel) -> bool
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax crefSyntax, out Microsoft.CodeAnalysis.SemanticModel speculativeModel) -> bool
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax initializer, out Microsoft.CodeAnalysis.SemanticModel speculativeModel) -> bool
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax constructorInitializer, out Microsoft.CodeAnalysis.SemanticModel speculativeModel) -> bool
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement, out Microsoft.CodeAnalysis.SemanticModel speculativeModel) -> bool
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, out Microsoft.CodeAnalysis.SemanticModel speculativeModel, Microsoft.CodeAnalysis.SpeculativeBindingOption bindingOption = Microsoft.CodeAnalysis.SpeculativeBindingOption.BindAsExpression) -> bool
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModelForMethodBody(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax accessor, out Microsoft.CodeAnalysis.SemanticModel speculativeModel) -> bool
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModelForMethodBody(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax method, out Microsoft.CodeAnalysis.SemanticModel speculativeModel) -> bool
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.ReplaceTrivia(this Microsoft.CodeAnalysis.SyntaxToken token, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxTrivia>! trivia, System.Func<Microsoft.CodeAnalysis.SyntaxTrivia, Microsoft.CodeAnalysis.SyntaxTrivia, Microsoft.CodeAnalysis.SyntaxTrivia>! computeReplacementTrivia) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax! expressionBody, out Microsoft.CodeAnalysis.SemanticModel? speculativeModel) -> bool
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax! attribute, out Microsoft.CodeAnalysis.SemanticModel? speculativeModel) -> bool
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax! constructorInitializer, out Microsoft.CodeAnalysis.SemanticModel? speculativeModel) -> bool
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax! crefSyntax, out Microsoft.CodeAnalysis.SemanticModel? speculativeModel) -> bool
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax! initializer, out Microsoft.CodeAnalysis.SemanticModel? speculativeModel) -> bool
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax! constructorInitializer, out Microsoft.CodeAnalysis.SemanticModel? speculativeModel) -> bool
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement, out Microsoft.CodeAnalysis.SemanticModel? speculativeModel) -> bool
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, out Microsoft.CodeAnalysis.SemanticModel? speculativeModel, Microsoft.CodeAnalysis.SpeculativeBindingOption bindingOption = Microsoft.CodeAnalysis.SpeculativeBindingOption.BindAsExpression) -> bool
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModelForMethodBody(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax! accessor, out Microsoft.CodeAnalysis.SemanticModel? speculativeModel) -> bool
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModelForMethodBody(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.BaseMethodDeclarationSyntax! method, out Microsoft.CodeAnalysis.SemanticModel? speculativeModel) -> bool
 static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.VarianceKindFromToken(this Microsoft.CodeAnalysis.SyntaxToken node) -> Microsoft.CodeAnalysis.VarianceKind
-static Microsoft.CodeAnalysis.CSharp.CSharpFileSystemExtensions.Emit(this Microsoft.CodeAnalysis.CSharp.CSharpCompilation compilation, string outputPath, string pdbPath = null, string xmlDocumentationPath = null, string win32ResourcesPath = null, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.ResourceDescription> manifestResources = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.Emit.EmitResult
-static Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.Create(params Microsoft.CodeAnalysis.ISourceGenerator[] generators) -> Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver
+static Microsoft.CodeAnalysis.CSharp.CSharpFileSystemExtensions.Emit(this Microsoft.CodeAnalysis.CSharp.CSharpCompilation! compilation, string! outputPath, string? pdbPath = null, string? xmlDocumentationPath = null, string? win32ResourcesPath = null, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.ResourceDescription!>? manifestResources = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.Emit.EmitResult!
+static Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.Create(params Microsoft.CodeAnalysis.ISourceGenerator![]! generators) -> Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver!
 static Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.Create(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.ISourceGenerator> generators, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.AdditionalText> additionalTexts = null, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions parseOptions = null, Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider optionsProvider = null) -> Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver
-static Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.Default.get -> Microsoft.CodeAnalysis.CSharp.CSharpParseOptions
-static Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.DeserializeFrom(System.IO.Stream stream, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SyntaxNode
-static Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.Create(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode root, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions options = null, string path = "", System.Text.Encoding encoding = null) -> Microsoft.CodeAnalysis.SyntaxTree
-static Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.Create(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode root, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions options, string path, System.Text.Encoding encoding, System.Collections.Immutable.ImmutableDictionary<string, Microsoft.CodeAnalysis.ReportDiagnostic> diagnosticOptions) -> Microsoft.CodeAnalysis.SyntaxTree
-static Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.Create(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode root, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions options, string path, System.Text.Encoding encoding, System.Collections.Immutable.ImmutableDictionary<string, Microsoft.CodeAnalysis.ReportDiagnostic> diagnosticOptions, bool? isGeneratedCode) -> Microsoft.CodeAnalysis.SyntaxTree
-static Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(Microsoft.CodeAnalysis.Text.SourceText text, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions options = null, string path = "", System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SyntaxTree
-static Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(Microsoft.CodeAnalysis.Text.SourceText text, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions options, string path, System.Collections.Immutable.ImmutableDictionary<string, Microsoft.CodeAnalysis.ReportDiagnostic> diagnosticOptions, bool? isGeneratedCode, System.Threading.CancellationToken cancellationToken) -> Microsoft.CodeAnalysis.SyntaxTree
-static Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(Microsoft.CodeAnalysis.Text.SourceText text, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions options, string path, System.Collections.Immutable.ImmutableDictionary<string, Microsoft.CodeAnalysis.ReportDiagnostic> diagnosticOptions, System.Threading.CancellationToken cancellationToken) -> Microsoft.CodeAnalysis.SyntaxTree
-static Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(string text, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions options = null, string path = "", System.Text.Encoding encoding = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SyntaxTree
-static Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(string text, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions options, string path, System.Text.Encoding encoding, System.Collections.Immutable.ImmutableDictionary<string, Microsoft.CodeAnalysis.ReportDiagnostic> diagnosticOptions, bool? isGeneratedCode, System.Threading.CancellationToken cancellationToken) -> Microsoft.CodeAnalysis.SyntaxTree
-static Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(string text, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions options, string path, System.Text.Encoding encoding, System.Collections.Immutable.ImmutableDictionary<string, Microsoft.CodeAnalysis.ReportDiagnostic> diagnosticOptions, System.Threading.CancellationToken cancellationToken) -> Microsoft.CodeAnalysis.SyntaxTree
+static Microsoft.CodeAnalysis.CSharp.CSharpParseOptions.Default.get -> Microsoft.CodeAnalysis.CSharp.CSharpParseOptions!
+static Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.DeserializeFrom(System.IO.Stream! stream, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SyntaxNode!
+static Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.Create(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode! root, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions? options = null, string! path = "", System.Text.Encoding? encoding = null) -> Microsoft.CodeAnalysis.SyntaxTree!
+static Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.Create(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode! root, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions? options, string! path, System.Text.Encoding? encoding, System.Collections.Immutable.ImmutableDictionary<string!, Microsoft.CodeAnalysis.ReportDiagnostic>? diagnosticOptions) -> Microsoft.CodeAnalysis.SyntaxTree!
+static Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.Create(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode! root, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions? options, string! path, System.Text.Encoding? encoding, System.Collections.Immutable.ImmutableDictionary<string!, Microsoft.CodeAnalysis.ReportDiagnostic>? diagnosticOptions, bool? isGeneratedCode) -> Microsoft.CodeAnalysis.SyntaxTree!
+static Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(Microsoft.CodeAnalysis.Text.SourceText! text, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions? options = null, string! path = "", System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SyntaxTree!
+static Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(Microsoft.CodeAnalysis.Text.SourceText! text, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions? options, string! path, System.Collections.Immutable.ImmutableDictionary<string!, Microsoft.CodeAnalysis.ReportDiagnostic>? diagnosticOptions, bool? isGeneratedCode, System.Threading.CancellationToken cancellationToken) -> Microsoft.CodeAnalysis.SyntaxTree!
+static Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(Microsoft.CodeAnalysis.Text.SourceText! text, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions? options, string! path, System.Collections.Immutable.ImmutableDictionary<string!, Microsoft.CodeAnalysis.ReportDiagnostic>? diagnosticOptions, System.Threading.CancellationToken cancellationToken) -> Microsoft.CodeAnalysis.SyntaxTree!
+static Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(string! text, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions? options = null, string! path = "", System.Text.Encoding? encoding = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SyntaxTree!
+static Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(string! text, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions? options, string! path, System.Text.Encoding? encoding, System.Collections.Immutable.ImmutableDictionary<string!, Microsoft.CodeAnalysis.ReportDiagnostic>? diagnosticOptions, bool? isGeneratedCode, System.Threading.CancellationToken cancellationToken) -> Microsoft.CodeAnalysis.SyntaxTree!
+static Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(string! text, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions? options, string! path, System.Text.Encoding? encoding, System.Collections.Immutable.ImmutableDictionary<string!, Microsoft.CodeAnalysis.ReportDiagnostic>? diagnosticOptions, System.Threading.CancellationToken cancellationToken) -> Microsoft.CodeAnalysis.SyntaxTree!
 static Microsoft.CodeAnalysis.CSharp.LanguageVersionFacts.MapSpecifiedToEffectiveVersion(this Microsoft.CodeAnalysis.CSharp.LanguageVersion version) -> Microsoft.CodeAnalysis.CSharp.LanguageVersion
-static Microsoft.CodeAnalysis.CSharp.LanguageVersionFacts.ToDisplayString(this Microsoft.CodeAnalysis.CSharp.LanguageVersion version) -> string
-static Microsoft.CodeAnalysis.CSharp.LanguageVersionFacts.TryParse(string version, out Microsoft.CodeAnalysis.CSharp.LanguageVersion result) -> bool
-static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.FormatLiteral(char c, bool quote) -> string
-static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.FormatLiteral(string value, bool quote) -> string
-static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.FormatPrimitive(object obj, bool quoteStrings, bool useHexadecimalNumbers) -> string
-static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayParts(Microsoft.CodeAnalysis.ISymbol symbol, Microsoft.CodeAnalysis.SymbolDisplayFormat format = null) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.SymbolDisplayPart>
-static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayParts(Microsoft.CodeAnalysis.ITypeSymbol symbol, Microsoft.CodeAnalysis.NullableAnnotation nullableAnnotation, Microsoft.CodeAnalysis.SymbolDisplayFormat format = null) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.SymbolDisplayPart>
-static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayParts(Microsoft.CodeAnalysis.ITypeSymbol symbol, Microsoft.CodeAnalysis.NullableFlowState nullableFlowState, Microsoft.CodeAnalysis.SymbolDisplayFormat format = null) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.SymbolDisplayPart>
-static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayString(Microsoft.CodeAnalysis.ISymbol symbol, Microsoft.CodeAnalysis.SymbolDisplayFormat format = null) -> string
-static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayString(Microsoft.CodeAnalysis.ITypeSymbol symbol, Microsoft.CodeAnalysis.NullableAnnotation nullableAnnotation, Microsoft.CodeAnalysis.SymbolDisplayFormat format = null) -> string
-static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayString(Microsoft.CodeAnalysis.ITypeSymbol symbol, Microsoft.CodeAnalysis.NullableFlowState nullableFlowState, Microsoft.CodeAnalysis.SymbolDisplayFormat format = null) -> string
-static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayParts(Microsoft.CodeAnalysis.ISymbol symbol, Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.SymbolDisplayFormat format = null) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.SymbolDisplayPart>
-static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayParts(Microsoft.CodeAnalysis.ITypeSymbol symbol, Microsoft.CodeAnalysis.NullableAnnotation nullableAnnotation, Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.SymbolDisplayFormat format = null) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.SymbolDisplayPart>
-static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayParts(Microsoft.CodeAnalysis.ITypeSymbol symbol, Microsoft.CodeAnalysis.NullableFlowState nullableFlowState, Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.SymbolDisplayFormat format = null) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.SymbolDisplayPart>
-static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayString(Microsoft.CodeAnalysis.ISymbol symbol, Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.SymbolDisplayFormat format = null) -> string
-static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayString(Microsoft.CodeAnalysis.ITypeSymbol symbol, Microsoft.CodeAnalysis.NullableAnnotation nullableAnnotation, Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.SymbolDisplayFormat format = null) -> string
-static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayString(Microsoft.CodeAnalysis.ITypeSymbol symbol, Microsoft.CodeAnalysis.NullableFlowState nullableFlowState, Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.SymbolDisplayFormat format = null) -> string
-static Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.NormalizeWhitespace(this Microsoft.CodeAnalysis.SyntaxToken token, string indentation = "    ", string eol = "\r\n", bool elasticTrivia = false) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.NormalizeWhitespace(this Microsoft.CodeAnalysis.SyntaxToken token, string indentation, bool elasticTrivia) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.NormalizeWhitespace(this Microsoft.CodeAnalysis.SyntaxTriviaList list, string indentation = "    ", string eol = "\r\n", bool elasticTrivia = false) -> Microsoft.CodeAnalysis.SyntaxTriviaList
-static Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.NormalizeWhitespace(this Microsoft.CodeAnalysis.SyntaxTriviaList list, string indentation, bool elasticTrivia) -> Microsoft.CodeAnalysis.SyntaxTriviaList
-static Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.ToSyntaxTriviaList(this System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxTrivia> sequence) -> Microsoft.CodeAnalysis.SyntaxTriviaList
-static Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.Update(this Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax syntax, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken thisKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.Update(this Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax syntax, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.Update(this Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax syntax, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.WithIdentifier(this Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax simpleName, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorList(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax> accessors = default(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorList(Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax> accessors, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax alias, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax alias, Microsoft.CodeAnalysis.SyntaxToken colonColonToken, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AliasQualifiedName(string alias, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression() -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode body) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode body) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode body) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousObjectCreationExpression(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax> initializers = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousObjectCreationExpression(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax> initializers, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax nameEquals, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent(Microsoft.CodeAnalysis.SyntaxNode oldNode, Microsoft.CodeAnalysis.SyntaxNode newNode, bool topLevel) -> bool
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent(Microsoft.CodeAnalysis.SyntaxNode oldNode, Microsoft.CodeAnalysis.SyntaxNode newNode, System.Func<Microsoft.CodeAnalysis.CSharp.SyntaxKind, bool> ignoreChildNode = null) -> bool
+static Microsoft.CodeAnalysis.CSharp.LanguageVersionFacts.ToDisplayString(this Microsoft.CodeAnalysis.CSharp.LanguageVersion version) -> string!
+static Microsoft.CodeAnalysis.CSharp.LanguageVersionFacts.TryParse(string? version, out Microsoft.CodeAnalysis.CSharp.LanguageVersion result) -> bool
+static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.FormatLiteral(char c, bool quote) -> string!
+static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.FormatLiteral(string! value, bool quote) -> string!
+static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.FormatPrimitive(object! obj, bool quoteStrings, bool useHexadecimalNumbers) -> string!
+static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayParts(Microsoft.CodeAnalysis.ISymbol! symbol, Microsoft.CodeAnalysis.SymbolDisplayFormat? format = null) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.SymbolDisplayPart>
+static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayParts(Microsoft.CodeAnalysis.ITypeSymbol! symbol, Microsoft.CodeAnalysis.NullableAnnotation nullableAnnotation, Microsoft.CodeAnalysis.SymbolDisplayFormat? format = null) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.SymbolDisplayPart>
+static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayParts(Microsoft.CodeAnalysis.ITypeSymbol! symbol, Microsoft.CodeAnalysis.NullableFlowState nullableFlowState, Microsoft.CodeAnalysis.SymbolDisplayFormat? format = null) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.SymbolDisplayPart>
+static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayString(Microsoft.CodeAnalysis.ISymbol! symbol, Microsoft.CodeAnalysis.SymbolDisplayFormat? format = null) -> string!
+static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayString(Microsoft.CodeAnalysis.ITypeSymbol! symbol, Microsoft.CodeAnalysis.NullableAnnotation nullableAnnotation, Microsoft.CodeAnalysis.SymbolDisplayFormat? format = null) -> string!
+static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToDisplayString(Microsoft.CodeAnalysis.ITypeSymbol! symbol, Microsoft.CodeAnalysis.NullableFlowState nullableFlowState, Microsoft.CodeAnalysis.SymbolDisplayFormat? format = null) -> string!
+static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayParts(Microsoft.CodeAnalysis.ISymbol! symbol, Microsoft.CodeAnalysis.SemanticModel! semanticModel, int position, Microsoft.CodeAnalysis.SymbolDisplayFormat? format = null) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.SymbolDisplayPart>
+static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayParts(Microsoft.CodeAnalysis.ITypeSymbol! symbol, Microsoft.CodeAnalysis.NullableAnnotation nullableAnnotation, Microsoft.CodeAnalysis.SemanticModel! semanticModel, int position, Microsoft.CodeAnalysis.SymbolDisplayFormat? format = null) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.SymbolDisplayPart>
+static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayParts(Microsoft.CodeAnalysis.ITypeSymbol! symbol, Microsoft.CodeAnalysis.NullableFlowState nullableFlowState, Microsoft.CodeAnalysis.SemanticModel! semanticModel, int position, Microsoft.CodeAnalysis.SymbolDisplayFormat? format = null) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.SymbolDisplayPart>
+static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayString(Microsoft.CodeAnalysis.ISymbol! symbol, Microsoft.CodeAnalysis.SemanticModel! semanticModel, int position, Microsoft.CodeAnalysis.SymbolDisplayFormat? format = null) -> string!
+static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayString(Microsoft.CodeAnalysis.ITypeSymbol! symbol, Microsoft.CodeAnalysis.NullableAnnotation nullableAnnotation, Microsoft.CodeAnalysis.SemanticModel! semanticModel, int position, Microsoft.CodeAnalysis.SymbolDisplayFormat? format = null) -> string!
+static Microsoft.CodeAnalysis.CSharp.SymbolDisplay.ToMinimalDisplayString(Microsoft.CodeAnalysis.ITypeSymbol! symbol, Microsoft.CodeAnalysis.NullableFlowState nullableFlowState, Microsoft.CodeAnalysis.SemanticModel! semanticModel, int position, Microsoft.CodeAnalysis.SymbolDisplayFormat? format = null) -> string!
+static Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.NormalizeWhitespace(this Microsoft.CodeAnalysis.SyntaxToken token, string! indentation = "    ", string! eol = "\r\n", bool elasticTrivia = false) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.NormalizeWhitespace(this Microsoft.CodeAnalysis.SyntaxToken token, string! indentation, bool elasticTrivia) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.NormalizeWhitespace(this Microsoft.CodeAnalysis.SyntaxTriviaList list, string! indentation = "    ", string! eol = "\r\n", bool elasticTrivia = false) -> Microsoft.CodeAnalysis.SyntaxTriviaList
+static Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.NormalizeWhitespace(this Microsoft.CodeAnalysis.SyntaxTriviaList list, string! indentation, bool elasticTrivia) -> Microsoft.CodeAnalysis.SyntaxTriviaList
+static Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.ToSyntaxTriviaList(this System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxTrivia>! sequence) -> Microsoft.CodeAnalysis.SyntaxTriviaList
+static Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.Update(this Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax! syntax, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax! explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken thisKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax! accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.Update(this Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax! syntax, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax! explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax! typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.Update(this Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax! syntax, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxExtensions.WithIdentifier(this Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax! simpleName, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax! expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax! expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorList(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!> accessors = default(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorList(Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax!> accessors, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! alias, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! alias, Microsoft.CodeAnalysis.SyntaxToken colonColonToken, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AliasQualifiedName(string! alias, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax!
+~static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression() -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax? parameterList, Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax!
+~static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousMethodExpression(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax? parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousObjectCreationExpression(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax!> initializers = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousObjectCreationExpression(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax!> initializers, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax? nameEquals, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent(Microsoft.CodeAnalysis.SyntaxNode? oldNode, Microsoft.CodeAnalysis.SyntaxNode? newNode, bool topLevel) -> bool
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent(Microsoft.CodeAnalysis.SyntaxNode? oldNode, Microsoft.CodeAnalysis.SyntaxNode? newNode, System.Func<Microsoft.CodeAnalysis.CSharp.SyntaxKind, bool>? ignoreChildNode = null) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent(Microsoft.CodeAnalysis.SyntaxToken oldToken, Microsoft.CodeAnalysis.SyntaxToken newToken) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent(Microsoft.CodeAnalysis.SyntaxTokenList oldList, Microsoft.CodeAnalysis.SyntaxTokenList newList) -> bool
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent(Microsoft.CodeAnalysis.SyntaxTree oldTree, Microsoft.CodeAnalysis.SyntaxTree newTree, bool topLevel) -> bool
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent<TNode>(Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode> oldList, Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode> newList, bool topLevel) -> bool
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent<TNode>(Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode> oldList, Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode> newList, System.Func<Microsoft.CodeAnalysis.CSharp.SyntaxKind, bool> ignoreChildNode = null) -> bool
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent<TNode>(Microsoft.CodeAnalysis.SyntaxList<TNode> oldList, Microsoft.CodeAnalysis.SyntaxList<TNode> newList, bool topLevel) -> bool
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent<TNode>(Microsoft.CodeAnalysis.SyntaxList<TNode> oldList, Microsoft.CodeAnalysis.SyntaxList<TNode> newList, System.Func<Microsoft.CodeAnalysis.CSharp.SyntaxKind, bool> ignoreChildNode = null) -> bool
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Argument(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Argument(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax nameColon, Microsoft.CodeAnalysis.SyntaxToken refKindKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArgumentList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax> arguments = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArgumentList(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax> arguments, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayRankSpecifier(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> sizes = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayRankSpecifier(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> sizes, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax elementType) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax elementType, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax> rankSpecifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrowExpressionClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrowExpressionClause(Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AssignmentExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax left, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax right) -> Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AssignmentExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax left, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax right) -> Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Attribute(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Attribute(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax nameEquals, Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax nameColon, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeArgumentList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax> arguments = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeArgumentList(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax> arguments, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax target, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax> attributes) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax> attributes = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeList(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax target, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax> attributes, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeTargetSpecifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeTargetSpecifier(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AwaitExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AwaitExpression(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BadDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BadDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken identifier, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BadToken(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string text, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BaseExpression() -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BaseExpression(Microsoft.CodeAnalysis.SyntaxToken token) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BaseList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax> types = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BaseList(Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax> types) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax left, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax right) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax left, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax right) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryPattern(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax left, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax right) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryPattern(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax left, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax right) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax> statements) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax> statements, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax> statements = default(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax> statements, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[] statements) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax> statements) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BracketedArgumentList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax> arguments = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BracketedArgumentList(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax> arguments, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BracketedParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax> parameters = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BracketedParameterList(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax> parameters, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BreakStatement() -> Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BreakStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BreakStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken breakKeyword, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BreakStatement(Microsoft.CodeAnalysis.SyntaxToken breakKeyword, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent(Microsoft.CodeAnalysis.SyntaxTree? oldTree, Microsoft.CodeAnalysis.SyntaxTree? newTree, bool topLevel) -> bool
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent<TNode>(Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode!> oldList, Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode!> newList, bool topLevel) -> bool
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent<TNode>(Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode!> oldList, Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode!> newList, System.Func<Microsoft.CodeAnalysis.CSharp.SyntaxKind, bool>? ignoreChildNode = null) -> bool
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent<TNode>(Microsoft.CodeAnalysis.SyntaxList<TNode!> oldList, Microsoft.CodeAnalysis.SyntaxList<TNode!> newList, bool topLevel) -> bool
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AreEquivalent<TNode>(Microsoft.CodeAnalysis.SyntaxList<TNode!> oldList, Microsoft.CodeAnalysis.SyntaxList<TNode!> newList, System.Func<Microsoft.CodeAnalysis.CSharp.SyntaxKind, bool>? ignoreChildNode = null) -> bool
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Argument(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Argument(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax? nameColon, Microsoft.CodeAnalysis.SyntaxToken refKindKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArgumentList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!> arguments = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArgumentList(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!> arguments, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayRankSpecifier(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> sizes = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayRankSpecifier(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> sizes, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! elementType) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! elementType, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax!> rankSpecifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrowExpressionClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ArrowExpressionClause(Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AssignmentExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! left, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! right) -> Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AssignmentExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! left, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! right) -> Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Attribute(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Attribute(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name, Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax? argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax? nameEquals, Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax? nameColon, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeArgumentList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax!> arguments = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeArgumentList(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax!> arguments, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax? target, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax!> attributes) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax!> attributes = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeList(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax? target, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax!> attributes, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeTargetSpecifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AttributeTargetSpecifier(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AwaitExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AwaitExpression(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BadDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BadDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken identifier, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BadToken(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string! text, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BaseExpression() -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BaseExpression(Microsoft.CodeAnalysis.SyntaxToken token) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BaseList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax!> types = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BaseList(Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax!> types) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! left, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! right) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! left, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! right) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryPattern(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! left, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! right) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryPattern(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! left, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! right) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!> statements) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!> statements, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!> statements = default(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!> statements, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax![]! statements) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Block(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!>! statements) -> Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BracketedArgumentList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!> arguments = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BracketedArgumentList(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!> arguments, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BracketedParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!> parameters = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BracketedParameterList(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!> parameters, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BreakStatement() -> Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BreakStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BreakStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken breakKeyword, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BreakStatement(Microsoft.CodeAnalysis.SyntaxToken breakKeyword, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax!
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CarriageReturn.get -> Microsoft.CodeAnalysis.SyntaxTrivia
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CarriageReturnLineFeed.get -> Microsoft.CodeAnalysis.SyntaxTrivia
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern, Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax whenClause, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CasePatternSwitchLabel(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern, Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax whenClause, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax value) -> Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax value, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CaseSwitchLabel(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax value, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CastExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CastExpression(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchClause() -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax declaration, Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax filter, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchClause(Microsoft.CodeAnalysis.SyntaxToken catchKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax declaration, Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax filter, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchDeclaration(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchFilterClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax filterExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchFilterClause(Microsoft.CodeAnalysis.SyntaxToken whenKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax filterExpression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(string identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken classOrStructKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken classOrStructKeyword, Microsoft.CodeAnalysis.SyntaxToken questionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Comment(string text) -> Microsoft.CodeAnalysis.SyntaxTrivia
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CompilationUnit() -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CompilationUnit(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CompilationUnit(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, Microsoft.CodeAnalysis.SyntaxToken endOfFileToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax whenNotNull) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax whenNotNull) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax whenTrue, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax whenFalse) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SyntaxToken questionToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax whenTrue, Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax whenFalse) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstantPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorConstraint() -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorConstraint(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax initializer, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax initializer, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax initializer, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax initializer, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax initializer, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax initializer, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(string identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorInitializer(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorInitializer(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.SyntaxToken thisOrBaseKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ContinueStatement() -> Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ContinueStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ContinueStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken continueKeyword, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ContinueStatement(Microsoft.CodeAnalysis.SyntaxToken continueKeyword, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefBracketedParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax> parameters = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefBracketedParameterList(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax> parameters, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameter(Microsoft.CodeAnalysis.SyntaxToken refKindKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax> parameters = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameterList(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax> parameters, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DeclarationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DeclarationPattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultConstraint() -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultConstraint(Microsoft.CodeAnalysis.SyntaxToken defaultKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultExpression(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultSwitchLabel() -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultSwitchLabel(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultSwitchLabel(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken defineKeyword, Microsoft.CodeAnalysis.SyntaxToken name, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken name, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefineDirectiveTrivia(string name, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, string identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DelegateDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DelegateDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken tildeToken, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken tildeToken, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken tildeToken, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(string identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DisabledText(string text) -> Microsoft.CodeAnalysis.SyntaxTrivia
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DiscardDesignation() -> Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DiscardDesignation(Microsoft.CodeAnalysis.SyntaxToken underscoreToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DiscardPattern() -> Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DiscardPattern(Microsoft.CodeAnalysis.SyntaxToken underscoreToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DocumentationComment(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] content) -> Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DocumentationCommentExterior(string text) -> Microsoft.CodeAnalysis.SyntaxTrivia
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content = default(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content, Microsoft.CodeAnalysis.SyntaxToken endOfComment) -> Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DoStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DoStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken doKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement, Microsoft.CodeAnalysis.SyntaxToken whileKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DoStatement(Microsoft.CodeAnalysis.SyntaxToken doKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement, Microsoft.CodeAnalysis.SyntaxToken whileKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern, Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax? whenClause, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CasePatternSwitchLabel(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern, Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax? whenClause, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! value) -> Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! value, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CaseSwitchLabel(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! value, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CastExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CastExpression(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchClause() -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax? declaration, Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax? filter, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchClause(Microsoft.CodeAnalysis.SyntaxToken catchKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax? declaration, Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax? filter, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchDeclaration(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchFilterClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! filterExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CatchFilterClause(Microsoft.CodeAnalysis.SyntaxToken whenKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! filterExpression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CheckedStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block) -> Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassDeclaration(string! identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken classOrStructKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken classOrStructKeyword, Microsoft.CodeAnalysis.SyntaxToken questionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Comment(string! text) -> Microsoft.CodeAnalysis.SyntaxTrivia
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CompilationUnit() -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CompilationUnit(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CompilationUnit(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members, Microsoft.CodeAnalysis.SyntaxToken endOfFileToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! whenNotNull) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! whenNotNull) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! whenTrue, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! whenFalse) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.SyntaxToken questionToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! whenTrue, Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! whenFalse) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstantPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorConstraint() -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorConstraint(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax! initializer, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax! expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax! initializer, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax! expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax! initializer, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax? initializer, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax? initializer, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax! initializer, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(string! identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorInitializer(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax? argumentList = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorInitializer(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.SyntaxToken thisOrBaseKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax! argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ContinueStatement() -> Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ContinueStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ContinueStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken continueKeyword, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ContinueStatement(Microsoft.CodeAnalysis.SyntaxToken continueKeyword, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax? parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax? parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefBracketedParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax!> parameters = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefBracketedParameterList(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax!> parameters, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameter(Microsoft.CodeAnalysis.SyntaxToken refKindKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax!> parameters = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameterList(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax!> parameters, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DeclarationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax! designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DeclarationPattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax! designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultConstraint() -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultConstraint(Microsoft.CodeAnalysis.SyntaxToken defaultKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultExpression(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultSwitchLabel() -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultSwitchLabel(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefaultSwitchLabel(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken defineKeyword, Microsoft.CodeAnalysis.SyntaxToken name, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken name, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DefineDirectiveTrivia(string! name, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, string! identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DelegateDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DelegateDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax! expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken tildeToken, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax! expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken tildeToken, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken tildeToken, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(string! identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DisabledText(string! text) -> Microsoft.CodeAnalysis.SyntaxTrivia
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DiscardDesignation() -> Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DiscardDesignation(Microsoft.CodeAnalysis.SyntaxToken underscoreToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DiscardPattern() -> Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DiscardPattern(Microsoft.CodeAnalysis.SyntaxToken underscoreToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DocumentationComment(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax![]! content) -> Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DocumentationCommentExterior(string! text) -> Microsoft.CodeAnalysis.SyntaxTrivia
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!> content = default(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!> content, Microsoft.CodeAnalysis.SyntaxToken endOfComment) -> Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DoStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DoStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken doKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement, Microsoft.CodeAnalysis.SyntaxToken whileKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DoStatement(Microsoft.CodeAnalysis.SyntaxToken doKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement, Microsoft.CodeAnalysis.SyntaxToken whileKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax!
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElasticCarriageReturn.get -> Microsoft.CodeAnalysis.SyntaxTrivia
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElasticCarriageReturnLineFeed.get -> Microsoft.CodeAnalysis.SyntaxTrivia
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElasticEndOfLine(string text) -> Microsoft.CodeAnalysis.SyntaxTrivia
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElasticEndOfLine(string! text) -> Microsoft.CodeAnalysis.SyntaxTrivia
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElasticLineFeed.get -> Microsoft.CodeAnalysis.SyntaxTrivia
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElasticMarker.get -> Microsoft.CodeAnalysis.SyntaxTrivia
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElasticSpace.get -> Microsoft.CodeAnalysis.SyntaxTrivia
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElasticTab.get -> Microsoft.CodeAnalysis.SyntaxTrivia
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElasticWhitespace(string text) -> Microsoft.CodeAnalysis.SyntaxTrivia
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElementBindingExpression() -> Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElementBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElifDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, bool isActive, bool branchTaken, bool conditionValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElifDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken elifKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive, bool branchTaken, bool conditionValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElseClause(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElseClause(Microsoft.CodeAnalysis.SyntaxToken elseKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElseDirectiveTrivia(bool isActive, bool branchTaken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElseDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken elseKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive, bool branchTaken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EmptyStatement() -> Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EmptyStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EmptyStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EmptyStatement(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndIfDirectiveTrivia(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndIfDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken endIfKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndOfLine(string text) -> Microsoft.CodeAnalysis.SyntaxTrivia
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndOfLine(string text, bool elastic) -> Microsoft.CodeAnalysis.SyntaxTrivia
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndRegionDirectiveTrivia(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndRegionDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken endRegionKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken enumKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumDeclaration(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumDeclaration(string identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumMemberDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax equalsValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumMemberDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax equalsValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumMemberDeclaration(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumMemberDeclaration(string identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EqualsValueClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax value) -> Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EqualsValueClause(Microsoft.CodeAnalysis.SyntaxToken equalsToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax value) -> Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ErrorDirectiveTrivia(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ErrorDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken errorKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, string identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken eventKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken eventKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax accessorList, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken eventKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventFieldDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventFieldDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken eventKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, Microsoft.CodeAnalysis.SyntaxToken dotToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExternAliasDirective(Microsoft.CodeAnalysis.SyntaxToken externKeyword, Microsoft.CodeAnalysis.SyntaxToken aliasKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExternAliasDirective(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExternAliasDirective(string identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FieldDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FieldDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FinallyClause(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FinallyClause(Microsoft.CodeAnalysis.SyntaxToken finallyKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FixedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FixedStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FixedStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken fixedKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FixedStatement(Microsoft.CodeAnalysis.SyntaxToken fixedKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, string identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax variable, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax variable, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax variable, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax variable, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax variable, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> initializers, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> incrementors, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> initializers, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> incrementors, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken forKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> initializers, Microsoft.CodeAnalysis.SyntaxToken firstSemicolonToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SyntaxToken secondSemicolonToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> incrementors, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.SyntaxToken forKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> initializers, Microsoft.CodeAnalysis.SyntaxToken firstSemicolonToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SyntaxToken secondSemicolonToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> incrementors, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FromClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FromClause(Microsoft.CodeAnalysis.SyntaxToken fromKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FromClause(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FromClause(string identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerCallingConvention(Microsoft.CodeAnalysis.SyntaxToken managedOrUnmanagedKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerCallingConvention(Microsoft.CodeAnalysis.SyntaxToken managedOrUnmanagedKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameter(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax> parameters = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameterList(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax> parameters, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType() -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax callingConvention, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType(Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.SyntaxToken asteriskToken, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax callingConvention, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.SyntaxToken name) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax> callingConventions = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax> callingConventions, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GenericName(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GenericName(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax typeArgumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GenericName(string identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GetNonGenericExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GetStandaloneExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GlobalStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GlobalStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken caseOrDefaultKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken gotoKeyword, Microsoft.CodeAnalysis.SyntaxToken caseOrDefaultKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken caseOrDefaultKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken gotoKeyword, Microsoft.CodeAnalysis.SyntaxToken caseOrDefaultKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GroupClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax groupExpression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax byExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GroupClause(Microsoft.CodeAnalysis.SyntaxToken groupKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax groupExpression, Microsoft.CodeAnalysis.SyntaxToken byKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax byExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Identifier(Microsoft.CodeAnalysis.SyntaxTriviaList leading, Microsoft.CodeAnalysis.CSharp.SyntaxKind contextualKind, string text, string valueText, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Identifier(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string text, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Identifier(string text) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IdentifierName(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IdentifierName(string name) -> Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, bool isActive, bool branchTaken, bool conditionValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken ifKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive, bool branchTaken, bool conditionValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement, Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax else) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement, Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax else) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken ifKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement, Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax else) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.SyntaxToken ifKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement, Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax else) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SyntaxTokenList commas, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxTokenList commas, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitElementAccess() -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitElementAccess(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression() -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken stackAllocKeyword, Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IncompleteMember(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IncompleteMember(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax accessorList, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken thisKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax accessorList, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax parameters = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerMemberCref(Microsoft.CodeAnalysis.SyntaxToken thisKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InitializerExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> expressions = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InitializerExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> expressions, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterfaceDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterfaceDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterfaceDeclaration(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterfaceDeclaration(string identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringExpression(Microsoft.CodeAnalysis.SyntaxToken stringStartToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringExpression(Microsoft.CodeAnalysis.SyntaxToken stringStartToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax> contents) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringExpression(Microsoft.CodeAnalysis.SyntaxToken stringStartToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax> contents, Microsoft.CodeAnalysis.SyntaxToken stringEndToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringText() -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringText(Microsoft.CodeAnalysis.SyntaxToken textToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Interpolation(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Interpolation(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax alignmentClause, Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax formatClause) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Interpolation(Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax alignmentClause, Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax formatClause, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolationAlignmentClause(Microsoft.CodeAnalysis.SyntaxToken commaToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax value) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolationFormatClause(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolationFormatClause(Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.SyntaxToken formatStringToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IsCompleteSubmission(Microsoft.CodeAnalysis.SyntaxTree tree) -> bool
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken isKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax inExpression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax leftExpression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax rightExpression, Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax into) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinClause(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax inExpression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax leftExpression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax rightExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinClause(Microsoft.CodeAnalysis.SyntaxToken joinKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax inExpression, Microsoft.CodeAnalysis.SyntaxToken onKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax leftExpression, Microsoft.CodeAnalysis.SyntaxToken equalsKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax rightExpression, Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax into) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinClause(string identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax inExpression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax leftExpression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax rightExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinIntoClause(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinIntoClause(Microsoft.CodeAnalysis.SyntaxToken intoKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinIntoClause(string identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(string identifier, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LetClause(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LetClause(Microsoft.CodeAnalysis.SyntaxToken letKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken equalsToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LetClause(string identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken lineKeyword, Microsoft.CodeAnalysis.SyntaxToken line, Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken line, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken line, Microsoft.CodeAnalysis.SyntaxToken file, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElasticWhitespace(string! text) -> Microsoft.CodeAnalysis.SyntaxTrivia
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax! argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElementBindingExpression() -> Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElementBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax! argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElifDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, bool isActive, bool branchTaken, bool conditionValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElifDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken elifKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive, bool branchTaken, bool conditionValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElseClause(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElseClause(Microsoft.CodeAnalysis.SyntaxToken elseKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElseDirectiveTrivia(bool isActive, bool branchTaken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ElseDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken elseKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive, bool branchTaken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EmptyStatement() -> Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EmptyStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EmptyStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EmptyStatement(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndIfDirectiveTrivia(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndIfDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken endIfKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndOfLine(string! text) -> Microsoft.CodeAnalysis.SyntaxTrivia
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndOfLine(string! text, bool elastic) -> Microsoft.CodeAnalysis.SyntaxTrivia
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndRegionDirectiveTrivia(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EndRegionDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken endRegionKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken enumKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax!> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumDeclaration(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumDeclaration(string! identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumMemberDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax! equalsValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumMemberDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax? equalsValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumMemberDeclaration(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumMemberDeclaration(string! identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EqualsValueClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! value) -> Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EqualsValueClause(Microsoft.CodeAnalysis.SyntaxToken equalsToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! value) -> Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ErrorDirectiveTrivia(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ErrorDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken errorKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, string! identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax? accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken eventKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax! explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax! accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken eventKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax? accessorList, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken eventKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax! explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventFieldDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventFieldDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken eventKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken dotToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExternAliasDirective(Microsoft.CodeAnalysis.SyntaxToken externKeyword, Microsoft.CodeAnalysis.SyntaxToken aliasKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExternAliasDirective(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExternAliasDirective(string! identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FieldDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FieldDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FinallyClause(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FinallyClause(Microsoft.CodeAnalysis.SyntaxToken finallyKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block) -> Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FixedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FixedStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FixedStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken fixedKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FixedStatement(Microsoft.CodeAnalysis.SyntaxToken fixedKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, string! identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachStatement(Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! variable, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! variable, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! variable, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! variable, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForEachVariableStatement(Microsoft.CodeAnalysis.SyntaxToken forEachKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! variable, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> initializers, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? condition, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> incrementors, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> initializers, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? condition, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> incrementors, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken forKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> initializers, Microsoft.CodeAnalysis.SyntaxToken firstSemicolonToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? condition, Microsoft.CodeAnalysis.SyntaxToken secondSemicolonToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> incrementors, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ForStatement(Microsoft.CodeAnalysis.SyntaxToken forKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> initializers, Microsoft.CodeAnalysis.SyntaxToken firstSemicolonToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? condition, Microsoft.CodeAnalysis.SyntaxToken secondSemicolonToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> incrementors, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FromClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FromClause(Microsoft.CodeAnalysis.SyntaxToken fromKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FromClause(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FromClause(string! identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerCallingConvention(Microsoft.CodeAnalysis.SyntaxToken managedOrUnmanagedKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerCallingConvention(Microsoft.CodeAnalysis.SyntaxToken managedOrUnmanagedKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameter(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax!> parameters = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameterList(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax!> parameters, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType() -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax? callingConvention, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax! parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType(Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.SyntaxToken asteriskToken, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax? callingConvention, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax! parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.SyntaxToken name) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax!> callingConventions = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax!> callingConventions, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GenericName(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GenericName(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax! typeArgumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GenericName(string! identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GetNonGenericExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax?
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GetStandaloneExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GlobalStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GlobalStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken caseOrDefaultKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken gotoKeyword, Microsoft.CodeAnalysis.SyntaxToken caseOrDefaultKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken caseOrDefaultKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GotoStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken gotoKeyword, Microsoft.CodeAnalysis.SyntaxToken caseOrDefaultKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GroupClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! groupExpression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! byExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.GroupClause(Microsoft.CodeAnalysis.SyntaxToken groupKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! groupExpression, Microsoft.CodeAnalysis.SyntaxToken byKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! byExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Identifier(Microsoft.CodeAnalysis.SyntaxTriviaList leading, Microsoft.CodeAnalysis.CSharp.SyntaxKind contextualKind, string! text, string! valueText, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Identifier(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string! text, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Identifier(string! text) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IdentifierName(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IdentifierName(string! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, bool isActive, bool branchTaken, bool conditionValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken ifKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive, bool branchTaken, bool conditionValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement, Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax? else) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement, Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax? else) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken ifKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement, Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax? else) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IfStatement(Microsoft.CodeAnalysis.SyntaxToken ifKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement, Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax? else) -> Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax! initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SyntaxTokenList commas, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax! initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxTokenList commas, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax! initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitElementAccess() -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitElementAccess(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax! argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression() -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax! argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax! argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax! initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken stackAllocKeyword, Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax! initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IncompleteMember(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IncompleteMember(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type) -> Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax! explicitInterfaceSpecifier, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax! accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax? accessorList, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken thisKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax? accessorList, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax? parameters = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerMemberCref(Microsoft.CodeAnalysis.SyntaxToken thisKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax? parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InitializerExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> expressions = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InitializerExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> expressions, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterfaceDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterfaceDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterfaceDeclaration(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterfaceDeclaration(string! identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringExpression(Microsoft.CodeAnalysis.SyntaxToken stringStartToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringExpression(Microsoft.CodeAnalysis.SyntaxToken stringStartToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax!> contents) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringExpression(Microsoft.CodeAnalysis.SyntaxToken stringStartToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax!> contents, Microsoft.CodeAnalysis.SyntaxToken stringEndToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringText() -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolatedStringText(Microsoft.CodeAnalysis.SyntaxToken textToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Interpolation(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Interpolation(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax? alignmentClause, Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax? formatClause) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Interpolation(Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax? alignmentClause, Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax? formatClause, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolationAlignmentClause(Microsoft.CodeAnalysis.SyntaxToken commaToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! value) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolationFormatClause(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InterpolationFormatClause(Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.SyntaxToken formatStringToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.InvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax! argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IsCompleteSubmission(Microsoft.CodeAnalysis.SyntaxTree! tree) -> bool
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken isKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! inExpression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! leftExpression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! rightExpression, Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax? into) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinClause(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! inExpression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! leftExpression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! rightExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinClause(Microsoft.CodeAnalysis.SyntaxToken joinKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! inExpression, Microsoft.CodeAnalysis.SyntaxToken onKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! leftExpression, Microsoft.CodeAnalysis.SyntaxToken equalsKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! rightExpression, Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax? into) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinClause(string! identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! inExpression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! leftExpression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! rightExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinIntoClause(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinIntoClause(Microsoft.CodeAnalysis.SyntaxToken intoKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.JoinIntoClause(string! identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LabeledStatement(string! identifier, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LetClause(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LetClause(Microsoft.CodeAnalysis.SyntaxToken letKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken equalsToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LetClause(string! identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken lineKeyword, Microsoft.CodeAnalysis.SyntaxToken line, Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken line, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken line, Microsoft.CodeAnalysis.SyntaxToken file, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax!
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineFeed.get -> Microsoft.CodeAnalysis.SyntaxTrivia
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.List<TNode>() -> Microsoft.CodeAnalysis.SyntaxList<TNode>
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.List<TNode>(System.Collections.Generic.IEnumerable<TNode> nodes) -> Microsoft.CodeAnalysis.SyntaxList<TNode>
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.List<TNode>() -> Microsoft.CodeAnalysis.SyntaxList<TNode!>
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.List<TNode>(System.Collections.Generic.IEnumerable<TNode!>! nodes) -> Microsoft.CodeAnalysis.SyntaxList<TNode!>
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(char value) -> Microsoft.CodeAnalysis.SyntaxToken
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(decimal value) -> Microsoft.CodeAnalysis.SyntaxToken
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(double value) -> Microsoft.CodeAnalysis.SyntaxToken
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(float value) -> Microsoft.CodeAnalysis.SyntaxToken
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(int value) -> Microsoft.CodeAnalysis.SyntaxToken
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(long value) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string text, char value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string text, decimal value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string text, double value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string text, float value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string text, int value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string text, long value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string text, string value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string text, uint value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string text, ulong value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(string text, char value) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(string text, decimal value) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(string text, double value) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(string text, float value) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(string text, int value) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(string text, long value) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(string text, string value) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(string text, uint value) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(string text, ulong value) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(string value) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string! text, char value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string! text, decimal value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string! text, double value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string! text, float value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string! text, int value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string! text, long value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string! text, string! value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string! text, uint value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string! text, ulong value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(string! text, char value) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(string! text, decimal value) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(string! text, double value) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(string! text, float value) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(string! text, int value) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(string! text, long value) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(string! text, string! value) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(string! text, uint value) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(string! text, ulong value) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(string! value) -> Microsoft.CodeAnalysis.SyntaxToken
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(uint value) -> Microsoft.CodeAnalysis.SyntaxToken
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal(ulong value) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LiteralExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LiteralExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken token) -> Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LoadDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken file, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LoadDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken loadKeyword, Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, string identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LockStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LockStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LockStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken lockKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LockStatement(Microsoft.CodeAnalysis.SyntaxToken lockKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MakeRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MakeRefExpression(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MemberAccessExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MemberAccessExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MemberBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MemberBindingExpression(Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, string identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LiteralExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LiteralExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken token) -> Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LoadDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken file, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LoadDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken loadKeyword, Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalDeclarationStatement(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! declaration, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, string! identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax! typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax! expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax! typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax! expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LockStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LockStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LockStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken lockKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LockStatement(Microsoft.CodeAnalysis.SyntaxToken lockKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MakeRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MakeRefExpression(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MemberAccessExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MemberAccessExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MemberBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MemberBindingExpression(Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, string! identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MethodDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax! explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax! typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax!
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MissingToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> Microsoft.CodeAnalysis.SyntaxToken
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.MissingToken(Microsoft.CodeAnalysis.SyntaxTriviaList leading, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameColon(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameColon(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax name, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameColon(string name) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax name, Microsoft.CodeAnalysis.SyntaxToken equalsToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameEquals(string name) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax name, Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken namespaceKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxToken namespaceKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameColon(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameColon(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameColon(string! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken equalsToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameEquals(string! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! name, Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax? parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken namespaceKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxToken namespaceKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax!
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NodeOrTokenList() -> Microsoft.CodeAnalysis.SyntaxNodeOrTokenList
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NodeOrTokenList(params Microsoft.CodeAnalysis.SyntaxNodeOrToken[] nodesAndTokens) -> Microsoft.CodeAnalysis.SyntaxNodeOrTokenList
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NodeOrTokenList(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxNodeOrToken> nodesAndTokens) -> Microsoft.CodeAnalysis.SyntaxNodeOrTokenList
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken nullableKeyword, Microsoft.CodeAnalysis.SyntaxToken settingToken, Microsoft.CodeAnalysis.SyntaxToken targetToken, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken settingToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken settingToken, Microsoft.CodeAnalysis.SyntaxToken targetToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax elementType) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax elementType, Microsoft.CodeAnalysis.SyntaxToken questionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ObjectCreationExpression(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OmittedArraySizeExpression() -> Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OmittedArraySizeExpression(Microsoft.CodeAnalysis.SyntaxToken omittedArraySizeExpressionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OmittedTypeArgument() -> Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OmittedTypeArgument(Microsoft.CodeAnalysis.SyntaxToken omittedTypeArgumentToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OrderByClause(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax> orderings = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OrderByClause(Microsoft.CodeAnalysis.SyntaxToken orderByKeyword, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax> orderings) -> Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Ordering(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Ordering(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken ascendingOrDescendingKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Parameter(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax default) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Parameter(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax> parameters = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParameterList(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax> parameters, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedExpression(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression() -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode body) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode body) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode body) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedPattern(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedVariableDesignation(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax> variables = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedVariableDesignation(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax> variables, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseArgumentList(string text, int offset = 0, Microsoft.CodeAnalysis.ParseOptions options = null, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseAttributeArgumentList(string text, int offset = 0, Microsoft.CodeAnalysis.ParseOptions options = null, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseBracketedArgumentList(string text, int offset = 0, Microsoft.CodeAnalysis.ParseOptions options = null, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseBracketedParameterList(string text, int offset = 0, Microsoft.CodeAnalysis.ParseOptions options = null, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseCompilationUnit(string text, int offset = 0, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions options = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseExpression(string text, int offset = 0, Microsoft.CodeAnalysis.ParseOptions options = null, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseLeadingTrivia(string text, int offset = 0) -> Microsoft.CodeAnalysis.SyntaxTriviaList
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseMemberDeclaration(string text, int offset = 0, Microsoft.CodeAnalysis.ParseOptions options = null, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseName(string text, int offset = 0, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseParameterList(string text, int offset = 0, Microsoft.CodeAnalysis.ParseOptions options = null, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseStatement(string text, int offset = 0, Microsoft.CodeAnalysis.ParseOptions options = null, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(Microsoft.CodeAnalysis.Text.SourceText text, Microsoft.CodeAnalysis.ParseOptions options = null, string path = "", System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SyntaxTree
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(Microsoft.CodeAnalysis.Text.SourceText text, Microsoft.CodeAnalysis.ParseOptions options, string path, System.Collections.Immutable.ImmutableDictionary<string, Microsoft.CodeAnalysis.ReportDiagnostic> diagnosticOptions, bool? isGeneratedCode, System.Threading.CancellationToken cancellationToken) -> Microsoft.CodeAnalysis.SyntaxTree
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(Microsoft.CodeAnalysis.Text.SourceText text, Microsoft.CodeAnalysis.ParseOptions options, string path, System.Collections.Immutable.ImmutableDictionary<string, Microsoft.CodeAnalysis.ReportDiagnostic> diagnosticOptions, System.Threading.CancellationToken cancellationToken) -> Microsoft.CodeAnalysis.SyntaxTree
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(string text, Microsoft.CodeAnalysis.ParseOptions options = null, string path = "", System.Text.Encoding encoding = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SyntaxTree
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(string text, Microsoft.CodeAnalysis.ParseOptions options, string path, System.Text.Encoding encoding, System.Collections.Immutable.ImmutableDictionary<string, Microsoft.CodeAnalysis.ReportDiagnostic> diagnosticOptions, bool? isGeneratedCode, System.Threading.CancellationToken cancellationToken) -> Microsoft.CodeAnalysis.SyntaxTree
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(string text, Microsoft.CodeAnalysis.ParseOptions options, string path, System.Text.Encoding encoding, System.Collections.Immutable.ImmutableDictionary<string, Microsoft.CodeAnalysis.ReportDiagnostic> diagnosticOptions, System.Threading.CancellationToken cancellationToken) -> Microsoft.CodeAnalysis.SyntaxTree
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseToken(string text, int offset = 0) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTokens(string text, int offset = 0, int initialTokenPosition = 0, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions options = null) -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxToken>
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTrailingTrivia(string text, int offset = 0) -> Microsoft.CodeAnalysis.SyntaxTriviaList
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTypeName(string text, int offset = 0, Microsoft.CodeAnalysis.ParseOptions options = null, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTypeName(string text, int offset, bool consumeFullText) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PointerType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax elementType) -> Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PointerType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax elementType, Microsoft.CodeAnalysis.SyntaxToken asteriskToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PositionalPatternClause(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax> subpatterns = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PositionalPatternClause(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax> subpatterns, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax operand) -> Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax operand, Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken guid, Microsoft.CodeAnalysis.SyntaxToken bytes, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken pragmaKeyword, Microsoft.CodeAnalysis.SyntaxToken checksumKeyword, Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken guid, Microsoft.CodeAnalysis.SyntaxToken bytes, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken disableOrRestoreKeyword, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken disableOrRestoreKeyword, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> errorCodes, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken pragmaKeyword, Microsoft.CodeAnalysis.SyntaxToken warningKeyword, Microsoft.CodeAnalysis.SyntaxToken disableOrRestoreKeyword, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> errorCodes, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PredefinedType(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax operand) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax operand) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PreprocessingMessage(string text) -> Microsoft.CodeAnalysis.SyntaxTrivia
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, string identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax accessorList, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax accessorList, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax initializer, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyPatternClause(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax> subpatterns = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyPatternClause(Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax> subpatterns, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax container, Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax member) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax container, Microsoft.CodeAnalysis.SyntaxToken dotToken, Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax member) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax left, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax right) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax left, Microsoft.CodeAnalysis.SyntaxToken dotToken, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax right) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryBody(Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax selectOrGroup) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryBody(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax> clauses, Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax selectOrGroup, Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax continuation) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryContinuation(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax body) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryContinuation(Microsoft.CodeAnalysis.SyntaxToken intoKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax body) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryContinuation(string identifier, Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax body) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax fromClause, Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax body) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RangeExpression() -> Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax leftOperand, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax rightOperand) -> Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax leftOperand, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax rightOperand) -> Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.SyntaxToken keyword, string identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecursivePattern() -> Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecursivePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax positionalPatternClause, Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax propertyPatternClause, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReferenceDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken file, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReferenceDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken referenceKeyword, Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefExpression(Microsoft.CodeAnalysis.SyntaxToken refKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefType(Microsoft.CodeAnalysis.SyntaxToken refKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefType(Microsoft.CodeAnalysis.SyntaxToken refKeyword, Microsoft.CodeAnalysis.SyntaxToken readOnlyKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefTypeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefTypeExpression(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefValueExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefValueExpression(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken comma, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RegionDirectiveTrivia(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RegionDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken regionKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RelationalPattern(Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReturnStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReturnStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReturnStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken returnKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReturnStatement(Microsoft.CodeAnalysis.SyntaxToken returnKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SelectClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SelectClause(Microsoft.CodeAnalysis.SyntaxToken selectKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList<TNode>() -> Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode>
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList<TNode>(Microsoft.CodeAnalysis.SyntaxNodeOrTokenList nodesAndTokens) -> Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode>
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList<TNode>(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxNodeOrToken> nodesAndTokens) -> Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode>
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList<TNode>(System.Collections.Generic.IEnumerable<TNode> nodes) -> Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode>
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList<TNode>(System.Collections.Generic.IEnumerable<TNode> nodes, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxToken> separators) -> Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode>
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ShebangDirectiveTrivia(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ShebangDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken exclamationToken, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax parameter) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax parameter, Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode body) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax parameter, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax parameter, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode body) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax parameter, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax parameter, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax parameter, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SingletonList<TNode>(TNode node) -> Microsoft.CodeAnalysis.SyntaxList<TNode>
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SingletonSeparatedList<TNode>(TNode node) -> Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode>
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SingleVariableDesignation(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SizeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SizeOfExpression(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SkippedTokensTrivia() -> Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SkippedTokensTrivia(Microsoft.CodeAnalysis.SyntaxTokenList tokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NodeOrTokenList(params Microsoft.CodeAnalysis.SyntaxNodeOrToken[]! nodesAndTokens) -> Microsoft.CodeAnalysis.SyntaxNodeOrTokenList
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NodeOrTokenList(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxNodeOrToken>! nodesAndTokens) -> Microsoft.CodeAnalysis.SyntaxNodeOrTokenList
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken nullableKeyword, Microsoft.CodeAnalysis.SyntaxToken settingToken, Microsoft.CodeAnalysis.SyntaxToken targetToken, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken settingToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken settingToken, Microsoft.CodeAnalysis.SyntaxToken targetToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! elementType) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.NullableType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! elementType, Microsoft.CodeAnalysis.SyntaxToken questionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax? argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ObjectCreationExpression(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax? argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OmittedArraySizeExpression() -> Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OmittedArraySizeExpression(Microsoft.CodeAnalysis.SyntaxToken omittedArraySizeExpressionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OmittedTypeArgument() -> Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OmittedTypeArgument(Microsoft.CodeAnalysis.SyntaxToken omittedTypeArgumentToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax? parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorMemberCref(Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax? parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OrderByClause(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax!> orderings = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OrderByClause(Microsoft.CodeAnalysis.SyntaxToken orderByKeyword, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax!> orderings) -> Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Ordering(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Ordering(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken ascendingOrDescendingKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Parameter(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax? default) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Parameter(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!> parameters = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParameterList(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!> parameters, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedExpression(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression() -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedPattern(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedVariableDesignation(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax!> variables = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedVariableDesignation(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax!> variables, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseArgumentList(string! text, int offset = 0, Microsoft.CodeAnalysis.ParseOptions? options = null, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseAttributeArgumentList(string! text, int offset = 0, Microsoft.CodeAnalysis.ParseOptions? options = null, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseBracketedArgumentList(string! text, int offset = 0, Microsoft.CodeAnalysis.ParseOptions? options = null, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseBracketedParameterList(string! text, int offset = 0, Microsoft.CodeAnalysis.ParseOptions? options = null, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseCompilationUnit(string! text, int offset = 0, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions? options = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseExpression(string! text, int offset = 0, Microsoft.CodeAnalysis.ParseOptions? options = null, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseLeadingTrivia(string! text, int offset = 0) -> Microsoft.CodeAnalysis.SyntaxTriviaList
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseMemberDeclaration(string! text, int offset = 0, Microsoft.CodeAnalysis.ParseOptions? options = null, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax?
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseName(string! text, int offset = 0, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseParameterList(string! text, int offset = 0, Microsoft.CodeAnalysis.ParseOptions? options = null, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseStatement(string! text, int offset = 0, Microsoft.CodeAnalysis.ParseOptions? options = null, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(Microsoft.CodeAnalysis.Text.SourceText! text, Microsoft.CodeAnalysis.ParseOptions? options = null, string! path = "", System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SyntaxTree!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(Microsoft.CodeAnalysis.Text.SourceText! text, Microsoft.CodeAnalysis.ParseOptions? options, string! path, System.Collections.Immutable.ImmutableDictionary<string!, Microsoft.CodeAnalysis.ReportDiagnostic>? diagnosticOptions, bool? isGeneratedCode, System.Threading.CancellationToken cancellationToken) -> Microsoft.CodeAnalysis.SyntaxTree!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(Microsoft.CodeAnalysis.Text.SourceText! text, Microsoft.CodeAnalysis.ParseOptions? options, string! path, System.Collections.Immutable.ImmutableDictionary<string!, Microsoft.CodeAnalysis.ReportDiagnostic>? diagnosticOptions, System.Threading.CancellationToken cancellationToken) -> Microsoft.CodeAnalysis.SyntaxTree!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(string! text, Microsoft.CodeAnalysis.ParseOptions? options = null, string! path = "", System.Text.Encoding? encoding = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SyntaxTree!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(string! text, Microsoft.CodeAnalysis.ParseOptions? options, string! path, System.Text.Encoding? encoding, System.Collections.Immutable.ImmutableDictionary<string!, Microsoft.CodeAnalysis.ReportDiagnostic>? diagnosticOptions, bool? isGeneratedCode, System.Threading.CancellationToken cancellationToken) -> Microsoft.CodeAnalysis.SyntaxTree!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(string! text, Microsoft.CodeAnalysis.ParseOptions? options, string! path, System.Text.Encoding? encoding, System.Collections.Immutable.ImmutableDictionary<string!, Microsoft.CodeAnalysis.ReportDiagnostic>? diagnosticOptions, System.Threading.CancellationToken cancellationToken) -> Microsoft.CodeAnalysis.SyntaxTree!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseToken(string! text, int offset = 0) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTokens(string! text, int offset = 0, int initialTokenPosition = 0, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions? options = null) -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxToken>!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTrailingTrivia(string! text, int offset = 0) -> Microsoft.CodeAnalysis.SyntaxTriviaList
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTypeName(string! text, int offset = 0, Microsoft.CodeAnalysis.ParseOptions? options = null, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTypeName(string! text, int offset, bool consumeFullText) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PointerType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! elementType) -> Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PointerType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! elementType, Microsoft.CodeAnalysis.SyntaxToken asteriskToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PositionalPatternClause(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax!> subpatterns = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PositionalPatternClause(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax!> subpatterns, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! operand) -> Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! operand, Microsoft.CodeAnalysis.SyntaxToken operatorToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken guid, Microsoft.CodeAnalysis.SyntaxToken bytes, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken pragmaKeyword, Microsoft.CodeAnalysis.SyntaxToken checksumKeyword, Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken guid, Microsoft.CodeAnalysis.SyntaxToken bytes, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken disableOrRestoreKeyword, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken disableOrRestoreKeyword, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> errorCodes, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken pragmaKeyword, Microsoft.CodeAnalysis.SyntaxToken warningKeyword, Microsoft.CodeAnalysis.SyntaxToken disableOrRestoreKeyword, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!> errorCodes, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PredefinedType(Microsoft.CodeAnalysis.SyntaxToken keyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! operand) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! operand) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PreprocessingMessage(string! text) -> Microsoft.CodeAnalysis.SyntaxTrivia
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax! argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, string! identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax! explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax! accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax? accessorList, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax? initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax? accessorList, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax? initializer, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyPatternClause(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax!> subpatterns = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyPatternClause(Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax!> subpatterns, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! container, Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax! member) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! container, Microsoft.CodeAnalysis.SyntaxToken dotToken, Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax! member) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! left, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax! right) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! left, Microsoft.CodeAnalysis.SyntaxToken dotToken, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax! right) -> Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryBody(Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax! selectOrGroup) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryBody(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax!> clauses, Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax! selectOrGroup, Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax? continuation) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryContinuation(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryContinuation(Microsoft.CodeAnalysis.SyntaxToken intoKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryContinuation(string! identifier, Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.QueryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax! fromClause, Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RangeExpression() -> Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? leftOperand, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? rightOperand) -> Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? leftOperand, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? rightOperand) -> Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax! typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax! baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax? parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.SyntaxToken keyword, string! identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecursivePattern() -> Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecursivePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type, Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax? positionalPatternClause, Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax? propertyPatternClause, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax? designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReferenceDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken file, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReferenceDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken referenceKeyword, Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefExpression(Microsoft.CodeAnalysis.SyntaxToken refKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefType(Microsoft.CodeAnalysis.SyntaxToken refKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefType(Microsoft.CodeAnalysis.SyntaxToken refKeyword, Microsoft.CodeAnalysis.SyntaxToken readOnlyKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefTypeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefTypeExpression(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefValueExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RefValueExpression(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken comma, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RegionDirectiveTrivia(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RegionDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken regionKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RelationalPattern(Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReturnStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReturnStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReturnStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken returnKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ReturnStatement(Microsoft.CodeAnalysis.SyntaxToken returnKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SelectClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SelectClause(Microsoft.CodeAnalysis.SyntaxToken selectKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList<TNode>() -> Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode!>
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList<TNode>(Microsoft.CodeAnalysis.SyntaxNodeOrTokenList nodesAndTokens) -> Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode!>
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList<TNode>(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxNodeOrToken>! nodesAndTokens) -> Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode!>
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList<TNode>(System.Collections.Generic.IEnumerable<TNode!>? nodes) -> Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode!>
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SeparatedList<TNode>(System.Collections.Generic.IEnumerable<TNode!>? nodes, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxToken>? separators) -> Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode!>
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ShebangDirectiveTrivia(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ShebangDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken exclamationToken, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax! parameter) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax! parameter, Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax! parameter, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax! parameter, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax! parameter, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax! parameter, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax! parameter, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SingletonList<TNode>(TNode! node) -> Microsoft.CodeAnalysis.SyntaxList<TNode!>
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SingletonSeparatedList<TNode>(TNode! node) -> Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode!>
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SingleVariableDesignation(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SizeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SizeOfExpression(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SkippedTokensTrivia() -> Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SkippedTokensTrivia(Microsoft.CodeAnalysis.SyntaxTokenList tokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax!
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Space.get -> Microsoft.CodeAnalysis.SyntaxTrivia
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StackAllocArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken stackAllocKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StackAllocArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken stackAllocKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(string identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Subpattern(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax nameColon, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Subpattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax governingExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax governingExpression, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax> arms) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax governingExpression, Microsoft.CodeAnalysis.SyntaxToken switchKeyword, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax> arms, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern, Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax whenClause, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern, Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax whenClause, Microsoft.CodeAnalysis.SyntaxToken equalsGreaterThanToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchSection() -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchSection(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax> labels, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax> statements) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax> sections) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken switchKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax> sections, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchStatement(Microsoft.CodeAnalysis.SyntaxToken switchKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax> sections, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SyntaxTree(Microsoft.CodeAnalysis.SyntaxNode root, Microsoft.CodeAnalysis.ParseOptions options = null, string path = "", System.Text.Encoding encoding = null) -> Microsoft.CodeAnalysis.SyntaxTree
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SyntaxTrivia(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, string text) -> Microsoft.CodeAnalysis.SyntaxTrivia
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StackAllocArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken stackAllocKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StackAllocArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxToken stackAllocKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.StructDeclaration(string! identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Subpattern(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax? nameColon, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Subpattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! governingExpression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! governingExpression, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax!> arms) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! governingExpression, Microsoft.CodeAnalysis.SyntaxToken switchKeyword, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax!> arms, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern, Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax? whenClause, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern, Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax? whenClause, Microsoft.CodeAnalysis.SyntaxToken equalsGreaterThanToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchSection() -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchSection(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax!> labels, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax!> statements) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax!> sections) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken switchKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax!> sections, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SwitchStatement(Microsoft.CodeAnalysis.SyntaxToken switchKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax!> sections, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SyntaxTree(Microsoft.CodeAnalysis.SyntaxNode! root, Microsoft.CodeAnalysis.ParseOptions? options = null, string! path = "", System.Text.Encoding? encoding = null) -> Microsoft.CodeAnalysis.SyntaxTree!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SyntaxTrivia(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, string! text) -> Microsoft.CodeAnalysis.SyntaxTrivia
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Tab.get -> Microsoft.CodeAnalysis.SyntaxTrivia
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThisExpression() -> Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThisExpression(Microsoft.CodeAnalysis.SyntaxToken token) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowExpression(Microsoft.CodeAnalysis.SyntaxToken throwKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken throwKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowStatement(Microsoft.CodeAnalysis.SyntaxToken throwKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThisExpression() -> Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThisExpression(Microsoft.CodeAnalysis.SyntaxToken token) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowExpression(Microsoft.CodeAnalysis.SyntaxToken throwKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken throwKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowStatement(Microsoft.CodeAnalysis.SyntaxToken throwKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax!
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Token(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> Microsoft.CodeAnalysis.SyntaxToken
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Token(Microsoft.CodeAnalysis.SyntaxTriviaList leading, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Token(Microsoft.CodeAnalysis.SyntaxTriviaList leading, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, string text, string valueText, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Token(Microsoft.CodeAnalysis.SyntaxTriviaList leading, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, string! text, string! valueText, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TokenList() -> Microsoft.CodeAnalysis.SyntaxTokenList
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TokenList(Microsoft.CodeAnalysis.SyntaxToken token) -> Microsoft.CodeAnalysis.SyntaxTokenList
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TokenList(params Microsoft.CodeAnalysis.SyntaxToken[] tokens) -> Microsoft.CodeAnalysis.SyntaxTokenList
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TokenList(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxToken> tokens) -> Microsoft.CodeAnalysis.SyntaxTokenList
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Trivia(Microsoft.CodeAnalysis.CSharp.Syntax.StructuredTriviaSyntax node) -> Microsoft.CodeAnalysis.SyntaxTrivia
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TokenList(params Microsoft.CodeAnalysis.SyntaxToken[]! tokens) -> Microsoft.CodeAnalysis.SyntaxTokenList
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TokenList(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxToken>! tokens) -> Microsoft.CodeAnalysis.SyntaxTokenList
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Trivia(Microsoft.CodeAnalysis.CSharp.Syntax.StructuredTriviaSyntax! node) -> Microsoft.CodeAnalysis.SyntaxTrivia
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TriviaList() -> Microsoft.CodeAnalysis.SyntaxTriviaList
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TriviaList(Microsoft.CodeAnalysis.SyntaxTrivia trivia) -> Microsoft.CodeAnalysis.SyntaxTriviaList
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TriviaList(params Microsoft.CodeAnalysis.SyntaxTrivia[] trivias) -> Microsoft.CodeAnalysis.SyntaxTriviaList
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TriviaList(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxTrivia> trivias) -> Microsoft.CodeAnalysis.SyntaxTriviaList
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax> catches, Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax finally) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax> catches, Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax finally) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken tryKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax> catches, Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax finally) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax> catches = default(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.SyntaxToken tryKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax> catches, Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax finally) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleExpression(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax> arguments = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleExpression(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax> arguments, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleType(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax> elements = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleType(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax> elements, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeArgumentList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax> arguments = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeArgumentList(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax> arguments, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributes, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, string identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeOfExpression(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameter(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken varianceKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameter(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameter(string identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax name, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax> constraints) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterConstraintClause(Microsoft.CodeAnalysis.SyntaxToken whereKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax name, Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax> constraints) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterConstraintClause(string name) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax> parameters = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterList(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax> parameters, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnaryPattern(Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UndefDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken undefKeyword, Microsoft.CodeAnalysis.SyntaxToken name, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UndefDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken name, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UndefDirectiveTrivia(string name, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnsafeStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnsafeStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnsafeStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken unsafeKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnsafeStatement(Microsoft.CodeAnalysis.SyntaxToken unsafeKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax alias, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.SyntaxToken staticKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax alias, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxToken staticKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax alias, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax> variables) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclarator(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclarator(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclarator(string identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VarPattern(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VarPattern(Microsoft.CodeAnalysis.SyntaxToken varKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VerbatimIdentifier(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string text, string valueText, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WarningDirectiveTrivia(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WarningDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken warningKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhenClause(Microsoft.CodeAnalysis.SyntaxToken whenKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhereClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhereClause(Microsoft.CodeAnalysis.SyntaxToken whereKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhileStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhileStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhileStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken whileKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhileStatement(Microsoft.CodeAnalysis.SyntaxToken whileKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Whitespace(string text) -> Microsoft.CodeAnalysis.SyntaxTrivia
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Whitespace(string text, bool elastic) -> Microsoft.CodeAnalysis.SyntaxTrivia
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken withKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCDataSection(Microsoft.CodeAnalysis.SyntaxToken startCDataToken, Microsoft.CodeAnalysis.SyntaxTokenList textTokens, Microsoft.CodeAnalysis.SyntaxToken endCDataToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCDataSection(Microsoft.CodeAnalysis.SyntaxTokenList textTokens = default(Microsoft.CodeAnalysis.SyntaxTokenList)) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlComment(Microsoft.CodeAnalysis.SyntaxToken lessThanExclamationMinusMinusToken, Microsoft.CodeAnalysis.SyntaxTokenList textTokens, Microsoft.CodeAnalysis.SyntaxToken minusMinusGreaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlComment(Microsoft.CodeAnalysis.SyntaxTokenList textTokens = default(Microsoft.CodeAnalysis.SyntaxTokenList)) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax cref) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax cref, Microsoft.CodeAnalysis.CSharp.SyntaxKind quoteKind) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxToken equalsToken, Microsoft.CodeAnalysis.SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax cref, Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax cref, Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax startTag, Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax endTag) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax startTag, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content, Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax endTag) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElement(string localName, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementEndTag(Microsoft.CodeAnalysis.SyntaxToken lessThanSlashToken, Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax> attributes) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementStartTag(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax> attributes, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax> attributes) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEmptyElement(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax> attributes, Microsoft.CodeAnalysis.SyntaxToken slashGreaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEmptyElement(string localName) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEntity(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string text, string value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlExampleElement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlExampleElement(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlExceptionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax cref, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlExceptionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax cref, params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlMultiLineElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlMultiLineElement(string localName, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax prefix, Microsoft.CodeAnalysis.SyntaxToken localName) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlName(Microsoft.CodeAnalysis.SyntaxToken localName) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlName(string localName) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxToken equalsToken, Microsoft.CodeAnalysis.SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax identifier, Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax identifier, Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxToken startQuoteToken, string identifier, Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNameAttribute(string parameterName) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNewLine(string text) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNullKeywordElement() -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParaElement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParaElement(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParamElement(string parameterName, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParamElement(string parameterName, params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParamRefElement(string parameterName) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPermissionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax cref, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPermissionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax cref, params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPlaceholderElement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPlaceholderElement(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPrefix(Microsoft.CodeAnalysis.SyntaxToken prefix) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPrefix(Microsoft.CodeAnalysis.SyntaxToken prefix, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPrefix(string prefix) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPreliminaryElement() -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxTokenList textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlProcessingInstruction(Microsoft.CodeAnalysis.SyntaxToken startProcessingInstructionToken, Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxTokenList textTokens, Microsoft.CodeAnalysis.SyntaxToken endProcessingInstructionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlRemarksElement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlRemarksElement(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlReturnsElement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlReturnsElement(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSeeAlsoElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax cref) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSeeAlsoElement(System.Uri linkAddress, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> linkText) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSeeElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax cref) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSummaryElement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSummaryElement(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlText() -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlText(Microsoft.CodeAnalysis.SyntaxTokenList textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlText(params Microsoft.CodeAnalysis.SyntaxToken[] textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlText(string value) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.CSharp.SyntaxKind quoteKind, Microsoft.CodeAnalysis.SyntaxTokenList textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxToken equalsToken, Microsoft.CodeAnalysis.SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.SyntaxTokenList textTokens, Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, Microsoft.CodeAnalysis.SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.SyntaxTokenList textTokens, Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(string name, Microsoft.CodeAnalysis.CSharp.SyntaxKind quoteKind, Microsoft.CodeAnalysis.SyntaxTokenList textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(string name, params Microsoft.CodeAnalysis.SyntaxToken[] textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(string name, string value) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextLiteral(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string text, string value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextLiteral(string text, string value) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextLiteral(string value) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextNewLine(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string text, string value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextNewLine(string text) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextNewLine(string text, bool continueXmlDocumentationComment) -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlThreadSafetyElement() -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlThreadSafetyElement(bool isStatic, bool isInstance) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlValueElement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlValueElement(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.YieldStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.YieldStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.YieldStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken yieldKeyword, Microsoft.CodeAnalysis.SyntaxToken returnOrBreakKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.YieldStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken yieldKeyword, Microsoft.CodeAnalysis.SyntaxToken returnOrBreakKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.EqualityComparer.get -> System.Collections.Generic.IEqualityComparer<Microsoft.CodeAnalysis.CSharp.SyntaxKind>
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TriviaList(params Microsoft.CodeAnalysis.SyntaxTrivia[]! trivias) -> Microsoft.CodeAnalysis.SyntaxTriviaList
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TriviaList(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxTrivia>! trivias) -> Microsoft.CodeAnalysis.SyntaxTriviaList
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!> catches, Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax! finally) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!> catches, Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax? finally) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken tryKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!> catches, Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax? finally) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!> catches = default(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.SyntaxToken tryKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!> catches, Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax! finally) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleExpression(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!> arguments = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleExpression(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax!> arguments, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleType(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax!> elements = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleType(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax!> elements, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeArgumentList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!> arguments = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeArgumentList(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax!> arguments, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributes, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, string! identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeOfExpression(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameter(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken varianceKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameter(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameter(string! identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! name, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax!> constraints) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterConstraintClause(Microsoft.CodeAnalysis.SyntaxToken whereKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken colonToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax!> constraints) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterConstraintClause(string! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax!> parameters = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypeParameterList(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax!> parameters, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TypePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnaryPattern(Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UndefDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken undefKeyword, Microsoft.CodeAnalysis.SyntaxToken name, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UndefDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken name, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UndefDirectiveTrivia(string! name, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnsafeStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnsafeStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnsafeStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken unsafeKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UnsafeStatement(Microsoft.CodeAnalysis.SyntaxToken unsafeKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax! alias, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.SyntaxToken staticKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax? alias, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxToken staticKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax? alias, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingStatement(Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax!> variables) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclarator(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclarator(Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax? argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax? initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VariableDeclarator(string! identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VarPattern(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax! designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VarPattern(Microsoft.CodeAnalysis.SyntaxToken varKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax! designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VerbatimIdentifier(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string! text, string! valueText, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WarningDirectiveTrivia(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WarningDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken warningKeyword, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhenClause(Microsoft.CodeAnalysis.SyntaxToken whenKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhereClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhereClause(Microsoft.CodeAnalysis.SyntaxToken whereKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhileStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhileStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhileStatement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken whileKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WhileStatement(Microsoft.CodeAnalysis.SyntaxToken whileKeyword, Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! condition, Microsoft.CodeAnalysis.SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax! statement) -> Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Whitespace(string! text) -> Microsoft.CodeAnalysis.SyntaxTrivia
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Whitespace(string! text, bool elastic) -> Microsoft.CodeAnalysis.SyntaxTrivia
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax! initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken withKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax! initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCDataSection(Microsoft.CodeAnalysis.SyntaxToken startCDataToken, Microsoft.CodeAnalysis.SyntaxTokenList textTokens, Microsoft.CodeAnalysis.SyntaxToken endCDataToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCDataSection(Microsoft.CodeAnalysis.SyntaxTokenList textTokens = default(Microsoft.CodeAnalysis.SyntaxTokenList)) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlComment(Microsoft.CodeAnalysis.SyntaxToken lessThanExclamationMinusMinusToken, Microsoft.CodeAnalysis.SyntaxTokenList textTokens, Microsoft.CodeAnalysis.SyntaxToken minusMinusGreaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlComment(Microsoft.CodeAnalysis.SyntaxTokenList textTokens = default(Microsoft.CodeAnalysis.SyntaxTokenList)) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax! cref) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax! cref, Microsoft.CodeAnalysis.CSharp.SyntaxKind quoteKind) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken equalsToken, Microsoft.CodeAnalysis.SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax! cref, Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax! cref, Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax! startTag, Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax! endTag) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax! startTag, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!> content, Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax! endTag) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElement(string! localName, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementEndTag(Microsoft.CodeAnalysis.SyntaxToken lessThanSlashToken, Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax!> attributes) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlElementStartTag(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax!> attributes, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax!> attributes) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEmptyElement(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax!> attributes, Microsoft.CodeAnalysis.SyntaxToken slashGreaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEmptyElement(string! localName) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlEntity(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string! text, string! value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlExampleElement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlExampleElement(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax![]! content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlExceptionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax! cref, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlExceptionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax! cref, params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax![]! content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlMultiLineElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlMultiLineElement(string! localName, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax? prefix, Microsoft.CodeAnalysis.SyntaxToken localName) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlName(Microsoft.CodeAnalysis.SyntaxToken localName) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlName(string! localName) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken equalsToken, Microsoft.CodeAnalysis.SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! identifier, Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! identifier, Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken startQuoteToken, string! identifier, Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNameAttribute(string! parameterName) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNewLine(string! text) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlNullKeywordElement() -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParaElement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParaElement(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax![]! content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParamElement(string! parameterName, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParamElement(string! parameterName, params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax![]! content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlParamRefElement(string! parameterName) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPermissionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax! cref, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPermissionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax! cref, params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax![]! content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPlaceholderElement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPlaceholderElement(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax![]! content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPrefix(Microsoft.CodeAnalysis.SyntaxToken prefix) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPrefix(Microsoft.CodeAnalysis.SyntaxToken prefix, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPrefix(string! prefix) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlPreliminaryElement() -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxTokenList textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlProcessingInstruction(Microsoft.CodeAnalysis.SyntaxToken startProcessingInstructionToken, Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxTokenList textTokens, Microsoft.CodeAnalysis.SyntaxToken endProcessingInstructionToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlRemarksElement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlRemarksElement(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax![]! content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlReturnsElement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlReturnsElement(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax![]! content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSeeAlsoElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax! cref) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSeeAlsoElement(System.Uri! linkAddress, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!> linkText) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSeeElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax! cref) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSummaryElement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlSummaryElement(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax![]! content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlText() -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlText(Microsoft.CodeAnalysis.SyntaxTokenList textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlText(params Microsoft.CodeAnalysis.SyntaxToken[]! textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlText(string! value) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.CSharp.SyntaxKind quoteKind, Microsoft.CodeAnalysis.SyntaxTokenList textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken equalsToken, Microsoft.CodeAnalysis.SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.SyntaxTokenList textTokens, Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.SyntaxTokenList textTokens, Microsoft.CodeAnalysis.SyntaxToken endQuoteToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(string! name, Microsoft.CodeAnalysis.CSharp.SyntaxKind quoteKind, Microsoft.CodeAnalysis.SyntaxTokenList textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(string! name, params Microsoft.CodeAnalysis.SyntaxToken[]! textTokens) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextAttribute(string! name, string! value) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextLiteral(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string! text, string! value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextLiteral(string! text, string! value) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextLiteral(string! value) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextNewLine(Microsoft.CodeAnalysis.SyntaxTriviaList leading, string! text, string! value, Microsoft.CodeAnalysis.SyntaxTriviaList trailing) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextNewLine(string! text) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlTextNewLine(string! text, bool continueXmlDocumentationComment) -> Microsoft.CodeAnalysis.SyntaxToken
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlThreadSafetyElement() -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlThreadSafetyElement(bool isStatic, bool isInstance) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlValueElement(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax!> content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.XmlValueElement(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax![]! content) -> Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.YieldStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.YieldStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.YieldStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken yieldKeyword, Microsoft.CodeAnalysis.SyntaxToken returnOrBreakKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.YieldStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken yieldKeyword, Microsoft.CodeAnalysis.SyntaxToken returnOrBreakKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.EqualityComparer.get -> System.Collections.Generic.IEqualityComparer<Microsoft.CodeAnalysis.CSharp.SyntaxKind>!
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetAccessorDeclarationKind(Microsoft.CodeAnalysis.CSharp.SyntaxKind keyword) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetAssignmentExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind token) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetBaseTypeDeclarationKind(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetBinaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind token) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetCheckStatement(Microsoft.CodeAnalysis.CSharp.SyntaxKind keyword) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetContextualKeywordKind(string text) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetContextualKeywordKinds() -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.CSharp.SyntaxKind>
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetContextualKeywordKind(string! text) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetContextualKeywordKinds() -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.CSharp.SyntaxKind>!
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetInstanceExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind token) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetKeywordKind(string text) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetKeywordKinds() -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.CSharp.SyntaxKind>
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetKeywordKind(string! text) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetKeywordKinds() -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.CSharp.SyntaxKind>!
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetLiteralExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind token) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetOperatorKind(string operatorMetadataName) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetOperatorKind(string! operatorMetadataName) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind token) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind token) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPreprocessorKeywordKind(string text) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPreprocessorKeywordKinds() -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.CSharp.SyntaxKind>
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPreprocessorKeywordKind(string! text) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPreprocessorKeywordKinds() -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.CSharp.SyntaxKind>!
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPrimaryFunction(Microsoft.CodeAnalysis.CSharp.SyntaxKind keyword) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPunctuationKinds() -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.CSharp.SyntaxKind>
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetReservedKeywordKinds() -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.CSharp.SyntaxKind>
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetPunctuationKinds() -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.CSharp.SyntaxKind>!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetReservedKeywordKinds() -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.CSharp.SyntaxKind>!
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetSwitchLabelKind(Microsoft.CodeAnalysis.CSharp.SyntaxKind keyword) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetText(Microsoft.CodeAnalysis.Accessibility accessibility) -> string
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetText(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> string
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetText(Microsoft.CodeAnalysis.Accessibility accessibility) -> string!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetText(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> string!
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetTypeDeclarationKind(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAccessibilityModifier(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAccessorDeclarationKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind keyword) -> bool
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAliasQualifier(Microsoft.CodeAnalysis.SyntaxNode node) -> bool
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAliasQualifier(Microsoft.CodeAnalysis.SyntaxNode! node) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAnyOverloadableOperator(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAnyToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAnyUnaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind token) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAssignmentExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAssignmentExpressionOperatorToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind token) -> bool
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAttributeName(Microsoft.CodeAnalysis.SyntaxNode node) -> bool
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAttributeName(Microsoft.CodeAnalysis.SyntaxNode! node) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsAttributeTargetSpecifier(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsBinaryExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind token) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsBinaryExpressionOperatorToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind token) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsContextualKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsDocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsFixedStatementExpression(Microsoft.CodeAnalysis.SyntaxNode node) -> bool
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsFixedStatementExpression(Microsoft.CodeAnalysis.SyntaxNode! node) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsGlobalMemberDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsIdentifierPartCharacter(char ch) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsIdentifierStartCharacter(char ch) -> bool
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsIndexed(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax node) -> bool
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsInNamespaceOrTypeContext(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax node) -> bool
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsIndexed(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! node) -> bool
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsInNamespaceOrTypeContext(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? node) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsInstanceExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind token) -> bool
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsInTypeOnlyContext(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax node) -> bool
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsInvoked(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax node) -> bool
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsInTypeOnlyContext(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! node) -> bool
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsInvoked(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! node) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsKeywordKind(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsLambdaBody(Microsoft.CodeAnalysis.SyntaxNode node) -> bool
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsLambdaBody(Microsoft.CodeAnalysis.SyntaxNode! node) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsLanguagePunctuation(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsLiteralExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind token) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsName(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsNamedArgumentName(Microsoft.CodeAnalysis.SyntaxNode node) -> bool
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsNamespaceAliasQualifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax node) -> bool
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsNamedArgumentName(Microsoft.CodeAnalysis.SyntaxNode! node) -> bool
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsNamespaceAliasQualifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! node) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsNamespaceMemberDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsNewLine(char ch) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsOverloadableBinaryOperator(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
@@ -5262,505 +5263,505 @@ static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPunctuation(Microsoft.CodeAna
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsPunctuationOrKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsQueryContextualKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsReservedKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsReservedTupleElementName(string elementName) -> bool
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsReservedTupleElementName(string! elementName) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsTrivia(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsTypeDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsTypeParameterVarianceKeyword(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsTypeSyntax(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsUnaryOperatorDeclarationToken(Microsoft.CodeAnalysis.CSharp.SyntaxKind token) -> bool
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsValidIdentifier(string name) -> bool
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsValidIdentifier(string? name) -> bool
 static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsWhitespace(char ch) -> bool
-static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.TryGetInferredMemberName(this Microsoft.CodeAnalysis.SyntaxNode syntax) -> string
-static Microsoft.CodeAnalysis.CSharp.TypedConstantExtensions.ToCSharpString(this Microsoft.CodeAnalysis.TypedConstant constant) -> string
+static Microsoft.CodeAnalysis.CSharp.SyntaxFacts.TryGetInferredMemberName(this Microsoft.CodeAnalysis.SyntaxNode! syntax) -> string?
+static Microsoft.CodeAnalysis.CSharp.TypedConstantExtensions.ToCSharpString(this Microsoft.CodeAnalysis.TypedConstant constant) -> string!
 static Microsoft.CodeAnalysis.CSharpExtensions.Any(this Microsoft.CodeAnalysis.SyntaxTokenList list, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
 static Microsoft.CodeAnalysis.CSharpExtensions.Any(this Microsoft.CodeAnalysis.SyntaxTriviaList list, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
-static Microsoft.CodeAnalysis.CSharpExtensions.Any<TNode>(this Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode> list, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
-static Microsoft.CodeAnalysis.CSharpExtensions.Any<TNode>(this Microsoft.CodeAnalysis.SyntaxList<TNode> list, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
+static Microsoft.CodeAnalysis.CSharpExtensions.Any<TNode>(this Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode!> list, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
+static Microsoft.CodeAnalysis.CSharpExtensions.Any<TNode>(this Microsoft.CodeAnalysis.SyntaxList<TNode!> list, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
 static Microsoft.CodeAnalysis.CSharpExtensions.IndexOf(this Microsoft.CodeAnalysis.SyntaxTokenList list, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> int
 static Microsoft.CodeAnalysis.CSharpExtensions.IndexOf(this Microsoft.CodeAnalysis.SyntaxTriviaList list, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> int
-static Microsoft.CodeAnalysis.CSharpExtensions.IndexOf<TNode>(this Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode> list, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> int
-static Microsoft.CodeAnalysis.CSharpExtensions.IndexOf<TNode>(this Microsoft.CodeAnalysis.SyntaxList<TNode> list, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> int
-static Microsoft.CodeAnalysis.CSharpExtensions.IsKind(this Microsoft.CodeAnalysis.SyntaxNode node, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
+static Microsoft.CodeAnalysis.CSharpExtensions.IndexOf<TNode>(this Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode!> list, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> int
+static Microsoft.CodeAnalysis.CSharpExtensions.IndexOf<TNode>(this Microsoft.CodeAnalysis.SyntaxList<TNode!> list, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> int
+static Microsoft.CodeAnalysis.CSharpExtensions.IsKind(this Microsoft.CodeAnalysis.SyntaxNode? node, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
 static Microsoft.CodeAnalysis.CSharpExtensions.IsKind(this Microsoft.CodeAnalysis.SyntaxNodeOrToken nodeOrToken, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
 static Microsoft.CodeAnalysis.CSharpExtensions.IsKind(this Microsoft.CodeAnalysis.SyntaxToken token, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
 static Microsoft.CodeAnalysis.CSharpExtensions.IsKind(this Microsoft.CodeAnalysis.SyntaxTrivia trivia, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> bool
 virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitIntoStructuredTrivia.get -> bool
 virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitList(Microsoft.CodeAnalysis.SyntaxTokenList list) -> Microsoft.CodeAnalysis.SyntaxTokenList
 virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitList(Microsoft.CodeAnalysis.SyntaxTriviaList list) -> Microsoft.CodeAnalysis.SyntaxTriviaList
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitList<TNode>(Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode> list) -> Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode>
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitList<TNode>(Microsoft.CodeAnalysis.SyntaxList<TNode> list) -> Microsoft.CodeAnalysis.SyntaxList<TNode>
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitList<TNode>(Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode!> list) -> Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode!>
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitList<TNode>(Microsoft.CodeAnalysis.SyntaxList<TNode!> list) -> Microsoft.CodeAnalysis.SyntaxList<TNode!>
 virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitListElement(Microsoft.CodeAnalysis.SyntaxTrivia element) -> Microsoft.CodeAnalysis.SyntaxTrivia
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitListElement<TNode>(TNode node) -> TNode
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitListElement<TNode>(TNode? node) -> TNode?
 virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitListSeparator(Microsoft.CodeAnalysis.SyntaxToken separator) -> Microsoft.CodeAnalysis.SyntaxToken
 virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitToken(Microsoft.CodeAnalysis.SyntaxToken token) -> Microsoft.CodeAnalysis.SyntaxToken
 virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitTrivia(Microsoft.CodeAnalysis.SyntaxTrivia trivia) -> Microsoft.CodeAnalysis.SyntaxTrivia
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetRootAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode>
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.DefaultVisit(Microsoft.CodeAnalysis.SyntaxNode node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.Visit(Microsoft.CodeAnalysis.SyntaxNode node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAccessorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAnonymousObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArgument(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArrayRankSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArrowExpressionClause(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAssignmentExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttributeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttributeList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttributeTargetSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAwaitExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBaseExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBinaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBinaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBracketedArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBreakStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCastExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCatchClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCatchFilterClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCheckedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCheckedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitClassDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCompilationUnit(Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConstantPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConstructorConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConstructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConstructorInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitContinueStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConversionOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConversionOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCrefBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCrefParameter(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCrefParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDeclarationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDeclarationPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDefaultConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDefaultExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDefaultSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDefineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDestructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDiscardDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDiscardPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElementBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElifDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElseClause(Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElseDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEmptyStatement(Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEndIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEndRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEnumDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEnumMemberDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEqualsValueClause(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitErrorDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEventFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExternAliasDirective(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFinallyClause(Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFixedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitForEachVariableStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFromClause(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitGenericName(Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitGlobalStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitGotoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitGroupClause(Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIdentifierName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitElementAccess(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIncompleteMember(Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIndexerDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIndexerMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInitializerExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterfaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolatedStringExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolatedStringText(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolation(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolationAlignmentClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolationFormatClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitJoinClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitJoinIntoClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLabeledStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLetClause(Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLiteralExpression(Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLoadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLocalDeclarationStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLockStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitMakeRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitMemberAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitMemberBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitMethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNullableDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNullableType(Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOmittedArraySizeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOmittedTypeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOrderByClause(Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOrdering(Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParameter(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPositionalPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPredefinedType(Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPropertyPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQueryBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQueryContinuation(Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQueryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRecordDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRecursivePattern(Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitReferenceDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRefType(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRefTypeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRefValueExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRelationalPattern(Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitReturnStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSelectClause(Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitShebangDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSimpleBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSingleVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSizeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSkippedTokensTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitStructDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSubpattern(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSwitchSection(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitThisExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitThrowExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitThrowStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTryStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTupleExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTupleType(Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUnaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUndefDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUnsafeStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitVariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitVariableDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitVarPattern(Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWhereClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWhileStatement(Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlCDataSection(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlComment(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlElementEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlPrefix(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlText(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitYieldStatement(Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.DefaultVisit(Microsoft.CodeAnalysis.SyntaxNode node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.Visit(Microsoft.CodeAnalysis.SyntaxNode node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAccessorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAnonymousObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitArgument(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitArrayRankSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitArrowExpressionClause(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAssignmentExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAttributeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAttributeList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAttributeTargetSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAwaitExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitBadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitBaseExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitBinaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitBinaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitBracketedArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitBreakStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCastExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCatchClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCatchFilterClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCheckedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCheckedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitClassDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCompilationUnit(Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitConstantPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitConstructorConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitConstructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitConstructorInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitContinueStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitConversionOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitConversionOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCrefBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCrefParameter(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCrefParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDeclarationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDeclarationPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDefaultConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDefaultExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDefaultSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDefineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDestructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDiscardDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDiscardPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitElementBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitElifDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitElseClause(Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitElseDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitEmptyStatement(Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitEndIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitEndRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitEnumDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitEnumMemberDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitEqualsValueClause(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitErrorDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitEventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitEventFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitExternAliasDirective(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitFinallyClause(Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitFixedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitForEachVariableStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitFromClause(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitFunctionPointerCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitFunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitFunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitGenericName(Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitGlobalStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitGotoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitGroupClause(Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitIdentifierName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitIfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitImplicitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitImplicitElementAccess(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitIncompleteMember(Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitIndexerDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitIndexerMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitInitializerExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitInterfaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitInterpolatedStringExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitInterpolatedStringText(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitInterpolation(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitInterpolationAlignmentClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitInterpolationFormatClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitInvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitIsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitJoinClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitJoinIntoClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitLabeledStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitLetClause(Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitLineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitLiteralExpression(Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitLoadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitLocalDeclarationStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitLocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitLockStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitMakeRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitMemberAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitMemberBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitMethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitNameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitNullableDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitNullableType(Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitOmittedArraySizeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitOmittedTypeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitOrderByClause(Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitOrdering(Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitParameter(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitParenthesizedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitParenthesizedVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitPositionalPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitPostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitPragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitPragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitPredefinedType(Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitPrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitPropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitPropertyPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitQualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitQueryBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitQueryContinuation(Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitQueryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitRangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitRecordDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitRecursivePattern(Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitReferenceDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitRefType(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitRefTypeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitRefValueExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitRelationalPattern(Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitReturnStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSelectClause(Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitShebangDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSimpleBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSingleVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSizeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSkippedTokensTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitStructDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSubpattern(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSwitchSection(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitThisExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitThrowExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitThrowStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTryStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTupleExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTupleType(Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTypeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTypeConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTypeCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTypeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTypeParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTypePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitUnaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitUndefDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitUnsafeStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitUsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitUsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitVariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitVariableDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitVarPattern(Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitWhereClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitWhileStatement(Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitWithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlCDataSection(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlComment(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlElementEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlPrefix(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlText(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitYieldStatement(Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax node) -> TResult
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetRootAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode!>!
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.DefaultVisit(Microsoft.CodeAnalysis.SyntaxNode! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.Visit(Microsoft.CodeAnalysis.SyntaxNode? node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAccessorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAnonymousObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArgument(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArrayRankSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitArrowExpressionClause(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAssignmentExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttributeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttributeList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAttributeTargetSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitAwaitExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBaseExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBinaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBinaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBracketedArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBreakStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCastExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCatchClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCatchFilterClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCheckedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCheckedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitClassDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCompilationUnit(Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConstantPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConstructorConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConstructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConstructorInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitContinueStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConversionOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitConversionOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCrefBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCrefParameter(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitCrefParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDeclarationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDeclarationPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDefaultConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDefaultExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDefaultSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDefineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDestructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDiscardDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDiscardPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitDoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElementBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElifDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElseClause(Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitElseDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEmptyStatement(Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEndIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEndRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEnumDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEnumMemberDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEqualsValueClause(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitErrorDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitEventFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExternAliasDirective(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFinallyClause(Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFixedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitForEachVariableStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFromClause(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitGenericName(Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitGlobalStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitGotoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitGroupClause(Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIdentifierName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitElementAccess(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIncompleteMember(Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIndexerDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIndexerMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInitializerExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterfaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolatedStringExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolatedStringText(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolation(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolationAlignmentClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInterpolationFormatClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitInvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitIsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitJoinClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitJoinIntoClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLabeledStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLetClause(Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLiteralExpression(Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLoadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLocalDeclarationStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLockStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitMakeRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitMemberAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitMemberBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitMethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNullableDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitNullableType(Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOmittedArraySizeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOmittedTypeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOrderByClause(Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitOrdering(Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParameter(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPositionalPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPredefinedType(Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPropertyPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQueryBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQueryContinuation(Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitQueryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRecordDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRecursivePattern(Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitReferenceDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRefType(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRefTypeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRefValueExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRelationalPattern(Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitReturnStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSelectClause(Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitShebangDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSimpleBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSingleVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSizeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSkippedTokensTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitStructDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSubpattern(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSwitchSection(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitThisExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitThrowExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitThrowStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTryStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTupleExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTupleType(Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUnaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUndefDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUnsafeStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitVariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitVariableDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitVarPattern(Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWhereClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWhileStatement(Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlCDataSection(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlComment(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlElementEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlPrefix(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlText(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitXmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitYieldStatement(Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.DefaultVisit(Microsoft.CodeAnalysis.SyntaxNode! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.Visit(Microsoft.CodeAnalysis.SyntaxNode? node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAccessorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAccessorList(Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAnonymousObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitArgument(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitArrayRankSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitArrowExpressionClause(Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAssignmentExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAttributeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAttributeList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAttributeTargetSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitAwaitExpression(Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitBadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitBaseExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitBaseList(Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitBinaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitBinaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitBlock(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitBracketedArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitBreakStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCastExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCatchClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCatchFilterClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCheckedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCheckedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitClassDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitClassOrStructConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCompilationUnit(Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitConstantPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitConstructorConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitConstructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitConstructorInitializer(Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitContinueStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitConversionOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitConversionOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCrefBracketedParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCrefParameter(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitCrefParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDeclarationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDeclarationPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDefaultConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDefaultExpression(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDefaultSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDefineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDestructorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDiscardDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDiscardPattern(Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDocumentationCommentTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitDoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitElementBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitElifDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitElseClause(Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitElseDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitEmptyStatement(Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitEndIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitEndRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitEnumDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitEnumMemberDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitEqualsValueClause(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitErrorDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitEventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitEventFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitExternAliasDirective(Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitFinallyClause(Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitFixedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitForEachVariableStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitFromClause(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitFunctionPointerCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitFunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitFunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitGenericName(Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitGlobalStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitGotoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitGroupClause(Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitIdentifierName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitIfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitIfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitImplicitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitImplicitElementAccess(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitIncompleteMember(Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitIndexerDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitIndexerMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitInitializerExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitInterfaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitInterpolatedStringExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitInterpolatedStringText(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitInterpolation(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitInterpolationAlignmentClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitInterpolationFormatClause(Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitInvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitIsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitJoinClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitJoinIntoClause(Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitLabeledStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitLetClause(Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitLineDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitLiteralExpression(Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitLoadDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitLocalDeclarationStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitLocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitLockStatement(Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitMakeRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitMemberAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitMemberBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitMethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitNameColon(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitNameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitNameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitNullableDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitNullableType(Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitOmittedArraySizeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitOmittedTypeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitOperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitOperatorMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitOrderByClause(Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitOrdering(Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitParameter(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitParenthesizedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitParenthesizedVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitPositionalPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitPostfixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitPragmaChecksumDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitPragmaWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitPredefinedType(Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitPrefixUnaryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitPropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitPropertyPatternClause(Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitQualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitQueryBody(Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitQueryContinuation(Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitQueryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitRangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitRecordDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitRecursivePattern(Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitReferenceDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitRefType(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitRefTypeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitRefValueExpression(Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitRegionDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitRelationalPattern(Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitReturnStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSelectClause(Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitShebangDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSimpleBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSingleVariableDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSizeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSkippedTokensTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitStructDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSubpattern(Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSwitchSection(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitThisExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitThrowExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitThrowStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTryStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTupleExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTupleType(Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTypeArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTypeConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTypeCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTypeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTypeParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitTypePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitUnaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitUndefDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitUnsafeStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitUsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitUsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitVariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitVariableDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitVarPattern(Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitWarningDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitWhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitWhereClause(Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitWhileStatement(Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitWithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlCDataSection(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlComment(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlElementEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlPrefix(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlText(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitXmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitYieldStatement(Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax! node) -> TResult?
 virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.VisitLeadingTrivia(Microsoft.CodeAnalysis.SyntaxToken token) -> void
 virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.VisitToken(Microsoft.CodeAnalysis.SyntaxToken token) -> void
 virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker.VisitTrailingTrivia(Microsoft.CodeAnalysis.SyntaxToken token) -> void
diff --git a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt
index 4a6a172339b77..e002a91e8bd99 100644
--- a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt
+++ b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt
@@ -1,80 +1,80 @@
 Microsoft.CodeAnalysis.CSharp.Conversion.IsInterpolatedStringHandler.get -> bool
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.ColonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.File.get -> Microsoft.CodeAnalysis.SyntaxToken
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.LineKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp10 = 1000 -> Microsoft.CodeAnalysis.CSharp.LanguageVersion
 Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.Character.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.CloseParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.CommaToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.Line.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.OpenParenToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SyntaxToken line, Microsoft.CodeAnalysis.SyntaxToken commaToken, Microsoft.CodeAnalysis.SyntaxToken character, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithCharacter(Microsoft.CodeAnalysis.SyntaxToken character) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithCommaToken(Microsoft.CodeAnalysis.SyntaxToken commaToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithLine(Microsoft.CodeAnalysis.SyntaxToken line) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SyntaxToken line, Microsoft.CodeAnalysis.SyntaxToken commaToken, Microsoft.CodeAnalysis.SyntaxToken character, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithCharacter(Microsoft.CodeAnalysis.SyntaxToken character) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithCloseParenToken(Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithCommaToken(Microsoft.CodeAnalysis.SyntaxToken commaToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithLine(Microsoft.CodeAnalysis.SyntaxToken line) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.WithOpenParenToken(Microsoft.CodeAnalysis.SyntaxToken openParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax!
 *REMOVED*Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.File.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.ExclamationExclamationToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken exclamationExclamationToken, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax default) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithExclamationExclamationToken(Microsoft.CodeAnalysis.SyntaxToken exclamationExclamationToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken exclamationExclamationToken, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax? default) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithExclamationExclamationToken(Microsoft.CodeAnalysis.SyntaxToken exclamationExclamationToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!
 Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExclamationExclamationToken = 8285 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
 Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.AddPatterns(params Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.AddPatterns(params Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.CloseBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.Designation.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.Designation.get -> Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax?
 Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.OpenBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.Patterns.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax> patterns, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken openBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.WithPatterns(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax> patterns) -> Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.Patterns.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax!> patterns, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax? designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.WithDesignation(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax? designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken openBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.WithPatterns(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax!> patterns) -> Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.DotDotToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.Pattern.get -> Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken dotDotToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.WithDotDotToken(Microsoft.CodeAnalysis.SyntaxToken dotDotToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.Pattern.get -> Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken dotDotToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax? pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.WithDotDotToken(Microsoft.CodeAnalysis.SyntaxToken dotDotToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.WithPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax? pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax!
 Microsoft.CodeAnalysis.CSharp.SyntaxKind.ListPattern = 9035 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
 Microsoft.CodeAnalysis.CSharp.SyntaxKind.SlicePattern = 9034 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitListPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSlicePattern(Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitListPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitSlicePattern(Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
 override Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.File.get -> Microsoft.CodeAnalysis.SyntaxToken
 *REMOVED*Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.LineKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax.LineKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken file) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithLineKeyword(Microsoft.CodeAnalysis.SyntaxToken lineKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken file) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.WithLineKeyword(Microsoft.CodeAnalysis.SyntaxToken lineKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.CharacterOffset.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.End.get -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.End.get -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.MinusToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.Start.get -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken lineKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax start, Microsoft.CodeAnalysis.SyntaxToken minusToken, Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax end, Microsoft.CodeAnalysis.SyntaxToken characterOffset, Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithCharacterOffset(Microsoft.CodeAnalysis.SyntaxToken characterOffset) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithEnd(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax end) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken file) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithLineKeyword(Microsoft.CodeAnalysis.SyntaxToken lineKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithMinusToken(Microsoft.CodeAnalysis.SyntaxToken minusToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithStart(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax start) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.ExpressionColon.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax expressionColon, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.WithExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax expressionColon) -> Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.Start.get -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken lineKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax! start, Microsoft.CodeAnalysis.SyntaxToken minusToken, Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax! end, Microsoft.CodeAnalysis.SyntaxToken characterOffset, Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithCharacterOffset(Microsoft.CodeAnalysis.SyntaxToken characterOffset) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithEnd(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax! end) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithEndOfDirectiveToken(Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithFile(Microsoft.CodeAnalysis.SyntaxToken file) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithHashToken(Microsoft.CodeAnalysis.SyntaxToken hashToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithIsActive(bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithLineKeyword(Microsoft.CodeAnalysis.SyntaxToken lineKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithMinusToken(Microsoft.CodeAnalysis.SyntaxToken minusToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.WithStart(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax! start) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.ExpressionColon.get -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax? expressionColon, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax.WithExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax? expressionColon) -> Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax!
 Microsoft.CodeAnalysis.CSharp.SyntaxKind.ExpressionColon = 9069 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
 Microsoft.CodeAnalysis.CSharp.SyntaxKind.LineDirectivePosition = 9070 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
 Microsoft.CodeAnalysis.CSharp.SyntaxKind.LineSpanDirectiveTrivia = 9071 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
@@ -84,154 +84,154 @@ Microsoft.CodeAnalysis.CSharp.SyntaxKind.LineSpanDirectiveTrivia = 9071 -> Micro
 *REMOVED*Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.NamespaceKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
 *REMOVED*Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Usings.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax>
 Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddExterns(params Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddMembers(params Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddUsings(params Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithExterns(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithNamespaceKeyword(Microsoft.CodeAnalysis.SyntaxToken namespaceKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithUsings(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddExterns(params Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddMembers(params Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.AddUsings(params Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithExterns(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!> externs) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithNamespaceKeyword(Microsoft.CodeAnalysis.SyntaxToken namespaceKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.WithUsings(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!> usings) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddExterns(params Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddMembers(params Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddUsings(params Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddExterns(params Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddMembers(params Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AddUsings(params Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.SemicolonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken namespaceKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, Microsoft.CodeAnalysis.SyntaxToken semicolonToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithExterns(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithNamespaceKeyword(Microsoft.CodeAnalysis.SyntaxToken namespaceKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithUsings(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken namespaceKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken semicolonToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithExterns(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!> externs) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithMembers(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithNamespaceKeyword(Microsoft.CodeAnalysis.SyntaxToken namespaceKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.WithUsings(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!> usings) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.SyntaxKind.FileScopedNamespaceDeclaration = 8845 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.Externs.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax>
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.Members.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax>
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.Externs.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!>
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.Members.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!>
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax!
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.NamespaceKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.Usings.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax>
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Externs.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Members.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax.Usings.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!>
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Externs.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Members.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax!
 override Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.NamespaceKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Usings.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Externs.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax>
-override Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Members.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax>
+override Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax.Usings.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Externs.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!>
+override Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Members.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!>
 override Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList
-override Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax!
 override Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.NamespaceKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Usings.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax>
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax constructorInitializer) -> Microsoft.CodeAnalysis.DataFlowAnalysis
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax primaryConstructorBaseType) -> Microsoft.CodeAnalysis.DataFlowAnalysis
-override Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.INamespaceSymbol
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken namespaceKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, Microsoft.CodeAnalysis.SyntaxToken semicolonToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Parameter(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken exclamationExclamationToken, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax default) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ListPattern(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax> patterns = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ListPattern(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax> patterns, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ListPattern(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax> patterns, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SlicePattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SlicePattern(Microsoft.CodeAnalysis.SyntaxToken dotDotToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitListPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSlicePattern(Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitFileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax node) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax.Usings.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!>
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax! constructorInitializer) -> Microsoft.CodeAnalysis.DataFlowAnalysis?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax! primaryConstructorBaseType) -> Microsoft.CodeAnalysis.DataFlowAnalysis?
+override Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax! declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.INamespaceSymbol?
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken namespaceKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken semicolonToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Parameter(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken exclamationExclamationToken, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax? default) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ListPattern(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax!> patterns = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ListPattern(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax!> patterns, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax? designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ListPattern(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax!> patterns, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax? designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SlicePattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax? pattern = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SlicePattern(Microsoft.CodeAnalysis.SyntaxToken dotDotToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax? pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax!
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitListPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSlicePattern(Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitFileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax! node) -> TResult?
 Microsoft.CodeAnalysis.CSharp.SyntaxKind.RecordStructDeclaration = 9068 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
-override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetUsedAssemblyReferences(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.MetadataReference>
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLineDirectivePosition(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode
-override Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetUsedAssemblyReferences(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.MetadataReference!>
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLineDirectivePosition(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitLineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax! node) -> Microsoft.CodeAnalysis.SyntaxNode?
+override Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.ColonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-override Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
-override Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
+override Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
+override Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
+override Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
+override Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 override Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.EndOfDirectiveToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.File.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.HashToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.IsActive.get -> bool
 override Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax.LineKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-override Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax
+override Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 *REMOVED*Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.ColonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
 override Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax.ColonToken.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax
-abstract Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.ReturnType.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax!
+abstract Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.LambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+override Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.ReturnType.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
 *REMOVED*static Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.Create(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.ISourceGenerator> generators, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.AdditionalText> additionalTexts = null, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions parseOptions = null, Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider optionsProvider = null) -> Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver
-static Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.Create(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.ISourceGenerator> generators, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.AdditionalText> additionalTexts = null, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions parseOptions = null, Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider optionsProvider = null, Microsoft.CodeAnalysis.GeneratorDriverOptions driverOptions = default(Microsoft.CodeAnalysis.GeneratorDriverOptions)) -> Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver
-static Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.Create(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.ISourceGenerator> generators, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.AdditionalText> additionalTexts, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions parseOptions, Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider optionsProvider) -> Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectivePosition(Microsoft.CodeAnalysis.SyntaxToken line, Microsoft.CodeAnalysis.SyntaxToken character) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectivePosition(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SyntaxToken line, Microsoft.CodeAnalysis.SyntaxToken commaToken, Microsoft.CodeAnalysis.SyntaxToken character, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineSpanDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken lineKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax start, Microsoft.CodeAnalysis.SyntaxToken minusToken, Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax end, Microsoft.CodeAnalysis.SyntaxToken characterOffset, Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax start, Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax end, Microsoft.CodeAnalysis.SyntaxToken characterOffset, Microsoft.CodeAnalysis.SyntaxToken file, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax start, Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax end, Microsoft.CodeAnalysis.SyntaxToken file, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithClassOrStructKeyword(Microsoft.CodeAnalysis.SyntaxToken classOrStructKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken classOrStructKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken classOrStructKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
+static Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.Create(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.ISourceGenerator!>! generators, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.AdditionalText!>? additionalTexts = null, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions? parseOptions = null, Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider? optionsProvider = null, Microsoft.CodeAnalysis.GeneratorDriverOptions driverOptions = default(Microsoft.CodeAnalysis.GeneratorDriverOptions)) -> Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver!
+static Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.Create(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.ISourceGenerator!>! generators, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.AdditionalText!>? additionalTexts, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions? parseOptions, Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider? optionsProvider) -> Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax! expression, Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectivePosition(Microsoft.CodeAnalysis.SyntaxToken line, Microsoft.CodeAnalysis.SyntaxToken character) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineDirectivePosition(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SyntaxToken line, Microsoft.CodeAnalysis.SyntaxToken commaToken, Microsoft.CodeAnalysis.SyntaxToken character, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineSpanDirectiveTrivia(Microsoft.CodeAnalysis.SyntaxToken hashToken, Microsoft.CodeAnalysis.SyntaxToken lineKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax! start, Microsoft.CodeAnalysis.SyntaxToken minusToken, Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax! end, Microsoft.CodeAnalysis.SyntaxToken characterOffset, Microsoft.CodeAnalysis.SyntaxToken file, Microsoft.CodeAnalysis.SyntaxToken endOfDirectiveToken, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax! start, Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax! end, Microsoft.CodeAnalysis.SyntaxToken characterOffset, Microsoft.CodeAnalysis.SyntaxToken file, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax! start, Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax! end, Microsoft.CodeAnalysis.SyntaxToken file, bool isActive) -> Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax.WithReturnType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? returnType) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithClassOrStructKeyword(Microsoft.CodeAnalysis.SyntaxToken classOrStructKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken classOrStructKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax? parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken classOrStructKeyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax? parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.SyntaxToken openBraceToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members, Microsoft.CodeAnalysis.SyntaxToken closeBraceToken, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.ClassOrStructKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken keyword, string identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-override Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
-Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax parameter, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax parameter, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax parameter, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Subpattern(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax expressionColon, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.SyntaxToken globalKeyword, Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxToken staticKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax alias, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax? parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.SyntaxToken keyword, string! identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+override Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!>
+Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax! parameter, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax! parameter, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SimpleLambdaExpression(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax! parameter, Microsoft.CodeAnalysis.SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Subpattern(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax? expressionColon, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax! pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.UsingDirective(Microsoft.CodeAnalysis.SyntaxToken globalKeyword, Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxToken staticKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax? alias, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.GlobalKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken globalKeyword, Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxToken staticKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax alias, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithGlobalKeyword(Microsoft.CodeAnalysis.SyntaxToken globalKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLineDirectivePosition(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax node) -> void
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitLineDirectivePosition(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitLineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax node) -> TResult
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken globalKeyword, Microsoft.CodeAnalysis.SyntaxToken usingKeyword, Microsoft.CodeAnalysis.SyntaxToken staticKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax? alias, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.WithGlobalKeyword(Microsoft.CodeAnalysis.SyntaxToken globalKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLineDirectivePosition(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitLineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax! node) -> void
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitLineDirectivePosition(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitLineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax! node) -> TResult?
 *REMOVED*Microsoft.CodeAnalysis.CSharp.SyntaxKind.DataKeyword = 8441 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind
-override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetLineMappings(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.LineMapping>
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.ExplicitInterfaceSpecifier.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.ExplicitInterfaceSpecifier.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax
-static Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.Create(params Microsoft.CodeAnalysis.IIncrementalGenerator[] incrementalGenerators) -> Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitListPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax node) -> TResult
-virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSlicePattern(Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax node) -> TResult
+override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.GetLineMappings(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.LineMapping>!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.ExplicitInterfaceSpecifier.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.ExplicitInterfaceSpecifier.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax?
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
+Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax.WithExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.Create(params Microsoft.CodeAnalysis.IIncrementalGenerator![]! incrementalGenerators) -> Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver!
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitListPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax! node) -> TResult?
+virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>.VisitSlicePattern(Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax! node) -> TResult?
diff --git a/src/Compilers/CSharp/Portable/Syntax/AnonymousMethodExpressionSyntax.cs b/src/Compilers/CSharp/Portable/Syntax/AnonymousMethodExpressionSyntax.cs
index 5400db5e16f6b..be996f7bc0862 100644
--- a/src/Compilers/CSharp/Portable/Syntax/AnonymousMethodExpressionSyntax.cs
+++ b/src/Compilers/CSharp/Portable/Syntax/AnonymousMethodExpressionSyntax.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 #nullable disable
+#pragma warning disable RS0041 // uses oblivious reference types
 
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
diff --git a/src/Compilers/CSharp/Portable/Syntax/LambdaExpressionSyntax.cs b/src/Compilers/CSharp/Portable/Syntax/LambdaExpressionSyntax.cs
index 28232e209bb65..1cd6f60ccaa7b 100644
--- a/src/Compilers/CSharp/Portable/Syntax/LambdaExpressionSyntax.cs
+++ b/src/Compilers/CSharp/Portable/Syntax/LambdaExpressionSyntax.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 #nullable disable
+#pragma warning disable RS0041 // uses oblivious reference types
 
 namespace Microsoft.CodeAnalysis.CSharp.Syntax
 {

From e72a0e2949ec95ea38bb4c4f908facc07f133fae Mon Sep 17 00:00:00 2001
From: Shen Chen <shech@microsoft.com>
Date: Mon, 3 Jan 2022 17:17:30 -0800
Subject: [PATCH 195/444] Use PackageReference

---
 .../IntegrationTests/Workspace/WorkspaceBase.cs    | 14 ++++++++++++++
 .../Workspace/WorkspacesNetCore.cs                 |  4 ++--
 2 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspaceBase.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspaceBase.cs
index 57a1a90f2d097..317c70c0ab0a9 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspaceBase.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspaceBase.cs
@@ -62,6 +62,20 @@ public virtual void MetadataReference()
             VisualStudio.Editor.Verify.CurrentTokenType("identifier");
         }
 
+        public void PackageReference()
+        {
+            var systemTextJson = new ProjectUtils.PackageReference("System.Text.Json", "6.0.0");
+            var project = new ProjectUtils.Project(ProjectName);
+            VisualStudio.SolutionExplorer.AddPackageReference(project, systemTextJson);
+            VisualStudio.SolutionExplorer.RestoreNuGetPackages(project);
+            VisualStudio.Editor.SetText("class C { System.Text.Json.JsonElement p; }");
+            VisualStudio.Editor.PlaceCaret("JsonElement");
+            VisualStudio.Editor.Verify.CurrentTokenType("struct name");
+            VisualStudio.SolutionExplorer.RemovePackageReference(project, systemTextJson);
+            VisualStudio.SolutionExplorer.RestoreNuGetPackages(project);
+            VisualStudio.Editor.Verify.CurrentTokenType("identifier");
+        }
+
         public virtual void ProjectReference()
         {
             var project = new ProjectUtils.Project(ProjectName);
diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspacesNetCore.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspacesNetCore.cs
index 2e366de400a58..5b8cf69a935b9 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspacesNetCore.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspacesNetCore.cs
@@ -40,7 +40,7 @@ public override void MetadataReference()
             VisualStudio.SolutionExplorer.EditProjectFile(project);
             VisualStudio.Editor.SetText(@"<Project Sdk=""Microsoft.NET.Sdk"">
   <PropertyGroup>
-    <TargetFramework>net462</TargetFramework>
+    <TargetFramework>net461</TargetFramework>
   </PropertyGroup>
 </Project>");
             VisualStudio.SolutionExplorer.SaveAll();
@@ -49,7 +49,7 @@ public override void MetadataReference()
             // https://github.com/dotnet/roslyn/issues/34264
             VisualStudio.Workspace.WaitForAllAsyncOperations(Helper.HangMitigatingTimeout);
             VisualStudio.SolutionExplorer.OpenFile(project, "Class1.cs");
-            base.MetadataReference();
+            base.PackageReference();
         }
 
         [WpfFact]

From 66b3af7166f6da30089b2c512966c8219ea51110 Mon Sep 17 00:00:00 2001
From: Youssef Victor <youssefvictor00@gmail.com>
Date: Tue, 4 Jan 2022 11:52:38 +0200
Subject: [PATCH 196/444] Fix branch URLs in Language Feature Status (#58011)

---
 docs/Language Feature Status.md | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/docs/Language Feature Status.md b/docs/Language Feature Status.md
index 15b16f46a7454..6676470c7d0e8 100644
--- a/docs/Language Feature Status.md	
+++ b/docs/Language Feature Status.md	
@@ -13,17 +13,16 @@ efforts behind them.
 | [Newlines in interpolations](https://github.com/dotnet/csharplang/issues/4935) | main | [Merged in 17.1p1](https://github.com/dotnet/roslyn/issues/57154) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) | [jcouv](https://github.com/jcouv), [chsienki](https://github.com/chsienki) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) |
 | [List patterns](https://github.com/dotnet/csharplang/issues/3435) | [list-patterns](https://github.com/dotnet/roslyn/tree/features/list-patterns) | [Merged in 17.1p2](https://github.com/dotnet/roslyn/issues/51289) | [alrz](https://github.com/alrz) | [jcouv](https://github.com/jcouv), [333fred](https://github.com/333fred) | [333fred](https://github.com/333fred) |
 | [Parameter null-checking](https://github.com/dotnet/csharplang/issues/2145) | [param-nullchecking](https://github.com/dotnet/roslyn/tree/features/param-nullchecking) | [In Progress](https://github.com/dotnet/roslyn/issues/36024) | [RikkiGibson](https://github.com/RikkiGibson), [fayrose](https://github.com/fayrose) | [cston](https://github.com/cston), [chsienki](https://github.com/chsienki) | [jaredpar](https://github.com/jaredpar) |
-| [Raw string literals](https://github.com/dotnet/csharplang/issues/4304) | [RawStringLiterals](https://github.com/dotnet/roslyn/tree/features/features/RawStringLiterals) | [In Progress](https://github.com/dotnet/roslyn/issues/55306) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) | [jcouv](https://github.com/jcouv) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) |
+| [Raw string literals](https://github.com/dotnet/csharplang/issues/4304) | [RawStringLiterals](https://github.com/dotnet/roslyn/tree/features/RawStringLiterals) | [In Progress](https://github.com/dotnet/roslyn/issues/55306) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) | [jcouv](https://github.com/jcouv) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) |
 | [nameof(parameter)](https://github.com/dotnet/csharplang/issues/373) | main | [In Progress](https://github.com/dotnet/roslyn/issues/40524) | [jcouv](https://github.com/jcouv) | TBD | [jcouv](https://github.com/jcouv) |
 | [Relax ordering of `ref` and `partial` modifiers](https://github.com/dotnet/csharplang/issues/946) | [ref-partial](https://github.com/dotnet/roslyn/tree/features/ref-partial) | In Progress | [alrz](https://github.com/alrz) | [gafter](https://github.com/gafter) | [jcouv](https://github.com/jcouv) |
 | [Generic attributes](https://github.com/dotnet/csharplang/issues/124) | [generic-attributes](https://github.com/dotnet/roslyn/tree/features/generic-attributes) | [Merged into 17.0p4 (preview langver)](https://github.com/dotnet/roslyn/issues/36285) | [AviAvni](https://github.com/AviAvni) | [RikkiGibson](https://github.com/RikkiGibson), [jcouv](https://github.com/jcouv) | [mattwar](https://github.com/mattwar) |
 | [Default in deconstruction](https://github.com/dotnet/roslyn/pull/25562) | [decon-default](https://github.com/dotnet/roslyn/tree/features/decon-default) | [Implemented](https://github.com/dotnet/roslyn/issues/25559) | [jcouv](https://github.com/jcouv) | [gafter](https://github.com/gafter) | [jcouv](https://github.com/jcouv) |
 | [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) |
 | [Required members](https://github.com/dotnet/csharplang/issues/3630) | [required-members](https://github.com/dotnet/roslyn/tree/features/required-members) | [In Progress](https://github.com/dotnet/roslyn/issues/57046) | [333fred](https://github.com/333fred) | [jcouv](https://github.com/jcouv), [RikkiGibson](https://github.com/RikkiGibson) | [333fred](https://github.com/333fred) |
-| [Top Level statement attribute specifiers](https://github.com/dotnet/csharplang/issues/5045) | [main-attributes](https://github.com/dotnet/roslyn/tree/features/features/main-attributes) | [In Progress](https://github.com/dotnet/roslyn/issues/57047) | [chsienki](https://github.com/chsienki) | TBD | [jaredpar](https://github.com/jaredpar) |
-| [Primary Constructors](https://github.com/dotnet/csharplang/issues/2691) | [primary-constructors](https://github.com/dotnet/roslyn/tree/features/features/primary-constructors) | [In Progress](https://github.com/dotnet/roslyn/issues/57048) | TBD | TBD | [MadsTorgersen](https://github.com/MadsTorgersen) |
-| [Params Span<T> + Stackalloc any array type](https://github.com/dotnet/csharplang/issues/1757) | [params-span](https://github.com/dotnet/roslyn/tree/features/features/params-span) | [In Progress](https://github.com/dotnet/roslyn/issues/57049) | [cston](https://github.com/cston) | TBD | [jaredpar](https://github.com/jaredpar) |
-
+| [Top Level statement attribute specifiers](https://github.com/dotnet/csharplang/issues/5045) | [main-attributes](https://github.com/dotnet/roslyn/tree/features/main-attributes) | [In Progress](https://github.com/dotnet/roslyn/issues/57047) | [chsienki](https://github.com/chsienki) | TBD | [jaredpar](https://github.com/jaredpar) |
+| [Primary Constructors](https://github.com/dotnet/csharplang/issues/2691) | [primary-constructors](https://github.com/dotnet/roslyn/tree/features/primary-constructors) | [In Progress](https://github.com/dotnet/roslyn/issues/57048) | TBD | TBD | [MadsTorgersen](https://github.com/MadsTorgersen) |
+| [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) |
   
 # C# 10.0
 

From fc1b5028a7ec1d4f66aff3ffdc4f7d81dab33366 Mon Sep 17 00:00:00 2001
From: Manish Vasani <mavasani@microsoft.com>
Date: Tue, 4 Jan 2022 05:49:23 -0800
Subject: [PATCH 197/444] Handle globalconfig files correctly in configuration
 code actions

Fixes #50444
---
 ...SeverityBasedSeverityConfigurationTests.cs | 95 +++++++++++++++++++
 ...SeverityBasedSeverityConfigurationTests.vb | 92 ++++++++++++++++++
 .../Configuration/ConfigurationUpdater.cs     | 17 +++-
 3 files changed, 203 insertions(+), 1 deletion(-)

diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/DotNetDiagnosticSeverityBasedSeverityConfigurationTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/DotNetDiagnosticSeverityBasedSeverityConfigurationTests.cs
index f29df8f347c07..967585dba31da 100644
--- a/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/DotNetDiagnosticSeverityBasedSeverityConfigurationTests.cs
+++ b/src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/DotNetDiagnosticSeverityBasedSeverityConfigurationTests.cs
@@ -295,6 +295,101 @@ class Program1 { }
 
 [*.cs]
 
+# XYZ0001: Title
+dotnet_diagnostic.XYZ0001.severity = none
+</AnalyzerConfigDocument>
+    </Project>
+</Workspace>";
+
+                await TestInRegularAndScriptAsync(input, expected, CodeActionIndex);
+            }
+
+            [ConditionalFact(typeof(IsEnglishLocal)), Trait(Traits.Feature, Traits.Features.CodeActionsConfiguration)]
+            public async Task ConfigureGlobalconfig_Empty_None()
+            {
+                var input = @"
+<Workspace>
+    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
+        <Document FilePath=""z:\\file.cs"">
+[|class Program1 { }|]
+        </Document>
+        <AnalyzerConfigDocument FilePath=""z:\\.globalconfig"">is_global = true</AnalyzerConfigDocument>
+    </Project>
+</Workspace>";
+
+                var expected = @"
+<Workspace>
+    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
+         <Document FilePath=""z:\\file.cs"">
+class Program1 { }
+        </Document>
+        <AnalyzerConfigDocument FilePath=""z:\\.globalconfig"">is_global = true
+
+# XYZ0001: Title
+dotnet_diagnostic.XYZ0001.severity = none
+</AnalyzerConfigDocument>
+    </Project>
+</Workspace>";
+
+                await TestInRegularAndScriptAsync(input, expected, CodeActionIndex);
+            }
+
+            [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConfiguration)]
+            public async Task ConfigureGlobalconfig_RuleExists_None()
+            {
+                var input = @"
+<Workspace>
+    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
+        <Document FilePath=""z:\\file.cs"">
+[|class Program1 { }|]
+        </Document>
+        <AnalyzerConfigDocument FilePath=""z:\\.globalconfig"">is_global = true   # Comment
+dotnet_diagnostic.XYZ0001.severity = suggestion   # Comment
+</AnalyzerConfigDocument>
+    </Project>
+</Workspace>";
+
+                var expected = @"
+<Workspace>
+    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
+         <Document FilePath=""z:\\file.cs"">
+class Program1 { }
+        </Document>
+        <AnalyzerConfigDocument FilePath=""z:\\.globalconfig"">is_global = true   # Comment
+dotnet_diagnostic.XYZ0001.severity = none   # Comment
+</AnalyzerConfigDocument>
+    </Project>
+</Workspace>";
+
+                await TestInRegularAndScriptAsync(input, expected, CodeActionIndex);
+            }
+
+            [ConditionalFact(typeof(IsEnglishLocal)), Trait(Traits.Feature, Traits.Features.CodeActionsConfiguration)]
+            public async Task ConfigureGlobalconfig_InvalidHeader_None()
+            {
+                var input = @"
+<Workspace>
+    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
+        <Document FilePath=""z:\\file.cs"">
+[|class Program1 { }|]
+        </Document>
+        <AnalyzerConfigDocument FilePath=""z:\\.globalconfig"">[*.vb]
+dotnet_diagnostic.XYZ0001.severity = suggestion
+</AnalyzerConfigDocument>
+    </Project>
+</Workspace>";
+
+                var expected = @"
+<Workspace>
+    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
+        <Document FilePath=""z:\\file.cs"">
+class Program1 { }
+        </Document>
+        <AnalyzerConfigDocument FilePath=""z:\\.globalconfig"">[*.vb]
+dotnet_diagnostic.XYZ0001.severity = suggestion
+
+[*.cs]
+
 # XYZ0001: Title
 dotnet_diagnostic.XYZ0001.severity = none
 </AnalyzerConfigDocument>
diff --git a/src/EditorFeatures/VisualBasicTest/Diagnostics/Configuration/ConfigureSeverity/DotNetDiagnosticSeverityBasedSeverityConfigurationTests.vb b/src/EditorFeatures/VisualBasicTest/Diagnostics/Configuration/ConfigureSeverity/DotNetDiagnosticSeverityBasedSeverityConfigurationTests.vb
index e3263737e8f5e..610ef32864f02 100644
--- a/src/EditorFeatures/VisualBasicTest/Diagnostics/Configuration/ConfigureSeverity/DotNetDiagnosticSeverityBasedSeverityConfigurationTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/Diagnostics/Configuration/ConfigureSeverity/DotNetDiagnosticSeverityBasedSeverityConfigurationTests.vb
@@ -195,6 +195,98 @@ End Class
         <AnalyzerConfigDocument FilePath=""z:\\.editorconfig"">[*.vb]
 dotnet_diagnostic.XYZ1111.severity = none
 
+# XYZ0001: Title
+dotnet_diagnostic.XYZ0001.severity = none
+</AnalyzerConfigDocument>
+    </Project>
+</Workspace>"
+                Await TestInRegularAndScriptAsync(input, expected, CodeActionIndex)
+            End Function
+
+            <ConditionalFact(GetType(IsEnglishLocal)), Trait(Traits.Feature, Traits.Features.CodeActionsConfiguration)>
+            Public Async Function ConfigureGlobalconfig_Empty_None() As Task
+                Dim input = "
+<Workspace>
+    <Project Language=""Visual Basic"" AssemblyName=""Assembly1"" CommonReferences=""true"">
+        <Document FilePath=""z:\\file.vb"">
+[|Class Program1
+End Class|]
+        </Document>
+        <AnalyzerConfigDocument FilePath=""z:\\.globalconfig"">is_global = true</AnalyzerConfigDocument>
+    </Project>
+</Workspace>"
+                Dim expected = "
+<Workspace>
+    <Project Language=""Visual Basic"" AssemblyName=""Assembly1"" CommonReferences=""true"">
+         <Document FilePath=""z:\\file.vb"">
+Class Program1
+End Class
+        </Document>
+        <AnalyzerConfigDocument FilePath=""z:\\.globalconfig"">is_global = true
+
+# XYZ0001: Title
+dotnet_diagnostic.XYZ0001.severity = none
+</AnalyzerConfigDocument>
+    </Project>
+</Workspace>"
+                Await TestInRegularAndScriptAsync(input, expected, CodeActionIndex)
+            End Function
+
+            <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConfiguration)>
+            Public Async Function ConfigureGlobalconfig_RuleExists_None() As Task
+                Dim input = "
+<Workspace>
+    <Project Language=""Visual Basic"" AssemblyName=""Assembly1"" CommonReferences=""true"">
+        <Document FilePath=""z:\\file.vb"">
+[|Class Program1
+End Class|]
+        </Document>
+        <AnalyzerConfigDocument FilePath=""z:\\.globalconfig"">is_global = true   # Comment
+dotnet_diagnostic.XYZ0001.severity = suggestion   # Comment
+</AnalyzerConfigDocument>
+    </Project>
+</Workspace>"
+                Dim expected = "
+<Workspace>
+    <Project Language=""Visual Basic"" AssemblyName=""Assembly1"" CommonReferences=""true"">
+         <Document FilePath=""z:\\file.vb"">
+Class Program1
+End Class
+        </Document>
+        <AnalyzerConfigDocument FilePath=""z:\\.globalconfig"">is_global = true   # Comment
+dotnet_diagnostic.XYZ0001.severity = none   # Comment
+</AnalyzerConfigDocument>
+    </Project>
+</Workspace>"
+                Await TestInRegularAndScriptAsync(input, expected, CodeActionIndex)
+            End Function
+
+            <ConditionalFact(GetType(IsEnglishLocal)), Trait(Traits.Feature, Traits.Features.CodeActionsConfiguration)>
+            Public Async Function ConfigureGlobalconfig_InvalidHeader_None() As Task
+                Dim input = "
+<Workspace>
+    <Project Language=""Visual Basic"" AssemblyName=""Assembly1"" CommonReferences=""true"">
+        <Document FilePath=""z:\\file.vb"">
+[|Class Program1
+End Class|]
+        </Document>
+        <AnalyzerConfigDocument FilePath=""z:\\.globalconfig"">[*.cs]
+dotnet_diagnostic.XYZ0001.severity = suggestion
+</AnalyzerConfigDocument>
+    </Project>
+</Workspace>"
+                Dim expected = "
+<Workspace>
+    <Project Language=""Visual Basic"" AssemblyName=""Assembly1"" CommonReferences=""true"">
+         <Document FilePath=""z:\\file.vb"">
+Class Program1
+End Class
+        </Document>
+        <AnalyzerConfigDocument FilePath=""z:\\.globalconfig"">[*.cs]
+dotnet_diagnostic.XYZ0001.severity = suggestion
+
+[*.vb]
+
 # XYZ0001: Title
 dotnet_diagnostic.XYZ0001.severity = none
 </AnalyzerConfigDocument>
diff --git a/src/Features/Core/Portable/CodeFixes/Configuration/ConfigurationUpdater.cs b/src/Features/Core/Portable/CodeFixes/Configuration/ConfigurationUpdater.cs
index 107c26f8d0467..4d56475ff006d 100644
--- a/src/Features/Core/Portable/CodeFixes/Configuration/ConfigurationUpdater.cs
+++ b/src/Features/Core/Portable/CodeFixes/Configuration/ConfigurationUpdater.cs
@@ -474,6 +474,7 @@ internal static bool TryGetEditorConfigStringParts(
             TextLine? lastValidSpecificHeaderSpanEnd = null;
 
             var textChange = new TextChange();
+            var isGlobalConfig = false;
 
             foreach (var curLine in result.Lines)
             {
@@ -494,6 +495,20 @@ internal static bool TryGetEditorConfigStringParts(
                     var severitySuffixInValue = groups[3].Value.ToString();
                     var commentValue = groups[4].Value.ToString();
 
+                    // Check for global config header: "is_global = true"
+                    if (mostRecentHeader == null &&
+                        lastValidHeader == null &&
+                        key.Equals("is_global", StringComparison.OrdinalIgnoreCase) &&
+                        value.Trim().Equals("true", StringComparison.OrdinalIgnoreCase) &&
+                        severitySuffixInValue.Length == 0)
+                    {
+                        isGlobalConfig = true;
+                        mostRecentHeader = curLine;
+                        lastValidHeader = curLine;
+                        lastValidHeaderSpanEnd = curLine;
+                        continue;
+                    }
+
                     // Verify the most recent header is a valid header
                     if (mostRecentHeader != null &&
                         lastValidHeader != null &&
@@ -573,7 +588,7 @@ internal static bool TryGetEditorConfigStringParts(
                         }
                     }
                 }
-                else if (s_headerPattern.IsMatch(curLineText.Trim()))
+                else if (!isGlobalConfig && s_headerPattern.IsMatch(curLineText.Trim()))
                 {
                     // We found a header entry such as '[*.cs]', '[*.vb]', etc.
                     // Verify that header is valid.

From c885d0cd1ed4c674d55fa5964a2f44e1615baf9c Mon Sep 17 00:00:00 2001
From: "dotnet-maestro[bot]"
 <42748379+dotnet-maestro[bot]@users.noreply.github.com>
Date: Tue, 4 Jan 2022 15:03:36 +0000
Subject: [PATCH 198/444] [main] Update dependencies from dotnet/arcade
 (#58484)

[main] Update dependencies from dotnet/arcade
---
 eng/Version.Details.xml                    |   8 +-
 eng/common/cross/arm/tizen-build-rootfs.sh |  35 +++++
 eng/common/cross/arm/tizen-fetch.sh        | 170 +++++++++++++++++++++
 eng/common/cross/arm/tizen/tizen.patch     |   9 ++
 eng/common/cross/build-rootfs.sh           |   4 +-
 eng/common/cross/toolchain.cmake           |  45 ++++--
 eng/common/native/init-compiler.sh         |  32 +++-
 global.json                                |   4 +-
 8 files changed, 279 insertions(+), 28 deletions(-)
 create mode 100644 eng/common/cross/arm/tizen-build-rootfs.sh
 create mode 100644 eng/common/cross/arm/tizen-fetch.sh
 create mode 100644 eng/common/cross/arm/tizen/tizen.patch

diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index 61ea8dfc0871d..ebb6fdb7f29e5 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -13,18 +13,18 @@
     </Dependency>
   </ProductDependencies>
   <ToolsetDependencies>
-    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="7.0.0-beta.21623.1">
+    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="7.0.0-beta.22053.2">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>4abaab2bf44d06638abeb23fc96c4f6eef58a2f0</Sha>
+      <Sha>a0f6d2432ce3d1bb30ee747bb534f477c75fd667</Sha>
       <SourceBuild RepoName="arcade" ManagedOnly="true" />
     </Dependency>
     <Dependency Name="Microsoft.Net.Compilers.Toolset" Version="4.1.0-2.21609.7">
       <Uri>https://github.com/dotnet/roslyn</Uri>
       <Sha>818313426323d979747781a17c78860c833776da</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="7.0.0-beta.21623.1">
+    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="7.0.0-beta.22053.2">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>4abaab2bf44d06638abeb23fc96c4f6eef58a2f0</Sha>
+      <Sha>a0f6d2432ce3d1bb30ee747bb534f477c75fd667</Sha>
     </Dependency>
   </ToolsetDependencies>
 </Dependencies>
diff --git a/eng/common/cross/arm/tizen-build-rootfs.sh b/eng/common/cross/arm/tizen-build-rootfs.sh
new file mode 100644
index 0000000000000..9fdb32e920e22
--- /dev/null
+++ b/eng/common/cross/arm/tizen-build-rootfs.sh
@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+set -e
+
+__ARM_HARDFP_CrossDir=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
+__TIZEN_CROSSDIR="$__ARM_HARDFP_CrossDir/tizen"
+
+if [[ -z "$ROOTFS_DIR" ]]; then
+    echo "ROOTFS_DIR is not defined."
+    exit 1;
+fi
+
+TIZEN_TMP_DIR=$ROOTFS_DIR/tizen_tmp
+mkdir -p $TIZEN_TMP_DIR
+
+# Download files
+echo ">>Start downloading files"
+VERBOSE=1 $__ARM_HARDFP_CrossDir/tizen-fetch.sh $TIZEN_TMP_DIR
+echo "<<Finish downloading files"
+
+echo ">>Start constructing Tizen rootfs"
+TIZEN_RPM_FILES=`ls $TIZEN_TMP_DIR/*.rpm`
+cd $ROOTFS_DIR
+for f in $TIZEN_RPM_FILES; do
+    rpm2cpio $f  | cpio -idm --quiet
+done
+echo "<<Finish constructing Tizen rootfs"
+
+# Cleanup tmp
+rm -rf $TIZEN_TMP_DIR
+
+# Configure Tizen rootfs
+echo ">>Start configuring Tizen rootfs"
+ln -sfn asm-arm ./usr/include/asm
+patch -p1 < $__TIZEN_CROSSDIR/tizen.patch
+echo "<<Finish configuring Tizen rootfs"
diff --git a/eng/common/cross/arm/tizen-fetch.sh b/eng/common/cross/arm/tizen-fetch.sh
new file mode 100644
index 0000000000000..eabd06c4afede
--- /dev/null
+++ b/eng/common/cross/arm/tizen-fetch.sh
@@ -0,0 +1,170 @@
+#!/usr/bin/env bash
+set -e
+
+if [[ -z "${VERBOSE// }" ]] || [ "$VERBOSE" -ne "$VERBOSE" ] 2>/dev/null; then
+	VERBOSE=0
+fi
+
+Log()
+{
+	if [ $VERBOSE -ge $1 ]; then
+		echo ${@:2}
+	fi
+}
+
+Inform()
+{
+	Log 1 -e "\x1B[0;34m$@\x1B[m"
+}
+
+Debug()
+{
+	Log 2 -e "\x1B[0;32m$@\x1B[m"
+}
+
+Error()
+{
+	>&2 Log 0 -e "\x1B[0;31m$@\x1B[m"
+}
+
+Fetch()
+{
+	URL=$1
+	FILE=$2
+	PROGRESS=$3
+	if [ $VERBOSE -ge 1 ] && [ $PROGRESS ]; then
+		CURL_OPT="--progress-bar"
+	else
+		CURL_OPT="--silent"
+	fi
+	curl $CURL_OPT $URL > $FILE
+}
+
+hash curl 2> /dev/null || { Error "Require 'curl' Aborting."; exit 1; }
+hash xmllint 2> /dev/null || { Error "Require 'xmllint' Aborting."; exit 1; }
+hash sha256sum 2> /dev/null || { Error "Require 'sha256sum' Aborting."; exit 1; }
+
+TMPDIR=$1
+if [ ! -d $TMPDIR ]; then
+	TMPDIR=./tizen_tmp
+	Debug "Create temporary directory : $TMPDIR"
+	mkdir -p $TMPDIR 
+fi
+
+TIZEN_URL=http://download.tizen.org/snapshots/tizen
+BUILD_XML=build.xml
+REPOMD_XML=repomd.xml
+PRIMARY_XML=primary.xml
+TARGET_URL="http://__not_initialized"
+
+Xpath_get()
+{
+	XPATH_RESULT=''
+	XPATH=$1
+	XML_FILE=$2
+	RESULT=$(xmllint --xpath $XPATH $XML_FILE)
+	if [[ -z ${RESULT// } ]]; then
+		Error "Can not find target from $XML_FILE"
+		Debug "Xpath = $XPATH"
+		exit 1
+	fi
+	XPATH_RESULT=$RESULT
+}
+
+fetch_tizen_pkgs_init()
+{
+	TARGET=$1
+	PROFILE=$2
+	Debug "Initialize TARGET=$TARGET, PROFILE=$PROFILE"
+
+	TMP_PKG_DIR=$TMPDIR/tizen_${PROFILE}_pkgs
+	if [ -d $TMP_PKG_DIR ]; then rm -rf $TMP_PKG_DIR; fi
+	mkdir -p $TMP_PKG_DIR
+
+	PKG_URL=$TIZEN_URL/$PROFILE/latest
+
+	BUILD_XML_URL=$PKG_URL/$BUILD_XML
+	TMP_BUILD=$TMP_PKG_DIR/$BUILD_XML
+	TMP_REPOMD=$TMP_PKG_DIR/$REPOMD_XML
+	TMP_PRIMARY=$TMP_PKG_DIR/$PRIMARY_XML
+	TMP_PRIMARYGZ=${TMP_PRIMARY}.gz
+
+	Fetch $BUILD_XML_URL $TMP_BUILD
+
+	Debug "fetch $BUILD_XML_URL to $TMP_BUILD"
+
+	TARGET_XPATH="//build/buildtargets/buildtarget[@name=\"$TARGET\"]/repo[@type=\"binary\"]/text()"
+	Xpath_get $TARGET_XPATH $TMP_BUILD
+	TARGET_PATH=$XPATH_RESULT
+	TARGET_URL=$PKG_URL/$TARGET_PATH
+
+	REPOMD_URL=$TARGET_URL/repodata/repomd.xml
+	PRIMARY_XPATH='string(//*[local-name()="data"][@type="primary"]/*[local-name()="location"]/@href)'
+
+	Fetch $REPOMD_URL $TMP_REPOMD
+
+	Debug "fetch $REPOMD_URL to $TMP_REPOMD"
+
+	Xpath_get $PRIMARY_XPATH $TMP_REPOMD
+	PRIMARY_XML_PATH=$XPATH_RESULT
+	PRIMARY_URL=$TARGET_URL/$PRIMARY_XML_PATH
+
+	Fetch $PRIMARY_URL $TMP_PRIMARYGZ
+
+	Debug "fetch $PRIMARY_URL to $TMP_PRIMARYGZ"
+
+	gunzip $TMP_PRIMARYGZ 
+
+	Debug "unzip $TMP_PRIMARYGZ to $TMP_PRIMARY" 
+}
+
+fetch_tizen_pkgs()
+{
+	ARCH=$1
+	PACKAGE_XPATH_TPL='string(//*[local-name()="metadata"]/*[local-name()="package"][*[local-name()="name"][text()="_PKG_"]][*[local-name()="arch"][text()="_ARCH_"]]/*[local-name()="location"]/@href)'
+
+	PACKAGE_CHECKSUM_XPATH_TPL='string(//*[local-name()="metadata"]/*[local-name()="package"][*[local-name()="name"][text()="_PKG_"]][*[local-name()="arch"][text()="_ARCH_"]]/*[local-name()="checksum"]/text())'
+
+	for pkg in ${@:2}
+	do
+		Inform "Fetching... $pkg"
+		XPATH=${PACKAGE_XPATH_TPL/_PKG_/$pkg}
+		XPATH=${XPATH/_ARCH_/$ARCH}
+		Xpath_get $XPATH $TMP_PRIMARY
+		PKG_PATH=$XPATH_RESULT
+
+		XPATH=${PACKAGE_CHECKSUM_XPATH_TPL/_PKG_/$pkg}
+		XPATH=${XPATH/_ARCH_/$ARCH}
+		Xpath_get $XPATH $TMP_PRIMARY
+		CHECKSUM=$XPATH_RESULT
+
+		PKG_URL=$TARGET_URL/$PKG_PATH
+		PKG_FILE=$(basename $PKG_PATH)
+		PKG_PATH=$TMPDIR/$PKG_FILE
+
+		Debug "Download $PKG_URL to $PKG_PATH"
+		Fetch $PKG_URL $PKG_PATH true
+
+		echo "$CHECKSUM $PKG_PATH" | sha256sum -c - > /dev/null
+		if [ $? -ne 0 ]; then
+			Error "Fail to fetch $PKG_URL to $PKG_PATH"
+			Debug "Checksum = $CHECKSUM"
+			exit 1
+		fi
+	done
+}
+
+Inform "Initialize arm base"
+fetch_tizen_pkgs_init standard base
+Inform "fetch common packages"
+fetch_tizen_pkgs armv7hl gcc gcc-devel-static glibc glibc-devel libicu libicu-devel libatomic linux-glibc-devel keyutils keyutils-devel libkeyutils
+Inform "fetch coreclr packages"
+fetch_tizen_pkgs armv7hl lldb lldb-devel libgcc libstdc++ libstdc++-devel libunwind libunwind-devel lttng-ust-devel lttng-ust userspace-rcu-devel userspace-rcu
+Inform "fetch corefx packages"
+fetch_tizen_pkgs armv7hl libcom_err libcom_err-devel zlib zlib-devel libopenssl11 libopenssl1.1-devel krb5 krb5-devel
+
+Inform "Initialize standard unified"
+fetch_tizen_pkgs_init standard unified
+Inform "fetch corefx packages"
+fetch_tizen_pkgs armv7hl gssdp gssdp-devel tizen-release
+
diff --git a/eng/common/cross/arm/tizen/tizen.patch b/eng/common/cross/arm/tizen/tizen.patch
new file mode 100644
index 0000000000000..fb12ade7250ae
--- /dev/null
+++ b/eng/common/cross/arm/tizen/tizen.patch
@@ -0,0 +1,9 @@
+diff -u -r a/usr/lib/libc.so b/usr/lib/libc.so
+--- a/usr/lib/libc.so	2016-12-30 23:00:08.284951863 +0900
++++ b/usr/lib/libc.so	2016-12-30 23:00:32.140951815 +0900
+@@ -2,4 +2,4 @@
+    Use the shared library, but some functions are only in
+    the static library, so try that secondarily.  */
+ OUTPUT_FORMAT(elf32-littlearm)
+-GROUP ( /lib/libc.so.6 /usr/lib/libc_nonshared.a  AS_NEEDED ( /lib/ld-linux-armhf.so.3 ) )
++GROUP ( libc.so.6 libc_nonshared.a  AS_NEEDED ( ld-linux-armhf.so.3 ) )
diff --git a/eng/common/cross/build-rootfs.sh b/eng/common/cross/build-rootfs.sh
index 5102245b7b5e3..e94d13d62ef64 100755
--- a/eng/common/cross/build-rootfs.sh
+++ b/eng/common/cross/build-rootfs.sh
@@ -185,8 +185,8 @@ while :; do
             __LLDB_Package="liblldb-6.0-dev"
             ;;
         tizen)
-            if [ "$__BuildArch" != "armel" ] && [ "$__BuildArch" != "arm64" ]; then
-                echo "Tizen is available only for armel and arm64."
+            if [ "$__BuildArch" != "arm" ] && [ "$__BuildArch" != "armel" ] && [ "$__BuildArch" != "arm64" ]; then
+                echo "Tizen is available only for arm, armel and arm64."
                 usage;
                 exit 1;
             fi
diff --git a/eng/common/cross/toolchain.cmake b/eng/common/cross/toolchain.cmake
index 6501c3a955f78..f7878dddd3921 100644
--- a/eng/common/cross/toolchain.cmake
+++ b/eng/common/cross/toolchain.cmake
@@ -3,18 +3,26 @@ set(CROSS_ROOTFS $ENV{ROOTFS_DIR})
 set(TARGET_ARCH_NAME $ENV{TARGET_BUILD_ARCH})
 if(EXISTS ${CROSS_ROOTFS}/bin/freebsd-version)
   set(CMAKE_SYSTEM_NAME FreeBSD)
+  set(FREEBSD 1)
 elseif(EXISTS ${CROSS_ROOTFS}/usr/platform/i86pc)
   set(CMAKE_SYSTEM_NAME SunOS)
   set(ILLUMOS 1)
 else()
   set(CMAKE_SYSTEM_NAME Linux)
+  set(LINUX 1)
 endif()
 set(CMAKE_SYSTEM_VERSION 1)
 
+if(EXISTS ${CROSS_ROOTFS}/etc/tizen-release)
+  set(TIZEN 1)
+elseif(EXISTS ${CROSS_ROOTFS}/android_platform)
+  set(ANDROID 1)
+endif()
+
 if(TARGET_ARCH_NAME STREQUAL "armel")
   set(CMAKE_SYSTEM_PROCESSOR armv7l)
   set(TOOLCHAIN "arm-linux-gnueabi")
-  if("$ENV{__DistroRid}" MATCHES "tizen.*")
+  if(TIZEN)
     set(TIZEN_TOOLCHAIN "armv7l-tizen-linux-gnueabi/9.2.0")
   endif()
 elseif(TARGET_ARCH_NAME STREQUAL "arm")
@@ -26,6 +34,9 @@ elseif(TARGET_ARCH_NAME STREQUAL "arm")
   else()
     set(TOOLCHAIN "arm-linux-gnueabihf")
   endif()
+  if(TIZEN)
+    set(TIZEN_TOOLCHAIN "armv7hl-tizen-linux-gnueabihf/9.2.0")
+  endif()
 elseif(TARGET_ARCH_NAME STREQUAL "arm64")
   set(CMAKE_SYSTEM_PROCESSOR aarch64)
   if(EXISTS ${CROSS_ROOTFS}/usr/lib/gcc/aarch64-alpine-linux-musl)
@@ -33,7 +44,7 @@ elseif(TARGET_ARCH_NAME STREQUAL "arm64")
   else()
     set(TOOLCHAIN "aarch64-linux-gnu")
   endif()
-  if("$ENV{__DistroRid}" MATCHES "tizen.*")
+  if(TIZEN)
     set(TIZEN_TOOLCHAIN "aarch64-tizen-linux-gnu/9.2.0")
   endif()
 elseif(TARGET_ARCH_NAME STREQUAL "s390x")
@@ -42,7 +53,7 @@ elseif(TARGET_ARCH_NAME STREQUAL "s390x")
 elseif(TARGET_ARCH_NAME STREQUAL "x86")
   set(CMAKE_SYSTEM_PROCESSOR i686)
   set(TOOLCHAIN "i686-linux-gnu")
-elseif (CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
+elseif (FREEBSD)
   set(CMAKE_SYSTEM_PROCESSOR "x86_64")
   set(triple "x86_64-unknown-freebsd12")
 elseif (ILLUMOS)
@@ -57,7 +68,11 @@ if(DEFINED ENV{TOOLCHAIN})
 endif()
 
 # Specify include paths
-if(DEFINED TIZEN_TOOLCHAIN)
+if(TIZEN)
+  if(TARGET_ARCH_NAME STREQUAL "arm")
+    include_directories(SYSTEM ${CROSS_ROOTFS}/usr/lib/gcc/${TIZEN_TOOLCHAIN}/include/c++/)
+    include_directories(SYSTEM ${CROSS_ROOTFS}/usr/lib/gcc/${TIZEN_TOOLCHAIN}/include/c++/armv7hl-tizen-linux-gnueabihf)
+  endif()
   if(TARGET_ARCH_NAME STREQUAL "armel")
     include_directories(SYSTEM ${CROSS_ROOTFS}/usr/lib/gcc/${TIZEN_TOOLCHAIN}/include/c++/)
     include_directories(SYSTEM ${CROSS_ROOTFS}/usr/lib/gcc/${TIZEN_TOOLCHAIN}/include/c++/armv7l-tizen-linux-gnueabi)
@@ -68,7 +83,7 @@ if(DEFINED TIZEN_TOOLCHAIN)
   endif()
 endif()
 
-if("$ENV{__DistroRid}" MATCHES "android.*")
+if(ANDROID)
     if(TARGET_ARCH_NAME STREQUAL "arm")
         set(ANDROID_ABI armeabi-v7a)
     elseif(TARGET_ARCH_NAME STREQUAL "arm64")
@@ -76,7 +91,9 @@ if("$ENV{__DistroRid}" MATCHES "android.*")
     endif()
 
     # extract platform number required by the NDK's toolchain
-    string(REGEX REPLACE ".*\\.([0-9]+)-.*" "\\1" ANDROID_PLATFORM "$ENV{__DistroRid}")
+    file(READ "${CROSS_ROOTFS}/android_platform" RID_FILE_CONTENTS)
+    string(REPLACE "RID=" "" ANDROID_RID "${RID_FILE_CONTENTS}")
+    string(REGEX REPLACE ".*\\.([0-9]+)-.*" "\\1" ANDROID_PLATFORM "${ANDROID_RID}")
 
     set(ANDROID_TOOLCHAIN clang)
     set(FEATURE_EVENT_TRACE 0) # disable event trace as there is no lttng-ust package in termux repository
@@ -85,7 +102,7 @@ if("$ENV{__DistroRid}" MATCHES "android.*")
 
     # include official NDK toolchain script
     include(${CROSS_ROOTFS}/../build/cmake/android.toolchain.cmake)
-elseif(CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
+elseif(FREEBSD)
     # we cross-compile by instructing clang
     set(CMAKE_C_COMPILER_TARGET ${triple})
     set(CMAKE_CXX_COMPILER_TARGET ${triple})
@@ -145,20 +162,20 @@ function(add_toolchain_linker_flag Flag)
   set("CMAKE_SHARED_LINKER_FLAGS${CONFIG_SUFFIX}_INIT" "${CMAKE_SHARED_LINKER_FLAGS${CONFIG_SUFFIX}_INIT} ${Flag}" PARENT_SCOPE)
 endfunction()
 
-if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+if(LINUX)
   add_toolchain_linker_flag("-Wl,--rpath-link=${CROSS_ROOTFS}/lib/${TOOLCHAIN}")
   add_toolchain_linker_flag("-Wl,--rpath-link=${CROSS_ROOTFS}/usr/lib/${TOOLCHAIN}")
 endif()
 
-if(TARGET_ARCH_NAME STREQUAL "armel")
-  if(DEFINED TIZEN_TOOLCHAIN) # For Tizen only
+if(TARGET_ARCH_NAME MATCHES "^(arm|armel)$")
+  if(TIZEN)
     add_toolchain_linker_flag("-B${CROSS_ROOTFS}/usr/lib/gcc/${TIZEN_TOOLCHAIN}")
     add_toolchain_linker_flag("-L${CROSS_ROOTFS}/lib")
     add_toolchain_linker_flag("-L${CROSS_ROOTFS}/usr/lib")
     add_toolchain_linker_flag("-L${CROSS_ROOTFS}/usr/lib/gcc/${TIZEN_TOOLCHAIN}")
   endif()
 elseif(TARGET_ARCH_NAME STREQUAL "arm64")
-  if(DEFINED TIZEN_TOOLCHAIN) # For Tizen only
+  if(TIZEN)
     add_toolchain_linker_flag("-B${CROSS_ROOTFS}/usr/lib64/gcc/${TIZEN_TOOLCHAIN}")
     add_toolchain_linker_flag("-L${CROSS_ROOTFS}/lib64")
     add_toolchain_linker_flag("-L${CROSS_ROOTFS}/usr/lib64")
@@ -177,7 +194,7 @@ endif()
 
 # Specify compile options
 
-if((TARGET_ARCH_NAME MATCHES "^(arm|armel|arm64|s390x)$" AND NOT "$ENV{__DistroRid}" MATCHES "android.*") OR ILLUMOS)
+if((TARGET_ARCH_NAME MATCHES "^(arm|armel|arm64|s390x)$" AND NOT ANDROID) OR ILLUMOS)
   set(CMAKE_C_COMPILER_TARGET ${TOOLCHAIN})
   set(CMAKE_CXX_COMPILER_TARGET ${TOOLCHAIN})
   set(CMAKE_ASM_COMPILER_TARGET ${TOOLCHAIN})
@@ -204,8 +221,8 @@ elseif(TARGET_ARCH_NAME STREQUAL "x86")
   add_compile_options(-Wno-error=unused-command-line-argument)
 endif()
 
-if(DEFINED TIZEN_TOOLCHAIN)
-  if(TARGET_ARCH_NAME MATCHES "^(armel|arm64)$")
+if(TIZEN)
+  if(TARGET_ARCH_NAME MATCHES "^(arm|armel|arm64)$")
     add_compile_options(-Wno-deprecated-declarations) # compile-time option
     add_compile_options(-D__extern_always_inline=inline) # compile-time option
   endif()
diff --git a/eng/common/native/init-compiler.sh b/eng/common/native/init-compiler.sh
index e361e03fabdd2..6d7ba15e5f2b5 100644
--- a/eng/common/native/init-compiler.sh
+++ b/eng/common/native/init-compiler.sh
@@ -2,25 +2,45 @@
 #
 # This file detects the C/C++ compiler and exports it to the CC/CXX environment variables
 #
-# NOTE: some scripts source this file and rely on stdout being empty, make sure to not output anything here! 
+# NOTE: some scripts source this file and rely on stdout being empty, make sure to not output anything here!
 
 if [[ "$#" -lt 3 ]]; then
   echo "Usage..."
-  echo "init-compiler.sh <script directory> <Architecture> <compiler> <compiler major version> <compiler minor version>"
+  echo "init-compiler.sh <script directory> <Architecture> <compiler>"
   echo "Specify the script directory."
   echo "Specify the target architecture."
   echo "Specify the name of compiler (clang or gcc)."
-  echo "Specify the major version of compiler."
-  echo "Specify the minor version of compiler."
   exit 1
 fi
 
 nativescriptroot="$1"
 build_arch="$2"
 compiler="$3"
+
+case "$compiler" in
+    clang*|-clang*|--clang*)
+        # clangx.y or clang-x.y
+        version="$(echo "$compiler" | tr -d '[:alpha:]-=')"
+        parts=(${version//./ })
+        majorVersion="${parts[0]}"
+        minorVersion="${parts[1]}"
+        if [[ -z "$minorVersion" && "$majorVersion" -le 6 ]]; then
+            minorVersion=0;
+        fi
+        compiler=clang
+        ;;
+
+    gcc*|-gcc*|--gcc*)
+        # gccx.y or gcc-x.y
+        version="$(echo "$compiler" | tr -d '[:alpha:]-=')"
+        parts=(${version//./ })
+        majorVersion="${parts[0]}"
+        minorVersion="${parts[1]}"
+        compiler=gcc
+        ;;
+esac
+
 cxxCompiler="$compiler++"
-majorVersion="$4"
-minorVersion="$5"
 
 . "$nativescriptroot"/../pipeline-logging-functions.sh
 
diff --git a/global.json b/global.json
index 59c01b0b4680d..3321e0dc9261a 100644
--- a/global.json
+++ b/global.json
@@ -12,7 +12,7 @@
     "xcopy-msbuild": "16.10.0-preview2"
   },
   "msbuild-sdks": {
-    "Microsoft.DotNet.Arcade.Sdk": "7.0.0-beta.21623.1",
-    "Microsoft.DotNet.Helix.Sdk": "7.0.0-beta.21623.1"
+    "Microsoft.DotNet.Arcade.Sdk": "7.0.0-beta.22053.2",
+    "Microsoft.DotNet.Helix.Sdk": "7.0.0-beta.22053.2"
   }
 }

From cf4f9dd181c9c9a9b465b88c45f32632ea57facc Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Tue, 4 Jan 2022 09:36:56 -0800
Subject: [PATCH 199/444] Inline WorkCoordinator.ProcessProjectEvent

---
 .../SolutionCrawler/WorkCoordinator.cs        | 37 ++++++-------------
 1 file changed, 11 insertions(+), 26 deletions(-)

diff --git a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
index 5be133bc20d64..7c5e66ecb3881 100644
--- a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
+++ b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
@@ -271,11 +271,21 @@ private void ProcessEvent(WorkspaceChangeEventArgs args, string eventName)
                         ProcessSolutionEvent(args, eventName);
                         break;
                     case WorkspaceChangeKind.ProjectAdded:
+                        Contract.ThrowIfNull(args.ProjectId);
+                        EnqueueEvent(args.NewSolution, args.ProjectId, InvocationReasons.DocumentAdded, eventName);
+                        break;
+
                     case WorkspaceChangeKind.ProjectChanged:
                     case WorkspaceChangeKind.ProjectReloaded:
+                        Contract.ThrowIfNull(args.ProjectId);
+                        EnqueueEvent(args.OldSolution, args.NewSolution, args.ProjectId, eventName);
+                        break;
+
                     case WorkspaceChangeKind.ProjectRemoved:
-                        ProcessProjectEvent(args, eventName);
+                        Contract.ThrowIfNull(args.ProjectId);
+                        EnqueueEvent(args.OldSolution, args.ProjectId, InvocationReasons.DocumentRemoved, eventName);
                         break;
+
                     case WorkspaceChangeKind.DocumentAdded:
                     case WorkspaceChangeKind.DocumentReloaded:
                     case WorkspaceChangeKind.DocumentChanged:
@@ -345,31 +355,6 @@ private void ProcessDocumentEvent(WorkspaceChangeEventArgs e, string eventName)
                 }
             }
 
-            private void ProcessProjectEvent(WorkspaceChangeEventArgs e, string eventName)
-            {
-                switch (e.Kind)
-                {
-                    case WorkspaceChangeKind.ProjectAdded:
-                        Contract.ThrowIfNull(e.ProjectId);
-                        EnqueueEvent(e.NewSolution, e.ProjectId, InvocationReasons.DocumentAdded, eventName);
-                        break;
-
-                    case WorkspaceChangeKind.ProjectRemoved:
-                        Contract.ThrowIfNull(e.ProjectId);
-                        EnqueueEvent(e.OldSolution, e.ProjectId, InvocationReasons.DocumentRemoved, eventName);
-                        break;
-
-                    case WorkspaceChangeKind.ProjectChanged:
-                    case WorkspaceChangeKind.ProjectReloaded:
-                        Contract.ThrowIfNull(e.ProjectId);
-                        EnqueueEvent(e.OldSolution, e.NewSolution, e.ProjectId, eventName);
-                        break;
-
-                    default:
-                        throw ExceptionUtilities.UnexpectedValue(e.Kind);
-                }
-            }
-
             private void ProcessSolutionEvent(WorkspaceChangeEventArgs e, string eventName)
             {
                 switch (e.Kind)

From e26f0f760473aeb54e71a8988830295e376b1c6e Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Tue, 4 Jan 2022 09:37:10 -0800
Subject: [PATCH 200/444] Inline WorkCoordinator.ProcessSolutionEvent

---
 .../SolutionCrawler/WorkCoordinator.cs        | 38 ++++++-------------
 1 file changed, 11 insertions(+), 27 deletions(-)

diff --git a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
index 7c5e66ecb3881..b9152ca3d784b 100644
--- a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
+++ b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
@@ -264,12 +264,22 @@ private void ProcessEvent(WorkspaceChangeEventArgs args, string eventName)
                 switch (args.Kind)
                 {
                     case WorkspaceChangeKind.SolutionAdded:
+                        EnqueueEvent(args.NewSolution, InvocationReasons.DocumentAdded, eventName);
+                        break;
+
                     case WorkspaceChangeKind.SolutionChanged:
                     case WorkspaceChangeKind.SolutionReloaded:
+                        EnqueueEvent(args.OldSolution, args.NewSolution, eventName);
+                        break;
+
                     case WorkspaceChangeKind.SolutionRemoved:
+                        EnqueueEvent(args.OldSolution, InvocationReasons.SolutionRemoved, eventName);
+                        break;
+
                     case WorkspaceChangeKind.SolutionCleared:
-                        ProcessSolutionEvent(args, eventName);
+                        EnqueueEvent(args.OldSolution, InvocationReasons.DocumentRemoved, eventName);
                         break;
+
                     case WorkspaceChangeKind.ProjectAdded:
                         Contract.ThrowIfNull(args.ProjectId);
                         EnqueueEvent(args.NewSolution, args.ProjectId, InvocationReasons.DocumentAdded, eventName);
@@ -355,32 +365,6 @@ private void ProcessDocumentEvent(WorkspaceChangeEventArgs e, string eventName)
                 }
             }
 
-            private void ProcessSolutionEvent(WorkspaceChangeEventArgs e, string eventName)
-            {
-                switch (e.Kind)
-                {
-                    case WorkspaceChangeKind.SolutionAdded:
-                        EnqueueEvent(e.NewSolution, InvocationReasons.DocumentAdded, eventName);
-                        break;
-
-                    case WorkspaceChangeKind.SolutionRemoved:
-                        EnqueueEvent(e.OldSolution, InvocationReasons.SolutionRemoved, eventName);
-                        break;
-
-                    case WorkspaceChangeKind.SolutionCleared:
-                        EnqueueEvent(e.OldSolution, InvocationReasons.DocumentRemoved, eventName);
-                        break;
-
-                    case WorkspaceChangeKind.SolutionChanged:
-                    case WorkspaceChangeKind.SolutionReloaded:
-                        EnqueueEvent(e.OldSolution, e.NewSolution, eventName);
-                        break;
-
-                    default:
-                        throw ExceptionUtilities.UnexpectedValue(e.Kind);
-                }
-            }
-
             private void EnqueueEvent(Solution oldSolution, Solution newSolution, string eventName)
             {
                 _eventProcessingQueue.ScheduleTask(eventName,

From 5815cda1afc8572d35800e9b2110468f51e35642 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Tue, 4 Jan 2022 09:38:34 -0800
Subject: [PATCH 201/444] Inline WorkCoordinator.ProcessDocumentEvent

---
 .../SolutionCrawler/WorkCoordinator.cs        | 55 ++++++-------------
 1 file changed, 16 insertions(+), 39 deletions(-)

diff --git a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
index b9152ca3d784b..809519a5b367a 100644
--- a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
+++ b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
@@ -297,9 +297,21 @@ private void ProcessEvent(WorkspaceChangeEventArgs args, string eventName)
                         break;
 
                     case WorkspaceChangeKind.DocumentAdded:
+                        Contract.ThrowIfNull(args.DocumentId);
+                        EnqueueEvent(args.NewSolution, args.DocumentId, InvocationReasons.DocumentAdded, eventName);
+                        break;
+
                     case WorkspaceChangeKind.DocumentReloaded:
                     case WorkspaceChangeKind.DocumentChanged:
+                        Contract.ThrowIfNull(args.DocumentId);
+                        EnqueueEvent(args.OldSolution, args.NewSolution, args.DocumentId, eventName);
+                        break;
+
                     case WorkspaceChangeKind.DocumentRemoved:
+                        Contract.ThrowIfNull(args.DocumentId);
+                        EnqueueEvent(args.OldSolution, args.DocumentId, InvocationReasons.DocumentRemoved, eventName);
+                        break;
+
                     case WorkspaceChangeKind.AdditionalDocumentAdded:
                     case WorkspaceChangeKind.AdditionalDocumentRemoved:
                     case WorkspaceChangeKind.AdditionalDocumentChanged:
@@ -308,8 +320,11 @@ private void ProcessEvent(WorkspaceChangeEventArgs args, string eventName)
                     case WorkspaceChangeKind.AnalyzerConfigDocumentRemoved:
                     case WorkspaceChangeKind.AnalyzerConfigDocumentChanged:
                     case WorkspaceChangeKind.AnalyzerConfigDocumentReloaded:
-                        ProcessDocumentEvent(args, eventName);
+                        // If an additional file or .editorconfig has changed we need to reanalyze the entire project.
+                        Contract.ThrowIfNull(args.ProjectId);
+                        EnqueueEvent(args.NewSolution, args.ProjectId, InvocationReasons.AdditionalDocumentChanged, eventName);
                         break;
+
                     default:
                         throw ExceptionUtilities.UnexpectedValue(args.Kind);
                 }
@@ -327,44 +342,6 @@ private void OnDocumentClosed(object? sender, DocumentEventArgs e)
                     () => EnqueueWorkItemAsync(e.Document.Project, e.Document.Id, e.Document, InvocationReasons.DocumentClosed), _shutdownToken);
             }
 
-            private void ProcessDocumentEvent(WorkspaceChangeEventArgs e, string eventName)
-            {
-                switch (e.Kind)
-                {
-                    case WorkspaceChangeKind.DocumentAdded:
-                        Contract.ThrowIfNull(e.DocumentId);
-                        EnqueueEvent(e.NewSolution, e.DocumentId, InvocationReasons.DocumentAdded, eventName);
-                        break;
-
-                    case WorkspaceChangeKind.DocumentRemoved:
-                        Contract.ThrowIfNull(e.DocumentId);
-                        EnqueueEvent(e.OldSolution, e.DocumentId, InvocationReasons.DocumentRemoved, eventName);
-                        break;
-
-                    case WorkspaceChangeKind.DocumentReloaded:
-                    case WorkspaceChangeKind.DocumentChanged:
-                        Contract.ThrowIfNull(e.DocumentId);
-                        EnqueueEvent(e.OldSolution, e.NewSolution, e.DocumentId, eventName);
-                        break;
-
-                    case WorkspaceChangeKind.AdditionalDocumentAdded:
-                    case WorkspaceChangeKind.AdditionalDocumentRemoved:
-                    case WorkspaceChangeKind.AdditionalDocumentChanged:
-                    case WorkspaceChangeKind.AdditionalDocumentReloaded:
-                    case WorkspaceChangeKind.AnalyzerConfigDocumentAdded:
-                    case WorkspaceChangeKind.AnalyzerConfigDocumentRemoved:
-                    case WorkspaceChangeKind.AnalyzerConfigDocumentChanged:
-                    case WorkspaceChangeKind.AnalyzerConfigDocumentReloaded:
-                        // If an additional file or .editorconfig has changed we need to reanalyze the entire project.
-                        Contract.ThrowIfNull(e.ProjectId);
-                        EnqueueEvent(e.NewSolution, e.ProjectId, InvocationReasons.AdditionalDocumentChanged, eventName);
-                        break;
-
-                    default:
-                        throw ExceptionUtilities.UnexpectedValue(e.Kind);
-                }
-            }
-
             private void EnqueueEvent(Solution oldSolution, Solution newSolution, string eventName)
             {
                 _eventProcessingQueue.ScheduleTask(eventName,

From 6b25b1a6f8b9bd00ac2a103784f91d9a2f885b18 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Tue, 4 Jan 2022 09:48:27 -0800
Subject: [PATCH 202/444] Inline callback for EnqueueSolutionChangedEvent

---
 .../SolutionCrawler/WorkCoordinator.cs        | 50 +++++++++----------
 1 file changed, 25 insertions(+), 25 deletions(-)

diff --git a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
index 809519a5b367a..66fed5b525d62 100644
--- a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
+++ b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
@@ -269,7 +269,7 @@ private void ProcessEvent(WorkspaceChangeEventArgs args, string eventName)
 
                     case WorkspaceChangeKind.SolutionChanged:
                     case WorkspaceChangeKind.SolutionReloaded:
-                        EnqueueEvent(args.OldSolution, args.NewSolution, eventName);
+                        EnqueueSolutionChangedEvent(args.OldSolution, args.NewSolution, eventName);
                         break;
 
                     case WorkspaceChangeKind.SolutionRemoved:
@@ -342,10 +342,31 @@ private void OnDocumentClosed(object? sender, DocumentEventArgs e)
                     () => EnqueueWorkItemAsync(e.Document.Project, e.Document.Id, e.Document, InvocationReasons.DocumentClosed), _shutdownToken);
             }
 
-            private void EnqueueEvent(Solution oldSolution, Solution newSolution, string eventName)
+            private void EnqueueSolutionChangedEvent(Solution oldSolution, Solution newSolution, string eventName)
             {
-                _eventProcessingQueue.ScheduleTask(eventName,
-                    () => EnqueueWorkItemAsync(oldSolution, newSolution), _shutdownToken);
+                _eventProcessingQueue.ScheduleTask(
+                    eventName,
+                    async () =>
+                    {
+                        var solutionChanges = newSolution.GetChanges(oldSolution);
+
+                        // TODO: Async version for GetXXX methods?
+                        foreach (var addedProject in solutionChanges.GetAddedProjects())
+                        {
+                            await EnqueueWorkItemAsync(addedProject, InvocationReasons.DocumentAdded).ConfigureAwait(false);
+                        }
+
+                        foreach (var projectChanges in solutionChanges.GetProjectChanges())
+                        {
+                            await EnqueueWorkItemAsync(projectChanges).ConfigureAwait(continueOnCapturedContext: false);
+                        }
+
+                        foreach (var removedProject in solutionChanges.GetRemovedProjects())
+                        {
+                            await EnqueueWorkItemAsync(removedProject, InvocationReasons.DocumentRemoved).ConfigureAwait(false);
+                        }
+                    },
+                    _shutdownToken);
             }
 
             private void EnqueueEvent(Solution solution, InvocationReasons invocationReasons, string eventName)
@@ -451,27 +472,6 @@ private async Task EnqueueWorkItemAsync(
                         isLowPriority, analyzer, _listener.BeginAsyncOperation("WorkItem")));
             }
 
-            private async Task EnqueueWorkItemAsync(Solution oldSolution, Solution newSolution)
-            {
-                var solutionChanges = newSolution.GetChanges(oldSolution);
-
-                // TODO: Async version for GetXXX methods?
-                foreach (var addedProject in solutionChanges.GetAddedProjects())
-                {
-                    await EnqueueWorkItemAsync(addedProject, InvocationReasons.DocumentAdded).ConfigureAwait(false);
-                }
-
-                foreach (var projectChanges in solutionChanges.GetProjectChanges())
-                {
-                    await EnqueueWorkItemAsync(projectChanges).ConfigureAwait(continueOnCapturedContext: false);
-                }
-
-                foreach (var removedProject in solutionChanges.GetRemovedProjects())
-                {
-                    await EnqueueWorkItemAsync(removedProject, InvocationReasons.DocumentRemoved).ConfigureAwait(false);
-                }
-            }
-
             private async Task EnqueueWorkItemAsync(ProjectChanges projectChanges)
             {
                 await EnqueueProjectConfigurationChangeWorkItemAsync(projectChanges).ConfigureAwait(false);

From 6432819cc7eb7b2c55f2fce2d08db9f7fd5cb5dd Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Tue, 4 Jan 2022 09:50:06 -0800
Subject: [PATCH 203/444] Inline callback for EnqueueProjectChangedEvent

---
 .../SolutionCrawler/WorkCoordinator.cs        | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
index 66fed5b525d62..4f962c4187527 100644
--- a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
+++ b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
@@ -288,7 +288,7 @@ private void ProcessEvent(WorkspaceChangeEventArgs args, string eventName)
                     case WorkspaceChangeKind.ProjectChanged:
                     case WorkspaceChangeKind.ProjectReloaded:
                         Contract.ThrowIfNull(args.ProjectId);
-                        EnqueueEvent(args.OldSolution, args.NewSolution, args.ProjectId, eventName);
+                        EnqueueProjectChangedEvent(args.OldSolution, args.NewSolution, args.ProjectId, eventName);
                         break;
 
                     case WorkspaceChangeKind.ProjectRemoved:
@@ -375,10 +375,18 @@ private void EnqueueEvent(Solution solution, InvocationReasons invocationReasons
                     () => EnqueueWorkItemForSolutionAsync(solution, invocationReasons), _shutdownToken);
             }
 
-            private void EnqueueEvent(Solution oldSolution, Solution newSolution, ProjectId projectId, string eventName)
+            private void EnqueueProjectChangedEvent(Solution oldSolution, Solution newSolution, ProjectId projectId, string eventName)
             {
-                _eventProcessingQueue.ScheduleTask(eventName,
-                    () => EnqueueWorkItemAfterDiffAsync(oldSolution, newSolution, projectId), _shutdownToken);
+                _eventProcessingQueue.ScheduleTask(
+                    eventName,
+                    async () =>
+                    {
+                        var oldProject = oldSolution.GetRequiredProject(projectId);
+                        var newProject = newSolution.GetRequiredProject(projectId);
+
+                        await EnqueueWorkItemAsync(newProject.GetChanges(oldProject)).ConfigureAwait(false);
+                    },
+                    _shutdownToken);
             }
 
             private void EnqueueEvent(Solution solution, ProjectId projectId, InvocationReasons invocationReasons, string eventName)
@@ -567,14 +575,6 @@ private async Task EnqueueWorkItemForSolutionAsync(Solution solution, Invocation
                 }
             }
 
-            private async Task EnqueueWorkItemAfterDiffAsync(Solution oldSolution, Solution newSolution, ProjectId projectId)
-            {
-                var oldProject = oldSolution.GetRequiredProject(projectId);
-                var newProject = newSolution.GetRequiredProject(projectId);
-
-                await EnqueueWorkItemAsync(newProject.GetChanges(oldProject)).ConfigureAwait(continueOnCapturedContext: false);
-            }
-
             private async Task EnqueueWorkItemAfterDiffAsync(Solution oldSolution, Solution newSolution, DocumentId documentId)
             {
                 var oldProject = oldSolution.GetRequiredProject(documentId.ProjectId);

From 30d909e5abc51d8f459a3892a816f9774bc13a1c Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Tue, 4 Jan 2022 09:51:54 -0800
Subject: [PATCH 204/444] Inline callback for EnqueueDocumentChangedEvent

---
 .../SolutionCrawler/WorkCoordinator.cs        | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
index 4f962c4187527..f791c2b3bb090 100644
--- a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
+++ b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
@@ -304,7 +304,7 @@ private void ProcessEvent(WorkspaceChangeEventArgs args, string eventName)
                     case WorkspaceChangeKind.DocumentReloaded:
                     case WorkspaceChangeKind.DocumentChanged:
                         Contract.ThrowIfNull(args.DocumentId);
-                        EnqueueEvent(args.OldSolution, args.NewSolution, args.DocumentId, eventName);
+                        EnqueueDocumentChangedEvent(args.OldSolution, args.NewSolution, args.DocumentId, eventName);
                         break;
 
                     case WorkspaceChangeKind.DocumentRemoved:
@@ -401,11 +401,19 @@ private void EnqueueEvent(Solution solution, DocumentId documentId, InvocationRe
                     () => EnqueueWorkItemForDocumentAsync(solution, documentId, invocationReasons), _shutdownToken);
             }
 
-            private void EnqueueEvent(Solution oldSolution, Solution newSolution, DocumentId documentId, string eventName)
+            private void EnqueueDocumentChangedEvent(Solution oldSolution, Solution newSolution, DocumentId documentId, string eventName)
             {
                 // document changed event is the special one.
-                _eventProcessingQueue.ScheduleTask(eventName,
-                    () => EnqueueWorkItemAfterDiffAsync(oldSolution, newSolution, documentId), _shutdownToken);
+                _eventProcessingQueue.ScheduleTask(
+                    eventName,
+                    async () =>
+                    {
+                        var oldProject = oldSolution.GetRequiredProject(documentId.ProjectId);
+                        var newProject = newSolution.GetRequiredProject(documentId.ProjectId);
+
+                        await EnqueueWorkItemAsync(oldProject.GetRequiredDocument(documentId), newProject.GetRequiredDocument(documentId)).ConfigureAwait(false);
+                    },
+                    _shutdownToken);
             }
 
             private async Task EnqueueWorkItemAsync(Project project, DocumentId documentId, Document? document, InvocationReasons invocationReasons, SyntaxNode? changedMember = null)
@@ -575,14 +583,6 @@ private async Task EnqueueWorkItemForSolutionAsync(Solution solution, Invocation
                 }
             }
 
-            private async Task EnqueueWorkItemAfterDiffAsync(Solution oldSolution, Solution newSolution, DocumentId documentId)
-            {
-                var oldProject = oldSolution.GetRequiredProject(documentId.ProjectId);
-                var newProject = newSolution.GetRequiredProject(documentId.ProjectId);
-
-                await EnqueueWorkItemAsync(oldProject.GetRequiredDocument(documentId), newProject.GetRequiredDocument(documentId)).ConfigureAwait(continueOnCapturedContext: false);
-            }
-
             internal TestAccessor GetTestAccessor()
             {
                 return new TestAccessor(this);

From 3c3849442220ad995e94b9d2fb0d52036afbee9f Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Tue, 4 Jan 2022 09:56:09 -0800
Subject: [PATCH 205/444] Inline callback for EnqueueFullDocumentEvent

---
 .../SolutionCrawler/WorkCoordinator.cs        | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
index f791c2b3bb090..43d7d932a24ee 100644
--- a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
+++ b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
@@ -217,7 +217,7 @@ private void OnActiveDocumentChanged(object? sender, DocumentId? activeDocumentI
                 {
                     // When the active document changes and we are only analyzing the active file, trigger a document
                     // changed event to reanalyze the newly-active file.
-                    EnqueueEvent(solution, activeDocumentId, InvocationReasons.DocumentChanged, nameof(OnActiveDocumentChanged));
+                    EnqueueFullDocumentEvent(solution, activeDocumentId, InvocationReasons.DocumentChanged, nameof(OnActiveDocumentChanged));
                 }
             }
 
@@ -298,7 +298,7 @@ private void ProcessEvent(WorkspaceChangeEventArgs args, string eventName)
 
                     case WorkspaceChangeKind.DocumentAdded:
                         Contract.ThrowIfNull(args.DocumentId);
-                        EnqueueEvent(args.NewSolution, args.DocumentId, InvocationReasons.DocumentAdded, eventName);
+                        EnqueueFullDocumentEvent(args.NewSolution, args.DocumentId, InvocationReasons.DocumentAdded, eventName);
                         break;
 
                     case WorkspaceChangeKind.DocumentReloaded:
@@ -309,7 +309,7 @@ private void ProcessEvent(WorkspaceChangeEventArgs args, string eventName)
 
                     case WorkspaceChangeKind.DocumentRemoved:
                         Contract.ThrowIfNull(args.DocumentId);
-                        EnqueueEvent(args.OldSolution, args.DocumentId, InvocationReasons.DocumentRemoved, eventName);
+                        EnqueueFullDocumentEvent(args.OldSolution, args.DocumentId, InvocationReasons.DocumentRemoved, eventName);
                         break;
 
                     case WorkspaceChangeKind.AdditionalDocumentAdded:
@@ -395,10 +395,16 @@ private void EnqueueEvent(Solution solution, ProjectId projectId, InvocationReas
                     () => EnqueueWorkItemForProjectAsync(solution, projectId, invocationReasons), _shutdownToken);
             }
 
-            private void EnqueueEvent(Solution solution, DocumentId documentId, InvocationReasons invocationReasons, string eventName)
+            private void EnqueueFullDocumentEvent(Solution solution, DocumentId documentId, InvocationReasons invocationReasons, string eventName)
             {
-                _eventProcessingQueue.ScheduleTask(eventName,
-                    () => EnqueueWorkItemForDocumentAsync(solution, documentId, invocationReasons), _shutdownToken);
+                _eventProcessingQueue.ScheduleTask(
+                    eventName,
+                    () =>
+                    {
+                        var project = solution.GetRequiredProject(documentId.ProjectId);
+                        return EnqueueWorkItemAsync(project, documentId, document: null, invocationReasons);
+                    },
+                    _shutdownToken);
             }
 
             private void EnqueueDocumentChangedEvent(Solution oldSolution, Solution newSolution, DocumentId documentId, string eventName)
@@ -562,12 +568,6 @@ private async Task EnqueueWorkItemAsync(Document oldDocument, Document newDocume
                 }
             }
 
-            private Task EnqueueWorkItemForDocumentAsync(Solution solution, DocumentId documentId, InvocationReasons invocationReasons)
-            {
-                var project = solution.GetRequiredProject(documentId.ProjectId);
-                return EnqueueWorkItemAsync(project, documentId, document: null, invocationReasons);
-            }
-
             private Task EnqueueWorkItemForProjectAsync(Solution solution, ProjectId projectId, InvocationReasons invocationReasons)
             {
                 var project = solution.GetRequiredProject(projectId);

From 1c7f6ac147f0345e4254f905f4fc02bc76cc4cb8 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Tue, 4 Jan 2022 10:02:18 -0800
Subject: [PATCH 206/444] Inline callback for EnqueueFullSolutionEvent

---
 .../SolutionCrawler/WorkCoordinator.cs        | 28 +++++++++----------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
index 43d7d932a24ee..9a5254532392d 100644
--- a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
+++ b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
@@ -264,7 +264,7 @@ private void ProcessEvent(WorkspaceChangeEventArgs args, string eventName)
                 switch (args.Kind)
                 {
                     case WorkspaceChangeKind.SolutionAdded:
-                        EnqueueEvent(args.NewSolution, InvocationReasons.DocumentAdded, eventName);
+                        EnqueueFullSolutionEvent(args.NewSolution, InvocationReasons.DocumentAdded, eventName);
                         break;
 
                     case WorkspaceChangeKind.SolutionChanged:
@@ -273,11 +273,11 @@ private void ProcessEvent(WorkspaceChangeEventArgs args, string eventName)
                         break;
 
                     case WorkspaceChangeKind.SolutionRemoved:
-                        EnqueueEvent(args.OldSolution, InvocationReasons.SolutionRemoved, eventName);
+                        EnqueueFullSolutionEvent(args.OldSolution, InvocationReasons.SolutionRemoved, eventName);
                         break;
 
                     case WorkspaceChangeKind.SolutionCleared:
-                        EnqueueEvent(args.OldSolution, InvocationReasons.DocumentRemoved, eventName);
+                        EnqueueFullSolutionEvent(args.OldSolution, InvocationReasons.DocumentRemoved, eventName);
                         break;
 
                     case WorkspaceChangeKind.ProjectAdded:
@@ -369,10 +369,18 @@ private void EnqueueSolutionChangedEvent(Solution oldSolution, Solution newSolut
                     _shutdownToken);
             }
 
-            private void EnqueueEvent(Solution solution, InvocationReasons invocationReasons, string eventName)
+            private void EnqueueFullSolutionEvent(Solution solution, InvocationReasons invocationReasons, string eventName)
             {
-                _eventProcessingQueue.ScheduleTask(eventName,
-                    () => EnqueueWorkItemForSolutionAsync(solution, invocationReasons), _shutdownToken);
+                _eventProcessingQueue.ScheduleTask(
+                    eventName,
+                    async () =>
+                    {
+                        foreach (var projectId in solution.ProjectIds)
+                        {
+                            await EnqueueWorkItemForProjectAsync(solution, projectId, invocationReasons).ConfigureAwait(false);
+                        }
+                    },
+                    _shutdownToken);
             }
 
             private void EnqueueProjectChangedEvent(Solution oldSolution, Solution newSolution, ProjectId projectId, string eventName)
@@ -575,14 +583,6 @@ private Task EnqueueWorkItemForProjectAsync(Solution solution, ProjectId project
                 return EnqueueWorkItemAsync(project, invocationReasons);
             }
 
-            private async Task EnqueueWorkItemForSolutionAsync(Solution solution, InvocationReasons invocationReasons)
-            {
-                foreach (var projectId in solution.ProjectIds)
-                {
-                    await EnqueueWorkItemForProjectAsync(solution, projectId, invocationReasons).ConfigureAwait(false);
-                }
-            }
-
             internal TestAccessor GetTestAccessor()
             {
                 return new TestAccessor(this);

From 56f09fc60782966389a93acfd8ee4f7844e52181 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: Tue, 4 Jan 2022 10:06:26 -0800
Subject: [PATCH 207/444] CodeFixContext cleanup (#58565)

---
 ...enerateDeconstructMethodCodeFixProvider.cs |  2 +-
 .../Core/Portable/CodeFixes/CodeFixService.cs |  4 +-
 .../AbstractGenerateMemberCodeFixProvider.cs  |  2 +-
 .../Suppression/WrapperCodeFixProvider.cs     |  2 +-
 .../Core/Portable/CodeFixes/CodeFixContext.cs | 96 +++++--------------
 .../VSTypeScriptCodeFixContextExtensions.cs   | 17 ++++
 6 files changed, 45 insertions(+), 78 deletions(-)
 create mode 100644 src/Workspaces/Core/Portable/ExternalAccess/VSTypeScript/Api/VSTypeScriptCodeFixContextExtensions.cs

diff --git a/src/Features/CSharp/Portable/CodeFixes/GenerateMethod/GenerateDeconstructMethodCodeFixProvider.cs b/src/Features/CSharp/Portable/CodeFixes/GenerateMethod/GenerateDeconstructMethodCodeFixProvider.cs
index 8739a7c95b474..b48e6c487dc6b 100644
--- a/src/Features/CSharp/Portable/CodeFixes/GenerateMethod/GenerateDeconstructMethodCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/CodeFixes/GenerateMethod/GenerateDeconstructMethodCodeFixProvider.cs
@@ -42,7 +42,7 @@ public override FixAllProvider GetFixAllProvider()
         public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
         {
             // Not supported in REPL
-            if (context.Project.IsSubmission)
+            if (context.Document.Project.IsSubmission)
             {
                 return;
             }
diff --git a/src/Features/Core/Portable/CodeFixes/CodeFixService.cs b/src/Features/Core/Portable/CodeFixes/CodeFixService.cs
index 746329986d348..a33099b6eb8bf 100644
--- a/src/Features/Core/Portable/CodeFixes/CodeFixService.cs
+++ b/src/Features/Core/Portable/CodeFixes/CodeFixService.cs
@@ -510,9 +510,8 @@ private static async Task<ImmutableArray<CodeFix>> GetCodeFixesAsync(
                         }
                     }
                 },
-                verifyArguments: false,
                 isBlocking,
-                cancellationToken: cancellationToken);
+                cancellationToken);
 
             var task = fixer.RegisterCodeFixesAsync(context) ?? Task.CompletedTask;
             await task.ConfigureAwait(false);
@@ -781,7 +780,6 @@ private async Task<bool> ContainsAnyFixAsync(
                         fixes.Add(new CodeFix(document.Project, action, applicableDiagnostics));
                     }
                 },
-                verifyArguments: false,
                 cancellationToken: cancellationToken);
 
             var extensionManager = document.Project.Solution.Workspace.Services.GetRequiredService<IExtensionManager>();
diff --git a/src/Features/Core/Portable/CodeFixes/GenerateMember/AbstractGenerateMemberCodeFixProvider.cs b/src/Features/Core/Portable/CodeFixes/GenerateMember/AbstractGenerateMemberCodeFixProvider.cs
index 0963f4fd751de..83c378af27d1a 100644
--- a/src/Features/Core/Portable/CodeFixes/GenerateMember/AbstractGenerateMemberCodeFixProvider.cs
+++ b/src/Features/Core/Portable/CodeFixes/GenerateMember/AbstractGenerateMemberCodeFixProvider.cs
@@ -30,7 +30,7 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
         {
             // TODO: https://github.com/dotnet/roslyn/issues/5777
             // Not supported in REPL for now.
-            if (context.Project.IsSubmission)
+            if (context.Document.Project.IsSubmission)
             {
                 return;
             }
diff --git a/src/Features/Core/Portable/CodeFixes/Suppression/WrapperCodeFixProvider.cs b/src/Features/Core/Portable/CodeFixes/Suppression/WrapperCodeFixProvider.cs
index 0039393d216e7..7f7de1851040d 100644
--- a/src/Features/Core/Portable/CodeFixes/Suppression/WrapperCodeFixProvider.cs
+++ b/src/Features/Core/Portable/CodeFixes/Suppression/WrapperCodeFixProvider.cs
@@ -39,7 +39,7 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
             var projectDiagnostics = diagnostics.Where(d => !d.Location.IsInSource).ToImmutableArray();
             if (!projectDiagnostics.IsEmpty)
             {
-                var suppressionFixes = await _suppressionFixProvider.GetFixesAsync(context.Project, projectDiagnostics, context.CancellationToken).ConfigureAwait(false);
+                var suppressionFixes = await _suppressionFixProvider.GetFixesAsync(context.Document.Project, projectDiagnostics, context.CancellationToken).ConfigureAwait(false);
                 RegisterSuppressionFixes(context, suppressionFixes);
             }
         }
diff --git a/src/Workspaces/Core/Portable/CodeFixes/CodeFixContext.cs b/src/Workspaces/Core/Portable/CodeFixes/CodeFixContext.cs
index 836beb7b42e19..f7c41df235f9d 100644
--- a/src/Workspaces/Core/Portable/CodeFixes/CodeFixContext.cs
+++ b/src/Workspaces/Core/Portable/CodeFixes/CodeFixContext.cs
@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis.CodeActions;
@@ -15,33 +16,27 @@ namespace Microsoft.CodeAnalysis.CodeFixes
     /// <summary>
     /// Context for code fixes provided by a <see cref="CodeFixProvider"/>.
     /// </summary>
-    public struct CodeFixContext : ITypeScriptCodeFixContext
+    public readonly struct CodeFixContext : ITypeScriptCodeFixContext
     {
         private readonly Document _document;
-        private readonly Project _project;
         private readonly TextSpan _span;
         private readonly ImmutableArray<Diagnostic> _diagnostics;
         private readonly CancellationToken _cancellationToken;
         private readonly Action<CodeAction, ImmutableArray<Diagnostic>> _registerCodeFix;
 
         /// <summary>
-        /// Document corresponding to the <see cref="CodeFixContext.Span"/> to fix.
+        /// Document corresponding to the <see cref="Span"/> to fix.
         /// </summary>
         public Document Document => _document;
 
         /// <summary>
-        /// Project corresponding to the diagnostics to fix.
-        /// </summary>
-        internal Project Project => _project;
-
-        /// <summary>
-        /// Text span within the <see cref="CodeFixContext.Document"/> to fix.
+        /// Text span within the <see cref="Document"/> to fix.
         /// </summary>
         public TextSpan Span => _span;
 
         /// <summary>
         /// Diagnostics to fix.
-        /// NOTE: All the diagnostics in this collection have the same <see cref="CodeFixContext.Span"/>.
+        /// NOTE: All the diagnostics in this collection have the same <see cref="Span"/>.
         /// </summary>
         public ImmutableArray<Diagnostic> Diagnostics => _diagnostics;
 
@@ -76,7 +71,12 @@ public CodeFixContext(
             ImmutableArray<Diagnostic> diagnostics,
             Action<CodeAction, ImmutableArray<Diagnostic>> registerCodeFix,
             CancellationToken cancellationToken)
-            : this(document, span, diagnostics, registerCodeFix, verifyArguments: true, cancellationToken: cancellationToken)
+            : this(document ?? throw new ArgumentNullException(nameof(document)),
+                   span,
+                   VerifyDiagnosticsArgument(diagnostics, span),
+                   registerCodeFix ?? throw new ArgumentNullException(nameof(registerCodeFix)),
+                   isBlocking: false,
+                   cancellationToken)
         {
         }
 
@@ -96,18 +96,12 @@ public CodeFixContext(
             Diagnostic diagnostic,
             Action<CodeAction, ImmutableArray<Diagnostic>> registerCodeFix,
             CancellationToken cancellationToken)
-            : this(document, diagnostic.Location.SourceSpan, ImmutableArray.Create(diagnostic), registerCodeFix, verifyArguments: true, cancellationToken: cancellationToken)
-        {
-        }
-
-        internal CodeFixContext(
-            Document document,
-            TextSpan span,
-            ImmutableArray<Diagnostic> diagnostics,
-            Action<CodeAction, ImmutableArray<Diagnostic>> registerCodeFix,
-            bool verifyArguments,
-            CancellationToken cancellationToken)
-            : this(document, document.Project, span, diagnostics, registerCodeFix, verifyArguments, isBlocking: false, cancellationToken)
+            : this(document ?? throw new ArgumentNullException(nameof(document)),
+                   (diagnostic ?? throw new ArgumentNullException(nameof(diagnostic))).Location.SourceSpan,
+                   ImmutableArray.Create(diagnostic),
+                   registerCodeFix ?? throw new ArgumentNullException(nameof(registerCodeFix)),
+                   isBlocking: false,
+                   cancellationToken)
         {
         }
 
@@ -116,56 +110,17 @@ internal CodeFixContext(
             TextSpan span,
             ImmutableArray<Diagnostic> diagnostics,
             Action<CodeAction, ImmutableArray<Diagnostic>> registerCodeFix,
-            bool verifyArguments,
-            bool isBlocking,
-            CancellationToken cancellationToken)
-            : this(document, document.Project, span, diagnostics, registerCodeFix, verifyArguments, isBlocking, cancellationToken)
-        {
-        }
-
-        private CodeFixContext(
-            Document document,
-            Project project,
-            TextSpan span,
-            ImmutableArray<Diagnostic> diagnostics,
-            Action<CodeAction, ImmutableArray<Diagnostic>> registerCodeFix,
-            bool verifyArguments,
             bool isBlocking,
             CancellationToken cancellationToken)
         {
-            if (verifyArguments)
-            {
-                if (document == null)
-                {
-                    throw new ArgumentNullException(nameof(document));
-                }
-
-                if (registerCodeFix == null)
-                {
-                    throw new ArgumentNullException(nameof(registerCodeFix));
-                }
-
-                VerifyDiagnosticsArgument(diagnostics, span);
-            }
+            Debug.Assert(diagnostics.Any(d => d.Location.SourceSpan == span));
 
             _document = document;
-            _project = project;
             _span = span;
             _diagnostics = diagnostics;
             _registerCodeFix = registerCodeFix;
-            _cancellationToken = cancellationToken;
-
             _isBlocking = isBlocking;
-        }
-
-        internal CodeFixContext(
-            Document document,
-            Diagnostic diagnostic,
-            Action<CodeAction, ImmutableArray<Diagnostic>> registerCodeFix,
-            bool verifyArguments,
-            CancellationToken cancellationToken)
-            : this(document, diagnostic.Location.SourceSpan, ImmutableArray.Create(diagnostic), registerCodeFix, verifyArguments, cancellationToken)
-        {
+            _cancellationToken = cancellationToken;
         }
 
         /// <summary>
@@ -225,14 +180,9 @@ public void RegisterCodeFix(CodeAction action, ImmutableArray<Diagnostic> diagno
             _registerCodeFix(action, diagnostics);
         }
 
-        private static void VerifyDiagnosticsArgument(ImmutableArray<Diagnostic> diagnostics, TextSpan span)
+        private static ImmutableArray<Diagnostic> VerifyDiagnosticsArgument(ImmutableArray<Diagnostic> diagnostics, TextSpan span)
         {
-            if (diagnostics.IsDefault)
-            {
-                throw new ArgumentException(nameof(diagnostics));
-            }
-
-            if (diagnostics.Length == 0)
+            if (diagnostics.IsDefaultOrEmpty)
             {
                 throw new ArgumentException(WorkspacesResources.At_least_one_diagnostic_must_be_supplied, nameof(diagnostics));
             }
@@ -242,10 +192,12 @@ private static void VerifyDiagnosticsArgument(ImmutableArray<Diagnostic> diagnos
                 throw new ArgumentException(WorkspaceExtensionsResources.Supplied_diagnostic_cannot_be_null, nameof(diagnostics));
             }
 
-            if (diagnostics.Any(d => d.Location.SourceSpan != span))
+            if (diagnostics.Any((d, span) => d.Location.SourceSpan != span, span))
             {
                 throw new ArgumentException(string.Format(WorkspacesResources.Diagnostic_must_have_span_0, span.ToString()), nameof(diagnostics));
             }
+
+            return diagnostics;
         }
     }
 
diff --git a/src/Workspaces/Core/Portable/ExternalAccess/VSTypeScript/Api/VSTypeScriptCodeFixContextExtensions.cs b/src/Workspaces/Core/Portable/ExternalAccess/VSTypeScript/Api/VSTypeScriptCodeFixContextExtensions.cs
new file mode 100644
index 0000000000000..3dd5d9a7150cc
--- /dev/null
+++ b/src/Workspaces/Core/Portable/ExternalAccess/VSTypeScript/Api/VSTypeScriptCodeFixContextExtensions.cs
@@ -0,0 +1,17 @@
+// 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.Text;
+using Microsoft.CodeAnalysis.CodeFixes;
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.VSTypeScript.Api
+{
+    internal static class VSTypeScriptCodeFixContextExtensions
+    {
+        public static bool IsBlocking(this CodeFixContext context)
+            => ((ITypeScriptCodeFixContext)context).IsBlocking;
+    }
+}

From 9faa100273d76badda3d33bf1198d8e9240ae5cd Mon Sep 17 00:00:00 2001
From: AlekseyTs <AlekseyTs@users.noreply.github.com>
Date: Tue, 4 Jan 2022 10:07:05 -0800
Subject: [PATCH 208/444] Break binding cycles caused by type forwarders.
 (#58535)

Fixes #58517.
---
 .../Portable/Binder/Binder_Attributes.cs      |  26 ++-
 .../Binder/EarlyWellKnownAttributeBinder.cs   |  16 +-
 .../Symbols/Source/SourceAssemblySymbol.cs    |  61 +++++-
 .../Source/SourceComplexParameterSymbol.cs    |   4 +-
 .../SourceMethodSymbolWithAttributes.cs       |   2 +-
 .../Symbols/Source/SourceNamedTypeSymbol.cs   |  10 +-
 .../Source/SourcePropertySymbolBase.cs        |   2 +-
 .../Portable/Symbols/Symbol_Attributes.cs     |  12 +-
 .../Test/Symbol/Symbols/SymbolErrorTests.cs   | 193 ++++++++++++++++++
 9 files changed, 299 insertions(+), 27 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Attributes.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Attributes.cs
index 8062aaefc2adc..951343dbe27cb 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Attributes.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Attributes.cs
@@ -26,7 +26,11 @@ internal partial class Binder
         //      [return: A2]
         //      public delegate void Goo();
         // attributesToBind will only contain first attribute syntax.
-        internal static void BindAttributeTypes(ImmutableArray<Binder> binders, ImmutableArray<AttributeSyntax> attributesToBind, Symbol ownerSymbol, NamedTypeSymbol[] boundAttributeTypes, BindingDiagnosticBag diagnostics)
+        internal static void BindAttributeTypes(
+            ImmutableArray<Binder> binders, ImmutableArray<AttributeSyntax> attributesToBind, Symbol ownerSymbol, NamedTypeSymbol[] boundAttributeTypes,
+            Action<AttributeSyntax>? beforeAttributePartBound,
+            Action<AttributeSyntax>? afterAttributePartBound,
+            BindingDiagnosticBag diagnostics)
         {
             Debug.Assert(binders.Any());
             Debug.Assert(attributesToBind.Any());
@@ -40,11 +44,16 @@ internal static void BindAttributeTypes(ImmutableArray<Binder> binders, Immutabl
                 if (boundAttributeTypes[i] is null)
                 {
                     var binder = binders[i];
+                    AttributeSyntax attributeToBind = attributesToBind[i];
+
+                    beforeAttributePartBound?.Invoke(attributeToBind);
 
                     // BindType for AttributeSyntax's name is handled specially during lookup, see Binder.LookupAttributeType.
                     // When looking up a name in attribute type context, we generate a diagnostic + error type if it is not an attribute type, i.e. named type deriving from System.Attribute.
                     // Hence we can assume here that BindType returns a NamedTypeSymbol.
-                    boundAttributeTypes[i] = (NamedTypeSymbol)binder.BindType(attributesToBind[i].Name, diagnostics).Type;
+                    boundAttributeTypes[i] = (NamedTypeSymbol)binder.BindType(attributeToBind.Name, diagnostics).Type;
+
+                    afterAttributePartBound?.Invoke(attributeToBind);
                 }
             }
         }
@@ -56,6 +65,8 @@ internal static void GetAttributes(
             ImmutableArray<NamedTypeSymbol> boundAttributeTypes,
             CSharpAttributeData?[] attributeDataArray,
             BoundAttribute?[]? boundAttributeArray,
+            Action<AttributeSyntax>? beforeAttributePartBound,
+            Action<AttributeSyntax>? afterAttributePartBound,
             BindingDiagnosticBag diagnostics)
         {
             Debug.Assert(binders.Any());
@@ -74,7 +85,7 @@ internal static void GetAttributes(
                 var attribute = (SourceAttributeData?)attributeDataArray[i];
                 if (attribute == null)
                 {
-                    (attributeDataArray[i], var boundAttribute) = binder.GetAttribute(attributeSyntax, boundAttributeType, diagnostics);
+                    (attributeDataArray[i], var boundAttribute) = binder.GetAttribute(attributeSyntax, boundAttributeType, beforeAttributePartBound, afterAttributePartBound, diagnostics);
                     if (boundAttributeArray is not null)
                     {
                         boundAttributeArray[i] = boundAttribute;
@@ -103,10 +114,15 @@ internal static void GetAttributes(
 
         #region Bind Single Attribute
 
-        internal (CSharpAttributeData, BoundAttribute) GetAttribute(AttributeSyntax node, NamedTypeSymbol boundAttributeType, BindingDiagnosticBag diagnostics)
+        internal (CSharpAttributeData, BoundAttribute) GetAttribute(
+            AttributeSyntax node, NamedTypeSymbol boundAttributeType,
+            Action<AttributeSyntax>? beforeAttributePartBound,
+            Action<AttributeSyntax>? afterAttributePartBound,
+            BindingDiagnosticBag diagnostics)
         {
+            beforeAttributePartBound?.Invoke(node);
             var boundAttribute = new ExecutableCodeBinder(node, this.ContainingMemberOrLambda, this).BindAttribute(node, boundAttributeType, diagnostics);
-
+            afterAttributePartBound?.Invoke(node);
             return (GetAttribute(boundAttribute, diagnostics), boundAttribute);
         }
 
diff --git a/src/Compilers/CSharp/Portable/Binder/EarlyWellKnownAttributeBinder.cs b/src/Compilers/CSharp/Portable/Binder/EarlyWellKnownAttributeBinder.cs
index 1ed445563bb6a..149a790972594 100644
--- a/src/Compilers/CSharp/Portable/Binder/EarlyWellKnownAttributeBinder.cs
+++ b/src/Compilers/CSharp/Portable/Binder/EarlyWellKnownAttributeBinder.cs
@@ -23,10 +23,14 @@ internal EarlyWellKnownAttributeBinder(Binder enclosing)
         {
         }
 
-        internal (CSharpAttributeData, BoundAttribute) GetAttribute(AttributeSyntax node, NamedTypeSymbol boundAttributeType, out bool generatedDiagnostics)
+        internal (CSharpAttributeData, BoundAttribute) GetAttribute(
+            AttributeSyntax node, NamedTypeSymbol boundAttributeType,
+            Action<AttributeSyntax> beforeAttributePartBound,
+            Action<AttributeSyntax> afterAttributePartBound,
+            out bool generatedDiagnostics)
         {
             var dummyDiagnosticBag = new BindingDiagnosticBag(DiagnosticBag.GetInstance());
-            var result = base.GetAttribute(node, boundAttributeType, dummyDiagnosticBag);
+            var result = base.GetAttribute(node, boundAttributeType, beforeAttributePartBound, afterAttributePartBound, dummyDiagnosticBag);
             generatedDiagnostics = !dummyDiagnosticBag.DiagnosticBag.IsEmptyWithoutResolution;
             dummyDiagnosticBag.Free();
             return result;
@@ -36,12 +40,16 @@ internal EarlyWellKnownAttributeBinder(Binder enclosing)
         // This ensures that diagnostics from the early bound attributes are never preserved.
         [Obsolete("EarlyWellKnownAttributeBinder has a better overload - GetAttribute(AttributeSyntax, NamedTypeSymbol, out bool)", true)]
 #pragma warning disable format // https://github.com/dotnet/roslyn/issues/56498
-        internal new (CSharpAttributeData, BoundAttribute) GetAttribute(AttributeSyntax node, NamedTypeSymbol boundAttributeType, BindingDiagnosticBag diagnostics)
+        internal new (CSharpAttributeData, BoundAttribute) GetAttribute(
+            AttributeSyntax node, NamedTypeSymbol boundAttributeType,
+            Action<AttributeSyntax> beforeAttributePartBound,
+            Action<AttributeSyntax> afterAttributePartBound,
+            BindingDiagnosticBag diagnostics)
 #pragma warning restore format
         {
             Debug.Assert(false, "Don't call this overload.");
             diagnostics.Add(ErrorCode.ERR_InternalError, node.Location);
-            return base.GetAttribute(node, boundAttributeType, diagnostics);
+            return base.GetAttribute(node, boundAttributeType, beforeAttributePartBound, afterAttributePartBound, diagnostics);
         }
 
         /// <remarks>
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceAssemblySymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceAssemblySymbol.cs
index a6610b323fe83..edddf9d51e120 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceAssemblySymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceAssemblySymbol.cs
@@ -1686,6 +1686,10 @@ bool isPossibleAssemblyKeyFileAttribute(AttributeSyntax node)
         }
 #nullable disable
 
+        //Please don't use thread local storage widely. This is hoped to be the second one-off usage.
+        [ThreadStatic]
+        private static PooledHashSet<AttributeSyntax> t_forwardedTypesAttributesInProgress;
+
         /// <summary>
         /// This only forces binding of attributes that look like they may be forwarded types attributes (syntactically).
         /// </summary>
@@ -1698,11 +1702,46 @@ internal HashSet<NamedTypeSymbol> GetForwardedTypes()
                 return ((CommonAssemblyWellKnownAttributeData)attributesBag.DecodedWellKnownAttributeData)?.ForwardedTypes;
             }
 
-            attributesBag = null;
-            LoadAndValidateAttributes(OneOrMany.Create(GetAttributeDeclarations()), ref attributesBag, attributeMatchesOpt: this.IsPossibleForwardedTypesAttribute);
+            var allocate = t_forwardedTypesAttributesInProgress is null;
+
+            if (allocate)
+            {
+                t_forwardedTypesAttributesInProgress = PooledHashSet<AttributeSyntax>.GetInstance();
+            }
+
+            try
+            {
+                attributesBag = null;
+                LoadAndValidateAttributes(
+                    OneOrMany.Create(GetAttributeDeclarations()), ref attributesBag,
+                    attributeMatchesOpt: this.IsPossibleForwardedTypesAttribute,
+                    beforeAttributePartBound: BeforePossibleForwardedTypesAttributePartBound,
+                    afterAttributePartBound: AfterPossibleForwardedTypesAttributePartBound);
 
-            var wellKnownAttributeData = (CommonAssemblyWellKnownAttributeData)attributesBag?.DecodedWellKnownAttributeData;
-            return wellKnownAttributeData?.ForwardedTypes;
+                var wellKnownAttributeData = (CommonAssemblyWellKnownAttributeData)attributesBag?.DecodedWellKnownAttributeData;
+                return wellKnownAttributeData?.ForwardedTypes;
+            }
+            finally
+            {
+                if (allocate)
+                {
+                    var tofree = t_forwardedTypesAttributesInProgress;
+                    t_forwardedTypesAttributesInProgress = null;
+                    tofree.Free();
+                }
+            }
+        }
+
+        private static void BeforePossibleForwardedTypesAttributePartBound(AttributeSyntax node)
+        {
+            bool added = t_forwardedTypesAttributesInProgress.Add(node);
+            Debug.Assert(added);
+        }
+
+        private static void AfterPossibleForwardedTypesAttributePartBound(AttributeSyntax node)
+        {
+            bool removed = t_forwardedTypesAttributesInProgress.Remove(node);
+            Debug.Assert(removed);
         }
 
         private bool IsPossibleForwardedTypesAttribute(AttributeSyntax node)
@@ -1710,7 +1749,19 @@ private bool IsPossibleForwardedTypesAttribute(AttributeSyntax node)
             QuickAttributeChecker checker =
                 this.DeclaringCompilation.GetBinderFactory(node.SyntaxTree).GetBinder(node).QuickAttributeChecker;
 
-            return checker.IsPossibleMatch(node, QuickAttributes.TypeForwardedTo);
+            if (checker.IsPossibleMatch(node, QuickAttributes.TypeForwardedTo))
+            {
+                if (!t_forwardedTypesAttributesInProgress.Contains(node))
+                {
+                    return true;
+                }
+
+                // It looks like we started binding this attribute and circled back to it again.
+                // Let's skip it.
+                ;
+            }
+
+            return false;
         }
 
         private static IEnumerable<Cci.SecurityAttribute> GetSecurityAttributes(CustomAttributesBag<CSharpAttributeData> attributesBag)
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceComplexParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceComplexParameterSymbol.cs
index 13259d75e75c3..ad07645faa928 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceComplexParameterSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceComplexParameterSymbol.cs
@@ -618,7 +618,7 @@ internal override (CSharpAttributeData?, BoundAttribute?) EarlyDecodeWellKnownAt
                 else if (CSharpAttributeData.IsTargetEarlyAttribute(arguments.AttributeType, arguments.AttributeSyntax, AttributeDescription.CallerArgumentExpressionAttribute))
                 {
                     var index = -1;
-                    var (attributeData, _) = arguments.Binder.GetAttribute(arguments.AttributeSyntax, arguments.AttributeType, out _);
+                    var (attributeData, _) = arguments.Binder.GetAttribute(arguments.AttributeSyntax, arguments.AttributeType, beforeAttributePartBound: null, afterAttributePartBound: null, out _);
                     if (!attributeData.HasErrors)
                     {
                         var constructorArguments = attributeData.CommonConstructorArguments;
@@ -651,7 +651,7 @@ internal override (CSharpAttributeData?, BoundAttribute?) EarlyDecodeWellKnownAt
                 description.Equals(AttributeDescription.DateTimeConstantAttribute));
 
             bool hasAnyDiagnostics;
-            var (attributeData, boundAttribute) = arguments.Binder.GetAttribute(arguments.AttributeSyntax, arguments.AttributeType, out hasAnyDiagnostics);
+            var (attributeData, boundAttribute) = arguments.Binder.GetAttribute(arguments.AttributeSyntax, arguments.AttributeType, beforeAttributePartBound: null, afterAttributePartBound: null, out hasAnyDiagnostics);
             ConstantValue value;
             if (attributeData.HasErrors)
             {
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMethodSymbolWithAttributes.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceMethodSymbolWithAttributes.cs
index 60a068e423039..fb047ab0bfb2b 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMethodSymbolWithAttributes.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceMethodSymbolWithAttributes.cs
@@ -328,7 +328,7 @@ internal sealed override (CSharpAttributeData?, BoundAttribute?) EarlyDecodeWell
             {
                 if (CSharpAttributeData.IsTargetEarlyAttribute(arguments.AttributeType, arguments.AttributeSyntax, AttributeDescription.ConditionalAttribute))
                 {
-                    var (attributeData, boundAttribute) = arguments.Binder.GetAttribute(arguments.AttributeSyntax, arguments.AttributeType, out hasAnyDiagnostics);
+                    var (attributeData, boundAttribute) = arguments.Binder.GetAttribute(arguments.AttributeSyntax, arguments.AttributeType, beforeAttributePartBound: null, afterAttributePartBound: null, out hasAnyDiagnostics);
                     if (!attributeData.HasErrors)
                     {
                         string? name = attributeData.GetConstructorArgument<string>(0, SpecialType.System_String);
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamedTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamedTypeSymbol.cs
index 17633ef818e89..cacbf6cb60e00 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamedTypeSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamedTypeSymbol.cs
@@ -896,7 +896,7 @@ internal override (CSharpAttributeData?, BoundAttribute?) EarlyDecodeWellKnownAt
 
             if (CSharpAttributeData.IsTargetEarlyAttribute(arguments.AttributeType, arguments.AttributeSyntax, AttributeDescription.ComImportAttribute))
             {
-                (attributeData, boundAttribute) = arguments.Binder.GetAttribute(arguments.AttributeSyntax, arguments.AttributeType, out hasAnyDiagnostics);
+                (attributeData, boundAttribute) = arguments.Binder.GetAttribute(arguments.AttributeSyntax, arguments.AttributeType, beforeAttributePartBound: null, afterAttributePartBound: null, out hasAnyDiagnostics);
                 if (!attributeData.HasErrors)
                 {
                     arguments.GetOrCreateData<TypeEarlyWellKnownAttributeData>().HasComImportAttribute = true;
@@ -911,7 +911,7 @@ internal override (CSharpAttributeData?, BoundAttribute?) EarlyDecodeWellKnownAt
 
             if (CSharpAttributeData.IsTargetEarlyAttribute(arguments.AttributeType, arguments.AttributeSyntax, AttributeDescription.CodeAnalysisEmbeddedAttribute))
             {
-                (attributeData, boundAttribute) = arguments.Binder.GetAttribute(arguments.AttributeSyntax, arguments.AttributeType, out hasAnyDiagnostics);
+                (attributeData, boundAttribute) = arguments.Binder.GetAttribute(arguments.AttributeSyntax, arguments.AttributeType, beforeAttributePartBound: null, afterAttributePartBound: null, out hasAnyDiagnostics);
                 if (!attributeData.HasErrors)
                 {
                     arguments.GetOrCreateData<TypeEarlyWellKnownAttributeData>().HasCodeAnalysisEmbeddedAttribute = true;
@@ -926,7 +926,7 @@ internal override (CSharpAttributeData?, BoundAttribute?) EarlyDecodeWellKnownAt
 
             if (CSharpAttributeData.IsTargetEarlyAttribute(arguments.AttributeType, arguments.AttributeSyntax, AttributeDescription.ConditionalAttribute))
             {
-                (attributeData, boundAttribute) = arguments.Binder.GetAttribute(arguments.AttributeSyntax, arguments.AttributeType, out hasAnyDiagnostics);
+                (attributeData, boundAttribute) = arguments.Binder.GetAttribute(arguments.AttributeSyntax, arguments.AttributeType, beforeAttributePartBound: null, afterAttributePartBound: null, out hasAnyDiagnostics);
                 if (!attributeData.HasErrors)
                 {
                     string? name = attributeData.GetConstructorArgument<string>(0, SpecialType.System_String);
@@ -953,7 +953,7 @@ internal override (CSharpAttributeData?, BoundAttribute?) EarlyDecodeWellKnownAt
 
             if (CSharpAttributeData.IsTargetEarlyAttribute(arguments.AttributeType, arguments.AttributeSyntax, AttributeDescription.AttributeUsageAttribute))
             {
-                (attributeData, boundAttribute) = arguments.Binder.GetAttribute(arguments.AttributeSyntax, arguments.AttributeType, out hasAnyDiagnostics);
+                (attributeData, boundAttribute) = arguments.Binder.GetAttribute(arguments.AttributeSyntax, arguments.AttributeType, beforeAttributePartBound: null, afterAttributePartBound: null, out hasAnyDiagnostics);
                 if (!attributeData.HasErrors)
                 {
                     AttributeUsageInfo info = this.DecodeAttributeUsageAttribute(attributeData, arguments.AttributeSyntax, diagnose: false);
@@ -985,7 +985,7 @@ internal override (CSharpAttributeData?, BoundAttribute?) EarlyDecodeWellKnownAt
             // is an error scenario regardless (non-constant interpolated string), but it's good to get right as it will affect public API results.
             if (CSharpAttributeData.IsTargetEarlyAttribute(arguments.AttributeType, arguments.AttributeSyntax, AttributeDescription.InterpolatedStringHandlerAttribute))
             {
-                (attributeData, boundAttribute) = arguments.Binder.GetAttribute(arguments.AttributeSyntax, arguments.AttributeType, out hasAnyDiagnostics);
+                (attributeData, boundAttribute) = arguments.Binder.GetAttribute(arguments.AttributeSyntax, arguments.AttributeType, beforeAttributePartBound: null, afterAttributePartBound: null, out hasAnyDiagnostics);
                 if (!attributeData.HasErrors)
                 {
                     arguments.GetOrCreateData<TypeEarlyWellKnownAttributeData>().HasInterpolatedStringHandlerAttribute = true;
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourcePropertySymbolBase.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourcePropertySymbolBase.cs
index ee2f3ab954244..17df109569781 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourcePropertySymbolBase.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourcePropertySymbolBase.cs
@@ -1188,7 +1188,7 @@ internal override (CSharpAttributeData?, BoundAttribute?) EarlyDecodeWellKnownAt
             if (CSharpAttributeData.IsTargetEarlyAttribute(arguments.AttributeType, arguments.AttributeSyntax, AttributeDescription.IndexerNameAttribute))
             {
                 bool hasAnyDiagnostics;
-                (attributeData, boundAttribute) = arguments.Binder.GetAttribute(arguments.AttributeSyntax, arguments.AttributeType, out hasAnyDiagnostics);
+                (attributeData, boundAttribute) = arguments.Binder.GetAttribute(arguments.AttributeSyntax, arguments.AttributeType, beforeAttributePartBound: null, afterAttributePartBound: null, out hasAnyDiagnostics);
                 if (!attributeData.HasErrors)
                 {
                     string? indexerName = attributeData.CommonConstructorArguments[0].DecodeValue<string>(SpecialType.System_String);
diff --git a/src/Compilers/CSharp/Portable/Symbols/Symbol_Attributes.cs b/src/Compilers/CSharp/Portable/Symbols/Symbol_Attributes.cs
index 19f88aea373ae..472f6df41f379 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Symbol_Attributes.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Symbol_Attributes.cs
@@ -174,7 +174,7 @@ internal static bool EarlyDecodeDeprecatedOrExperimentalOrObsoleteAttribute(
             }
 
             bool hasAnyDiagnostics;
-            (attributeData, boundAttribute) = arguments.Binder.GetAttribute(syntax, type, out hasAnyDiagnostics);
+            (attributeData, boundAttribute) = arguments.Binder.GetAttribute(syntax, type, beforeAttributePartBound: null, afterAttributePartBound: null, out hasAnyDiagnostics);
             if (!attributeData.HasErrors)
             {
                 obsoleteData = attributeData.DecodeObsoleteAttribute(kind);
@@ -267,6 +267,8 @@ internal virtual void PostDecodeWellKnownAttributes(ImmutableArray<CSharpAttribu
         /// <param name="earlyDecodingOnly">Indicates that only early decoding should be performed.  WARNING: the resulting bag will not be sealed.</param>
         /// <param name="binderOpt">Binder to use. If null, <see cref="DeclaringCompilation"/> GetBinderFactory will be used.</param>
         /// <param name="attributeMatchesOpt">If specified, only load attributes that match this predicate, and any diagnostics produced will be dropped.</param>
+        /// <param name="beforeAttributePartBound">If specified, invoked before any part of the attribute syntax is bound.</param>
+        /// <param name="afterAttributePartBound">If specified, invoked after any part of the attribute syntax is bound.</param>
         /// <returns>Flag indicating whether lazyCustomAttributes were stored on this thread. Caller should check for this flag and perform NotePartComplete if true.</returns>
         internal bool LoadAndValidateAttributes(
             OneOrMany<SyntaxList<AttributeListSyntax>> attributesSyntaxLists,
@@ -274,7 +276,9 @@ internal bool LoadAndValidateAttributes(
             AttributeLocation symbolPart = AttributeLocation.None,
             bool earlyDecodingOnly = false,
             Binder? binderOpt = null,
-            Func<AttributeSyntax, bool>? attributeMatchesOpt = null)
+            Func<AttributeSyntax, bool>? attributeMatchesOpt = null,
+            Action<AttributeSyntax>? beforeAttributePartBound = null,
+            Action<AttributeSyntax>? afterAttributePartBound = null)
         {
             var diagnostics = BindingDiagnosticBag.GetInstance();
             Debug.Assert(diagnostics.DiagnosticBag is not null);
@@ -303,7 +307,7 @@ internal bool LoadAndValidateAttributes(
                 // Bind the attribute types and then early decode them.
                 var attributeTypesBuilder = new NamedTypeSymbol[totalAttributesCount];
 
-                Binder.BindAttributeTypes(binders, attributesToBind, this, attributeTypesBuilder, diagnostics);
+                Binder.BindAttributeTypes(binders, attributesToBind, this, attributeTypesBuilder, beforeAttributePartBound, afterAttributePartBound, diagnostics);
 
                 bool interestedInDiagnostics = !earlyDecodingOnly && attributeMatchesOpt is null;
                 if (interestedInDiagnostics)
@@ -341,7 +345,7 @@ internal bool LoadAndValidateAttributes(
                 }
 
                 // Bind attributes.
-                Binder.GetAttributes(binders, attributesToBind, boundAttributeTypes, attributeDataArray, boundAttributeArray, diagnostics);
+                Binder.GetAttributes(binders, attributesToBind, boundAttributeTypes, attributeDataArray, boundAttributeArray, beforeAttributePartBound, afterAttributePartBound, diagnostics);
                 boundAttributes = attributeDataArray.AsImmutableOrNull();
 
                 // All attributes must be bound by now.
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolErrorTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolErrorTests.cs
index b61e95e596e74..124d50b7412eb 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolErrorTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolErrorTests.cs
@@ -21220,5 +21220,198 @@ class \u007c { }
                 Diagnostic(ErrorCode.ERR_SimpleProgramNotAnExecutable, "{ }").WithLocation(3, 14)
                 );
         }
+
+        [Fact]
+        [WorkItem(58517, "https://github.com/dotnet/roslyn/issues/58517")]
+        public void CycleThroughForwardedType_01()
+        {
+            var source1_1 = @"
+public class Base
+{
+}
+";
+
+            var comp1_v1 = CreateCompilation(source1_1, assemblyName: "Lib1");
+            comp1_v1.VerifyDiagnostics();
+
+            var source2 = @"
+[MyAttribute]
+public class Derived : Base
+{
+}
+
+class MyAttribute : System.Attribute {}
+";
+
+            var comp2 = CreateCompilation(source2, references: new[] { comp1_v1.ToMetadataReference() });
+
+            var comp2Ref = comp2.EmitToImageReference();
+
+            var comp3 = CreateCompilation(source1_1);
+
+            var source1_2 = @"
+using System.Runtime.CompilerServices;
+
+[assembly: TypeForwardedTo(typeof(Base))]
+[assembly: TypeForwardedTo(typeof(Derived))]
+
+class Test
+{
+    void M()
+    {
+        Base x = new Derived();
+    }
+}
+";
+
+            var comp1_v2 = CreateCompilation(source1_2, assemblyName: "Lib1", references: new[] { comp2Ref, comp3.ToMetadataReference() });
+            comp1_v2.VerifyEmitDiagnostics();
+
+            var source1_3 = @"
+using System.Runtime.CompilerServices;
+
+[assembly: TypeForwardedTo(typeof(Derived))]
+";
+
+            var comp1_v3 = CreateCompilation(source1_3, assemblyName: "Lib1", references: new[] { comp2Ref });
+            comp1_v3.VerifyEmitDiagnostics();
+
+            var source1_4 = @"
+using System.Runtime.CompilerServices;
+
+[assembly: TypeForwardedTo(typeof(Derived))]
+[assembly: TypeForwardedTo(typeof(Base))]
+
+class Test
+{
+    void M()
+    {
+        Base x = new Derived();
+    }
+}
+";
+
+            var comp1_v4 = CreateCompilation(source1_4, assemblyName: "Lib1", references: new[] { comp2Ref, comp3.ToMetadataReference() });
+            comp1_v4.VerifyEmitDiagnostics();
+
+            var source1_5 = @"
+using System.Runtime.CompilerServices;
+
+[assembly: TypeForwardedTo(typeof(Derived))]
+
+class Test
+{
+    void M()
+    {
+        Test x = new Derived();
+    }
+}
+";
+
+            var comp1_v5 = CreateCompilation(source1_5, assemblyName: "Lib1", references: new[] { comp2Ref });
+            comp1_v5.VerifyEmitDiagnostics(
+                // (10,18): error CS7068: Reference to type 'Base' claims it is defined in this assembly, but it is not defined in source or any added modules
+                //         Test x = new Derived();
+                Diagnostic(ErrorCode.ERR_MissingTypeInSource, "new Derived()").WithArguments("Base").WithLocation(10, 18),
+                // (10,18): error CS0029: Cannot implicitly convert type 'Derived' to 'Test'
+                //         Test x = new Derived();
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "new Derived()").WithArguments("Derived", "Test").WithLocation(10, 18)
+                );
+        }
+
+        [Fact]
+        [WorkItem(58517, "https://github.com/dotnet/roslyn/issues/58517")]
+        public void CycleThroughForwardedType_02()
+        {
+            var source1_1 = @"
+public class Base
+{
+}
+";
+
+            var comp1_v1 = CreateCompilation(source1_1, assemblyName: "Lib1");
+            comp1_v1.VerifyDiagnostics();
+
+            var source2 = @"
+public class Derived : Base
+{
+}
+";
+
+            var comp2 = CreateCompilation(source2, references: new[] { comp1_v1.ToMetadataReference() });
+
+            var comp2Ref = comp2.EmitToImageReference();
+
+            var comp3 = CreateCompilation(source1_1);
+
+            var source1_2 = @"
+using System.Runtime.CompilerServices;
+
+[assembly: TypeForwardedTo(typeof(Base))]
+[assembly: TypeForwardedTo(typeof(Derived))]
+
+class Test
+{
+    void M()
+    {
+        Base x = new Derived();
+    }
+}
+";
+
+            var comp1_v2 = CreateCompilation(source1_2, assemblyName: "Lib1", references: new[] { comp2Ref, comp3.ToMetadataReference() });
+            comp1_v2.VerifyEmitDiagnostics();
+
+            var source1_3 = @"
+using System.Runtime.CompilerServices;
+
+[assembly: TypeForwardedTo(typeof(Derived))]
+";
+
+            var comp1_v3 = CreateCompilation(source1_3, assemblyName: "Lib1", references: new[] { comp2Ref });
+            comp1_v3.VerifyEmitDiagnostics();
+
+            var source1_4 = @"
+using System.Runtime.CompilerServices;
+
+[assembly: TypeForwardedTo(typeof(Derived))]
+[assembly: TypeForwardedTo(typeof(Base))]
+
+class Test
+{
+    void M()
+    {
+        Base x = new Derived();
+    }
+}
+";
+
+            var comp1_v4 = CreateCompilation(source1_4, assemblyName: "Lib1", references: new[] { comp2Ref, comp3.ToMetadataReference() });
+            comp1_v4.VerifyEmitDiagnostics();
+
+            var source1_5 = @"
+using System.Runtime.CompilerServices;
+
+[assembly: TypeForwardedTo(typeof(Derived))]
+
+class Test
+{
+    void M()
+    {
+        Test x = new Derived();
+    }
+}
+";
+
+            var comp1_v5 = CreateCompilation(source1_5, assemblyName: "Lib1", references: new[] { comp2Ref });
+            comp1_v5.VerifyEmitDiagnostics(
+                // (10,18): error CS7068: Reference to type 'Base' claims it is defined in this assembly, but it is not defined in source or any added modules
+                //         Test x = new Derived();
+                Diagnostic(ErrorCode.ERR_MissingTypeInSource, "new Derived()").WithArguments("Base").WithLocation(10, 18),
+                // (10,18): error CS0029: Cannot implicitly convert type 'Derived' to 'Test'
+                //         Test x = new Derived();
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "new Derived()").WithArguments("Derived", "Test").WithLocation(10, 18)
+                );
+        }
     }
 }

From 4fadc5bf69e06d3069aea5df5489ab61d65b07f8 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Tue, 4 Jan 2022 10:07:14 -0800
Subject: [PATCH 209/444] Inline EnqueueWorkItemForProjectAsync

---
 .../SolutionCrawler/WorkCoordinator.cs        | 27 +++++++------------
 1 file changed, 10 insertions(+), 17 deletions(-)

diff --git a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
index 9a5254532392d..88c40ef69e635 100644
--- a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
+++ b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
@@ -282,7 +282,7 @@ private void ProcessEvent(WorkspaceChangeEventArgs args, string eventName)
 
                     case WorkspaceChangeKind.ProjectAdded:
                         Contract.ThrowIfNull(args.ProjectId);
-                        EnqueueEvent(args.NewSolution, args.ProjectId, InvocationReasons.DocumentAdded, eventName);
+                        EnqueueFullProjectEvent(args.NewSolution, args.ProjectId, InvocationReasons.DocumentAdded, eventName);
                         break;
 
                     case WorkspaceChangeKind.ProjectChanged:
@@ -293,7 +293,7 @@ private void ProcessEvent(WorkspaceChangeEventArgs args, string eventName)
 
                     case WorkspaceChangeKind.ProjectRemoved:
                         Contract.ThrowIfNull(args.ProjectId);
-                        EnqueueEvent(args.OldSolution, args.ProjectId, InvocationReasons.DocumentRemoved, eventName);
+                        EnqueueFullProjectEvent(args.OldSolution, args.ProjectId, InvocationReasons.DocumentRemoved, eventName);
                         break;
 
                     case WorkspaceChangeKind.DocumentAdded:
@@ -322,7 +322,7 @@ private void ProcessEvent(WorkspaceChangeEventArgs args, string eventName)
                     case WorkspaceChangeKind.AnalyzerConfigDocumentReloaded:
                         // If an additional file or .editorconfig has changed we need to reanalyze the entire project.
                         Contract.ThrowIfNull(args.ProjectId);
-                        EnqueueEvent(args.NewSolution, args.ProjectId, InvocationReasons.AdditionalDocumentChanged, eventName);
+                        EnqueueFullProjectEvent(args.NewSolution, args.ProjectId, InvocationReasons.AdditionalDocumentChanged, eventName);
                         break;
 
                     default:
@@ -353,7 +353,7 @@ private void EnqueueSolutionChangedEvent(Solution oldSolution, Solution newSolut
                         // TODO: Async version for GetXXX methods?
                         foreach (var addedProject in solutionChanges.GetAddedProjects())
                         {
-                            await EnqueueWorkItemAsync(addedProject, InvocationReasons.DocumentAdded).ConfigureAwait(false);
+                            await EnqueueFullProjectWorkItemAsync(addedProject, InvocationReasons.DocumentAdded).ConfigureAwait(false);
                         }
 
                         foreach (var projectChanges in solutionChanges.GetProjectChanges())
@@ -363,7 +363,7 @@ private void EnqueueSolutionChangedEvent(Solution oldSolution, Solution newSolut
 
                         foreach (var removedProject in solutionChanges.GetRemovedProjects())
                         {
-                            await EnqueueWorkItemAsync(removedProject, InvocationReasons.DocumentRemoved).ConfigureAwait(false);
+                            await EnqueueFullProjectWorkItemAsync(removedProject, InvocationReasons.DocumentRemoved).ConfigureAwait(false);
                         }
                     },
                     _shutdownToken);
@@ -377,7 +377,7 @@ private void EnqueueFullSolutionEvent(Solution solution, InvocationReasons invoc
                     {
                         foreach (var projectId in solution.ProjectIds)
                         {
-                            await EnqueueWorkItemForProjectAsync(solution, projectId, invocationReasons).ConfigureAwait(false);
+                            await EnqueueFullProjectWorkItemAsync(solution.GetRequiredProject(projectId), invocationReasons).ConfigureAwait(false);
                         }
                     },
                     _shutdownToken);
@@ -397,10 +397,10 @@ private void EnqueueProjectChangedEvent(Solution oldSolution, Solution newSoluti
                     _shutdownToken);
             }
 
-            private void EnqueueEvent(Solution solution, ProjectId projectId, InvocationReasons invocationReasons, string eventName)
+            private void EnqueueFullProjectEvent(Solution solution, ProjectId projectId, InvocationReasons invocationReasons, string eventName)
             {
                 _eventProcessingQueue.ScheduleTask(eventName,
-                    () => EnqueueWorkItemForProjectAsync(solution, projectId, invocationReasons), _shutdownToken);
+                    () => EnqueueFullProjectWorkItemAsync(solution.GetRequiredProject(projectId), invocationReasons), _shutdownToken);
             }
 
             private void EnqueueFullDocumentEvent(Solution solution, DocumentId documentId, InvocationReasons invocationReasons, string eventName)
@@ -469,7 +469,7 @@ private static Document GetRequiredDocument(Project project, DocumentId document
                 return new SyntaxPath(changedMember);
             }
 
-            private async Task EnqueueWorkItemAsync(Project project, InvocationReasons invocationReasons)
+            private async Task EnqueueFullProjectWorkItemAsync(Project project, InvocationReasons invocationReasons)
             {
                 foreach (var documentId in project.DocumentIds)
                     await EnqueueWorkItemAsync(project, documentId, document: null, invocationReasons).ConfigureAwait(false);
@@ -553,7 +553,7 @@ private async Task EnqueueProjectConfigurationChangeWorkItemAsync(ProjectChanges
 
                 if (!projectConfigurationChange.IsEmpty)
                 {
-                    await EnqueueWorkItemAsync(projectChanges.NewProject, projectConfigurationChange).ConfigureAwait(false);
+                    await EnqueueFullProjectWorkItemAsync(projectChanges.NewProject, projectConfigurationChange).ConfigureAwait(false);
                 }
             }
 
@@ -576,13 +576,6 @@ private async Task EnqueueWorkItemAsync(Document oldDocument, Document newDocume
                 }
             }
 
-            private Task EnqueueWorkItemForProjectAsync(Solution solution, ProjectId projectId, InvocationReasons invocationReasons)
-            {
-                var project = solution.GetRequiredProject(projectId);
-
-                return EnqueueWorkItemAsync(project, invocationReasons);
-            }
-
             internal TestAccessor GetTestAccessor()
             {
                 return new TestAccessor(this);

From 454af063d56bad465980b8495029d690da30d6e9 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Tue, 4 Jan 2022 10:14:25 -0800
Subject: [PATCH 210/444] Rename methods for clarity

---
 .../SolutionCrawler/WorkCoordinator.cs        | 28 +++++++++----------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
index 88c40ef69e635..c3ee256080e42 100644
--- a/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
+++ b/src/Features/Core/Portable/SolutionCrawler/WorkCoordinator.cs
@@ -333,13 +333,13 @@ private void ProcessEvent(WorkspaceChangeEventArgs args, string eventName)
             private void OnDocumentOpened(object? sender, DocumentEventArgs e)
             {
                 _eventProcessingQueue.ScheduleTask("OnDocumentOpened",
-                    () => EnqueueWorkItemAsync(e.Document.Project, e.Document.Id, e.Document, InvocationReasons.DocumentOpened), _shutdownToken);
+                    () => EnqueueDocumentWorkItemAsync(e.Document.Project, e.Document.Id, e.Document, InvocationReasons.DocumentOpened), _shutdownToken);
             }
 
             private void OnDocumentClosed(object? sender, DocumentEventArgs e)
             {
                 _eventProcessingQueue.ScheduleTask("OnDocumentClosed",
-                    () => EnqueueWorkItemAsync(e.Document.Project, e.Document.Id, e.Document, InvocationReasons.DocumentClosed), _shutdownToken);
+                    () => EnqueueDocumentWorkItemAsync(e.Document.Project, e.Document.Id, e.Document, InvocationReasons.DocumentClosed), _shutdownToken);
             }
 
             private void EnqueueSolutionChangedEvent(Solution oldSolution, Solution newSolution, string eventName)
@@ -410,7 +410,7 @@ private void EnqueueFullDocumentEvent(Solution solution, DocumentId documentId,
                     () =>
                     {
                         var project = solution.GetRequiredProject(documentId.ProjectId);
-                        return EnqueueWorkItemAsync(project, documentId, document: null, invocationReasons);
+                        return EnqueueDocumentWorkItemAsync(project, documentId, document: null, invocationReasons);
                     },
                     _shutdownToken);
             }
@@ -425,12 +425,12 @@ private void EnqueueDocumentChangedEvent(Solution oldSolution, Solution newSolut
                         var oldProject = oldSolution.GetRequiredProject(documentId.ProjectId);
                         var newProject = newSolution.GetRequiredProject(documentId.ProjectId);
 
-                        await EnqueueWorkItemAsync(oldProject.GetRequiredDocument(documentId), newProject.GetRequiredDocument(documentId)).ConfigureAwait(false);
+                        await EnqueueChangedDocumentWorkItemAsync(oldProject.GetRequiredDocument(documentId), newProject.GetRequiredDocument(documentId)).ConfigureAwait(false);
                     },
                     _shutdownToken);
             }
 
-            private async Task EnqueueWorkItemAsync(Project project, DocumentId documentId, Document? document, InvocationReasons invocationReasons, SyntaxNode? changedMember = null)
+            private async Task EnqueueDocumentWorkItemAsync(Project project, DocumentId documentId, Document? document, InvocationReasons invocationReasons, SyntaxNode? changedMember = null)
             {
                 // we are shutting down
                 _shutdownToken.ThrowIfCancellationRequested();
@@ -472,13 +472,13 @@ private static Document GetRequiredDocument(Project project, DocumentId document
             private async Task EnqueueFullProjectWorkItemAsync(Project project, InvocationReasons invocationReasons)
             {
                 foreach (var documentId in project.DocumentIds)
-                    await EnqueueWorkItemAsync(project, documentId, document: null, invocationReasons).ConfigureAwait(false);
+                    await EnqueueDocumentWorkItemAsync(project, documentId, document: null, invocationReasons).ConfigureAwait(false);
 
                 foreach (var documentId in project.AdditionalDocumentIds)
-                    await EnqueueWorkItemAsync(project, documentId, document: null, invocationReasons).ConfigureAwait(false);
+                    await EnqueueDocumentWorkItemAsync(project, documentId, document: null, invocationReasons).ConfigureAwait(false);
 
                 foreach (var documentId in project.AnalyzerConfigDocumentIds)
-                    await EnqueueWorkItemAsync(project, documentId, document: null, invocationReasons).ConfigureAwait(false);
+                    await EnqueueDocumentWorkItemAsync(project, documentId, document: null, invocationReasons).ConfigureAwait(false);
             }
 
             private async Task EnqueueWorkItemAsync(IIncrementalAnalyzer analyzer, ReanalyzeScope scope, bool highPriority)
@@ -507,16 +507,16 @@ private async Task EnqueueWorkItemAsync(ProjectChanges projectChanges)
                 await EnqueueProjectConfigurationChangeWorkItemAsync(projectChanges).ConfigureAwait(false);
 
                 foreach (var addedDocumentId in projectChanges.GetAddedDocuments())
-                    await EnqueueWorkItemAsync(projectChanges.NewProject, addedDocumentId, document: null, InvocationReasons.DocumentAdded).ConfigureAwait(false);
+                    await EnqueueDocumentWorkItemAsync(projectChanges.NewProject, addedDocumentId, document: null, InvocationReasons.DocumentAdded).ConfigureAwait(false);
 
                 foreach (var changedDocumentId in projectChanges.GetChangedDocuments())
                 {
-                    await EnqueueWorkItemAsync(projectChanges.OldProject.GetRequiredDocument(changedDocumentId), projectChanges.NewProject.GetRequiredDocument(changedDocumentId))
+                    await EnqueueChangedDocumentWorkItemAsync(projectChanges.OldProject.GetRequiredDocument(changedDocumentId), projectChanges.NewProject.GetRequiredDocument(changedDocumentId))
                         .ConfigureAwait(continueOnCapturedContext: false);
                 }
 
                 foreach (var removedDocumentId in projectChanges.GetRemovedDocuments())
-                    await EnqueueWorkItemAsync(projectChanges.OldProject, removedDocumentId, document: null, InvocationReasons.DocumentRemoved).ConfigureAwait(false);
+                    await EnqueueDocumentWorkItemAsync(projectChanges.OldProject, removedDocumentId, document: null, InvocationReasons.DocumentRemoved).ConfigureAwait(false);
             }
 
             private async Task EnqueueProjectConfigurationChangeWorkItemAsync(ProjectChanges projectChanges)
@@ -557,7 +557,7 @@ private async Task EnqueueProjectConfigurationChangeWorkItemAsync(ProjectChanges
                 }
             }
 
-            private async Task EnqueueWorkItemAsync(Document oldDocument, Document newDocument)
+            private async Task EnqueueChangedDocumentWorkItemAsync(Document oldDocument, Document newDocument)
             {
                 var differenceService = newDocument.GetLanguageService<IDocumentDifferenceService>();
 
@@ -565,14 +565,14 @@ private async Task EnqueueWorkItemAsync(Document oldDocument, Document newDocume
                 {
                     // For languages that don't use a Roslyn syntax tree, they don't export a document difference service.
                     // The whole document should be considered as changed in that case.
-                    await EnqueueWorkItemAsync(newDocument.Project, newDocument.Id, newDocument, InvocationReasons.DocumentChanged).ConfigureAwait(false);
+                    await EnqueueDocumentWorkItemAsync(newDocument.Project, newDocument.Id, newDocument, InvocationReasons.DocumentChanged).ConfigureAwait(false);
                 }
                 else
                 {
                     var differenceResult = await differenceService.GetDifferenceAsync(oldDocument, newDocument, _shutdownToken).ConfigureAwait(false);
 
                     if (differenceResult != null)
-                        await EnqueueWorkItemAsync(newDocument.Project, newDocument.Id, newDocument, differenceResult.ChangeType, differenceResult.ChangedMember).ConfigureAwait(false);
+                        await EnqueueDocumentWorkItemAsync(newDocument.Project, newDocument.Id, newDocument, differenceResult.ChangeType, differenceResult.ChangedMember).ConfigureAwait(false);
                 }
             }
 

From e60a474fd5fcf1102d214a9845cb9f96630d06f1 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: Tue, 4 Jan 2022 11:00:22 -0800
Subject: [PATCH 211/444] Fix setting InBreakState flag (#58436)

---
 .../EditAndContinueWorkspaceServiceTests.cs    |  5 +++++
 .../Portable/EditAndContinue/EditSession.cs    | 10 ++++++----
 .../EditAndContinue/EditSessionTelemetry.cs    | 18 +++++++++++-------
 3 files changed, 22 insertions(+), 11 deletions(-)

diff --git a/src/EditorFeatures/Test/EditAndContinue/EditAndContinueWorkspaceServiceTests.cs b/src/EditorFeatures/Test/EditAndContinue/EditAndContinueWorkspaceServiceTests.cs
index cc96d88493e2d..56b8af13b9482 100644
--- a/src/EditorFeatures/Test/EditAndContinue/EditAndContinueWorkspaceServiceTests.cs
+++ b/src/EditorFeatures/Test/EditAndContinue/EditAndContinueWorkspaceServiceTests.cs
@@ -1792,6 +1792,11 @@ public async Task Capabilities(bool breakState)
             }
 
             EndDebuggingSession(debuggingSession);
+
+            AssertEx.Equal(new[]
+            {
+                $"Debugging_EncSession: SolutionSessionId={{00000000-AAAA-AAAA-AAAA-000000000000}}|SessionId=1|SessionCount=0|EmptySessionCount={(breakState ? 3 : 0)}|HotReloadSessionCount=0|EmptyHotReloadSessionCount={(breakState ? 4 : 3)}"
+            }, _telemetryLog);
         }
 
         [Fact]
diff --git a/src/Features/Core/Portable/EditAndContinue/EditSession.cs b/src/Features/Core/Portable/EditAndContinue/EditSession.cs
index 55aa36c84b04e..93102bc0e7b10 100644
--- a/src/Features/Core/Portable/EditAndContinue/EditSession.cs
+++ b/src/Features/Core/Portable/EditAndContinue/EditSession.cs
@@ -106,6 +106,8 @@ internal EditSession(
             Telemetry = telemetry;
             InBreakState = inBreakState;
 
+            telemetry.SetBreakState(inBreakState);
+
             BaseActiveStatements = lazyActiveStatementMap ?? (inBreakState ?
                 new AsyncLazy<ActiveStatementsMap>(GetBaseActiveStatementsAsync, cacheResult: true) :
                 new AsyncLazy<ActiveStatementsMap>(ActiveStatementsMap.Empty));
@@ -742,7 +744,7 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution
                         // Bail before analyzing documents as the analysis needs to read the PDB which will likely fail if we can't even read the MVID.
                         diagnostics.Add((newProject.Id, ImmutableArray.Create(mvidReadError)));
 
-                        Telemetry.LogProjectAnalysisSummary(ProjectAnalysisSummary.ValidChanges, newProject.State.ProjectInfo.Attributes.TelemetryId, ImmutableArray.Create(mvidReadError.Descriptor.Id), InBreakState);
+                        Telemetry.LogProjectAnalysisSummary(ProjectAnalysisSummary.ValidChanges, newProject.State.ProjectInfo.Attributes.TelemetryId, ImmutableArray.Create(mvidReadError.Descriptor.Id));
                         isBlocked = true;
                         continue;
                     }
@@ -813,7 +815,7 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution
 
                     if (isModuleEncBlocked || projectSummary != ProjectAnalysisSummary.ValidChanges)
                     {
-                        Telemetry.LogProjectAnalysisSummary(projectSummary, newProject.State.ProjectInfo.Attributes.TelemetryId, moduleDiagnostics.NullToEmpty().SelectAsArray(d => d.Descriptor.Id), InBreakState);
+                        Telemetry.LogProjectAnalysisSummary(projectSummary, newProject.State.ProjectInfo.Attributes.TelemetryId, moduleDiagnostics.NullToEmpty().SelectAsArray(d => d.Descriptor.Id));
                         continue;
                     }
 
@@ -824,7 +826,7 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution
                         // Report diagnosics even when the module is never going to be loaded (e.g. in multi-targeting scenario, where only one framework being debugged).
                         // This is consistent with reporting compilation errors - the IDE reports them for all TFMs regardless of what framework the app is running on.
                         diagnostics.Add((newProject.Id, createBaselineDiagnostics));
-                        Telemetry.LogProjectAnalysisSummary(projectSummary, newProject.State.ProjectInfo.Attributes.TelemetryId, createBaselineDiagnostics, InBreakState);
+                        Telemetry.LogProjectAnalysisSummary(projectSummary, newProject.State.ProjectInfo.Attributes.TelemetryId, createBaselineDiagnostics);
                         isBlocked = true;
                         continue;
                     }
@@ -927,7 +929,7 @@ public async ValueTask<SolutionUpdate> EmitSolutionUpdateAsync(Solution solution
                         diagnostics.Add((newProject.Id, emitResult.Diagnostics));
                     }
 
-                    Telemetry.LogProjectAnalysisSummary(projectSummary, newProject.State.ProjectInfo.Attributes.TelemetryId, emitResult.Diagnostics, InBreakState);
+                    Telemetry.LogProjectAnalysisSummary(projectSummary, newProject.State.ProjectInfo.Attributes.TelemetryId, emitResult.Diagnostics);
                 }
 
                 // log capabilities for edit sessions with changes or reported errors:
diff --git a/src/Features/Core/Portable/EditAndContinue/EditSessionTelemetry.cs b/src/Features/Core/Portable/EditAndContinue/EditSessionTelemetry.cs
index ecca607cdec03..c0eb7ceceab3e 100644
--- a/src/Features/Core/Portable/EditAndContinue/EditSessionTelemetry.cs
+++ b/src/Features/Core/Portable/EditAndContinue/EditSessionTelemetry.cs
@@ -29,6 +29,8 @@ internal readonly struct Data
 
             public Data(EditSessionTelemetry telemetry)
             {
+                Contract.ThrowIfNull(telemetry._inBreakState);
+
                 RudeEdits = telemetry._rudeEdits.AsImmutable();
                 EmitErrorIds = telemetry._emitErrorIds.AsImmutable();
                 ProjectsWithValidDelta = telemetry._projectsWithValidDelta.AsImmutable();
@@ -36,7 +38,7 @@ public Data(EditSessionTelemetry telemetry)
                 HadRudeEdits = telemetry._hadRudeEdits;
                 HadValidChanges = telemetry._hadValidChanges;
                 HadValidInsignificantChanges = telemetry._hadValidInsignificantChanges;
-                InBreakState = telemetry._inBreakState;
+                InBreakState = telemetry._inBreakState.Value;
                 Capabilities = telemetry._capabilities;
                 IsEmpty = telemetry.IsEmpty;
                 Committed = telemetry._committed;
@@ -56,7 +58,7 @@ public Data(EditSessionTelemetry telemetry)
         private bool _hadRudeEdits;
         private bool _hadValidChanges;
         private bool _hadValidInsignificantChanges;
-        private bool _inBreakState;
+        private bool? _inBreakState;
         private bool _committed;
 
         private EditAndContinueCapabilities _capabilities;
@@ -73,7 +75,7 @@ public Data GetDataAndClear()
                 _hadRudeEdits = false;
                 _hadValidChanges = false;
                 _hadValidInsignificantChanges = false;
-                _inBreakState = false;
+                _inBreakState = null;
                 _capabilities = EditAndContinueCapabilities.None;
                 _committed = false;
                 return data;
@@ -82,12 +84,14 @@ public Data GetDataAndClear()
 
         public bool IsEmpty => !(_hadCompilationErrors || _hadRudeEdits || _hadValidChanges || _hadValidInsignificantChanges);
 
-        public void LogProjectAnalysisSummary(ProjectAnalysisSummary summary, Guid projectTelemetryId, ImmutableArray<string> errorsIds, bool inBreakState)
+        public void SetBreakState(bool value)
+            => _inBreakState = value;
+
+        public void LogProjectAnalysisSummary(ProjectAnalysisSummary summary, Guid projectTelemetryId, ImmutableArray<string> errorsIds)
         {
             lock (_guard)
             {
                 _emitErrorIds.AddRange(errorsIds);
-                _inBreakState = inBreakState;
 
                 switch (summary)
                 {
@@ -122,8 +126,8 @@ public void LogProjectAnalysisSummary(ProjectAnalysisSummary summary, Guid proje
             }
         }
 
-        public void LogProjectAnalysisSummary(ProjectAnalysisSummary summary, Guid projectTelemetryId, ImmutableArray<Diagnostic> emitDiagnostics, bool inBreakState)
-            => LogProjectAnalysisSummary(summary, projectTelemetryId, emitDiagnostics.SelectAsArray(d => d.Severity == DiagnosticSeverity.Error, d => d.Id), inBreakState);
+        public void LogProjectAnalysisSummary(ProjectAnalysisSummary summary, Guid projectTelemetryId, ImmutableArray<Diagnostic> emitDiagnostics)
+            => LogProjectAnalysisSummary(summary, projectTelemetryId, emitDiagnostics.SelectAsArray(d => d.Severity == DiagnosticSeverity.Error, d => d.Id));
 
         public void LogRudeEditDiagnostics(ImmutableArray<RudeEditDiagnostic> diagnostics)
         {

From 42df5167df39318c34f1a69944b5f35bb7b7cccd Mon Sep 17 00:00:00 2001
From: Jason Malinowski <jason.malinowski@microsoft.com>
Date: Thu, 2 Dec 2021 11:51:52 -0800
Subject: [PATCH 212/444] Delete dead code

---
 .../TestUtilities/Remote/WatsonReporter.cs    | 32 -------------------
 1 file changed, 32 deletions(-)
 delete mode 100644 src/EditorFeatures/TestUtilities/Remote/WatsonReporter.cs

diff --git a/src/EditorFeatures/TestUtilities/Remote/WatsonReporter.cs b/src/EditorFeatures/TestUtilities/Remote/WatsonReporter.cs
deleted file mode 100644
index f6cc4c764e49e..0000000000000
--- a/src/EditorFeatures/TestUtilities/Remote/WatsonReporter.cs
+++ /dev/null
@@ -1,32 +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.
-
-#nullable disable
-
-using System;
-
-namespace Microsoft.CodeAnalysis.ErrorReporting
-{
-    /// <summary>
-    /// Mock to make test project build
-    /// </summary>
-    internal class WatsonReporter
-    {
-        public static void Report(string _1, Exception _2)
-        {
-            // do nothing
-        }
-
-        public static void Report(string _1, Exception _2, Func<IFaultUtility, int> _3)
-        {
-            // do nothing
-        }
-
-        public interface IFaultUtility
-        {
-            void AddProcessDump(int pid);
-            void AddFile(string fullpathname);
-        }
-    }
-}

From 69e50f0b88ecaa39283d718624b4f11f72e52e65 Mon Sep 17 00:00:00 2001
From: Jason Malinowski <jason.malinowski@microsoft.com>
Date: Thu, 2 Dec 2021 11:57:17 -0800
Subject: [PATCH 213/444] Rename WatsonReporter to FaultReporter

This hasn't directly used Watson in quite some time.
---
 .../Implementation/ProjectSystem/VisualStudioWorkspace.cs | 2 +-
 .../Watson/{WatsonReporter.cs => FaultReporter.cs}        | 8 ++++----
 .../Core/Def/Interactive/VsInteractiveWindowPackage.cs    | 4 ++--
 .../Def/Telemetry/AbstractWorkspaceTelemetryService.cs    | 6 +++---
 .../Microsoft.CodeAnalysis.Remote.ServiceHub.csproj       | 2 +-
 .../ProcessTelemetry/RemoteProcessTelemetryService.cs     | 2 +-
 6 files changed, 12 insertions(+), 12 deletions(-)
 rename src/VisualStudio/Core/Def/Implementation/Watson/{WatsonReporter.cs => FaultReporter.cs} (97%)

diff --git a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspace.cs b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspace.cs
index 390fe7b8ac861..3ee403cda8069 100644
--- a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspace.cs
+++ b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspace.cs
@@ -26,7 +26,7 @@ public abstract class VisualStudioWorkspace : Workspace
 
         static VisualStudioWorkspace()
         {
-            WatsonReporter.InitializeFatalErrorHandlers();
+            FaultReporter.InitializeFatalErrorHandlers();
         }
 
         internal VisualStudioWorkspace(HostServices hostServices)
diff --git a/src/VisualStudio/Core/Def/Implementation/Watson/WatsonReporter.cs b/src/VisualStudio/Core/Def/Implementation/Watson/FaultReporter.cs
similarity index 97%
rename from src/VisualStudio/Core/Def/Implementation/Watson/WatsonReporter.cs
rename to src/VisualStudio/Core/Def/Implementation/Watson/FaultReporter.cs
index ca0af15d0b3bd..1997e0fa87b6d 100644
--- a/src/VisualStudio/Core/Def/Implementation/Watson/WatsonReporter.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Watson/FaultReporter.cs
@@ -16,7 +16,7 @@
 
 namespace Microsoft.CodeAnalysis.ErrorReporting
 {
-    internal static class WatsonReporter
+    internal static class FaultReporter
     {
         private static Dictionary<string, string>? s_capturedFileContent;
 
@@ -30,8 +30,8 @@ public static void InitializeFatalErrorHandlers()
         {
             // Set both handlers to non-fatal Watson. Never fail-fast the ServiceHub process.
             // Any exception that is not recovered from shall be propagated and communicated to the client.
-            var nonFatalHandler = WatsonReporter.ReportNonFatal;
-            var fatalHandler = new Action<Exception>(static (exception) => ReportNonFatal(exception, forceDump: false));
+            var nonFatalHandler = FaultReporter.ReportFault;
+            var fatalHandler = new Action<Exception>(static (exception) => ReportFault(exception, forceDump: false));
 
             FatalError.Handler = fatalHandler;
             FatalError.NonFatalHandler = nonFatalHandler;
@@ -83,7 +83,7 @@ public static void UnregisterLogger(TraceSource logger)
         /// <param name="exception">Exception that triggered this non-fatal error</param>
         /// <param name="forceDump">Force a dump to be created, even if the telemetry system is not
         /// requesting one; we will still do a client-side limit to avoid sending too much at once.</param>
-        public static void ReportNonFatal(Exception exception, bool forceDump)
+        public static void ReportFault(Exception exception, bool forceDump)
         {
             try
             {
diff --git a/src/VisualStudio/Core/Def/Interactive/VsInteractiveWindowPackage.cs b/src/VisualStudio/Core/Def/Interactive/VsInteractiveWindowPackage.cs
index 9eee1f44e1e29..11d38047fba26 100644
--- a/src/VisualStudio/Core/Def/Interactive/VsInteractiveWindowPackage.cs
+++ b/src/VisualStudio/Core/Def/Interactive/VsInteractiveWindowPackage.cs
@@ -51,9 +51,9 @@ protected override async Task InitializeAsync(CancellationToken cancellationToke
 
             // Set both handlers to non-fatal Watson. Never fail-fast the VS process.
             // Any exception that is not recovered from shall be propagated.
-            var nonFatalHandler = new Action<Exception>(static (exception) => WatsonReporter.ReportNonFatal(exception, forceDump: false));
+            var nonFatalHandler = new Action<Exception>(static (exception) => FaultReporter.ReportFault(exception, forceDump: false));
             InteractiveHostFatalError.Handler = nonFatalHandler;
-            InteractiveHostFatalError.NonFatalHandler = WatsonReporter.ReportNonFatal;
+            InteractiveHostFatalError.NonFatalHandler = FaultReporter.ReportFault;
 
             // Load the Roslyn package so that its FatalError handlers are hooked up.
             shell.LoadPackage(Guids.RoslynPackageId, out var roslynPackage);
diff --git a/src/VisualStudio/Core/Def/Telemetry/AbstractWorkspaceTelemetryService.cs b/src/VisualStudio/Core/Def/Telemetry/AbstractWorkspaceTelemetryService.cs
index 29fb9d20785a0..ec9c95da8674b 100644
--- a/src/VisualStudio/Core/Def/Telemetry/AbstractWorkspaceTelemetryService.cs
+++ b/src/VisualStudio/Core/Def/Telemetry/AbstractWorkspaceTelemetryService.cs
@@ -26,7 +26,7 @@ public void InitializeTelemetrySession(TelemetrySession telemetrySession)
             Contract.ThrowIfFalse(CurrentSession is null);
 
             Logger.SetLogger(CreateLogger(telemetrySession));
-            WatsonReporter.RegisterTelemetrySesssion(telemetrySession);
+            FaultReporter.RegisterTelemetrySesssion(telemetrySession);
 
             CurrentSession = telemetrySession;
 
@@ -44,10 +44,10 @@ public bool HasActiveSession
             => CurrentSession?.SerializeSettings();
 
         public void RegisterUnexpectedExceptionLogger(TraceSource logger)
-            => WatsonReporter.RegisterLogger(logger);
+            => FaultReporter.RegisterLogger(logger);
 
         public void UnregisterUnexpectedExceptionLogger(TraceSource logger)
-            => WatsonReporter.UnregisterLogger(logger);
+            => FaultReporter.UnregisterLogger(logger);
 
         public void ReportApiUsage(HashSet<ISymbol> symbols, Guid solutionSessionId, Guid projectGuid)
         {
diff --git a/src/Workspaces/Remote/ServiceHub/Microsoft.CodeAnalysis.Remote.ServiceHub.csproj b/src/Workspaces/Remote/ServiceHub/Microsoft.CodeAnalysis.Remote.ServiceHub.csproj
index e12cc3d6601fb..ca8b821bfa250 100644
--- a/src/Workspaces/Remote/ServiceHub/Microsoft.CodeAnalysis.Remote.ServiceHub.csproj
+++ b/src/Workspaces/Remote/ServiceHub/Microsoft.CodeAnalysis.Remote.ServiceHub.csproj
@@ -41,7 +41,7 @@
   <ItemGroup>
     <Compile Include="..\..\..\VisualStudio\Core\Def\Implementation\UnusedReferences\ProjectAssets\ProjectAssetsFileReader.cs" Link="Services\UnusedReferences\ProjectAssets\ProjectAssetsFileReader.cs" />
     <Compile Include="..\..\..\VisualStudio\Core\Def\Implementation\Watson\WatsonExtensions.cs" Link="Services\ProcessTelemetry\WatsonExtensions.cs" />
-    <Compile Include="..\..\..\VisualStudio\Core\Def\Implementation\Watson\WatsonReporter.cs" Link="Services\ProcessTelemetry\WatsonReporter.cs" />
+    <Compile Include="..\..\..\VisualStudio\Core\Def\Implementation\Watson\FaultReporter.cs" Link="Services\ProcessTelemetry\FaultReporter.cs" />
     <Compile Include="..\..\..\VisualStudio\Core\Def\Storage\AbstractCloudCachePersistentStorageService.cs" Link="Host\Storage\AbstractCloudCachePersistentStorageService.cs" />
     <Compile Include="..\..\..\VisualStudio\Core\Def\Storage\CloudCachePersistentStorage.cs" Link="Host\Storage\CloudCachePersistentStorage.cs" />
     <Compile Include="..\..\..\VisualStudio\Core\Def\Storage\ProjectContainerKeyCache.cs" Link="Host\Storage\ProjectContainerKeyCache.cs" />
diff --git a/src/Workspaces/Remote/ServiceHub/Services/ProcessTelemetry/RemoteProcessTelemetryService.cs b/src/Workspaces/Remote/ServiceHub/Services/ProcessTelemetry/RemoteProcessTelemetryService.cs
index 573834956f856..afb7fefc57c50 100644
--- a/src/Workspaces/Remote/ServiceHub/Services/ProcessTelemetry/RemoteProcessTelemetryService.cs
+++ b/src/Workspaces/Remote/ServiceHub/Services/ProcessTelemetry/RemoteProcessTelemetryService.cs
@@ -58,7 +58,7 @@ public ValueTask InitializeTelemetrySessionAsync(int hostProcessId, string seria
 
                 telemetryService.InitializeTelemetrySession(telemetrySession);
                 telemetryService.RegisterUnexpectedExceptionLogger(TraceLogger);
-                WatsonReporter.InitializeFatalErrorHandlers();
+                FaultReporter.InitializeFatalErrorHandlers();
 
                 // log telemetry that service hub started
                 RoslynLogger.Log(FunctionId.RemoteHost_Connect, KeyValueLogMessage.Create(m =>

From 37dd43d44880c8a2cc86725e5534a205deeea715 Mon Sep 17 00:00:00 2001
From: Jason Malinowski <jason.malinowski@microsoft.com>
Date: Thu, 2 Dec 2021 16:50:11 -0800
Subject: [PATCH 214/444] Simplify how our FatalError type works and introduce
 a severity concept

Our FatalError type had two "handlers", the "fatal handler" and "non
fatal handler." If you called any ReportAndCatch method, that would
be counted as "non fatal" because you're catching the exception and
presumably dealing with it. If you called any ReportAndPropagate,
that would call the "fatal" handler.

This was confusing from a few perspectives. In the IDE, both the "fatal"
and "non-fatal" handlers actually did the same thing; they both reported
a non-fatal report via telemetry and kept the process alive. At first,
I was tempted to use fatal vs. non-fatal as way to report different
severities via telemetry, but the concept doesn't jive well there.
Sometimes we were calling ReportAndCatch when the feature absolutely
broke and the user would have known -- in that case we want the severity
to be high. Sometimes we're also catching an exception and gracefully
dealing with it, so the severity should be lower. Similarly, propagating
an exception usually means it's a severe problem, but if it's a
background job that has a higher-up error handler, we may not want to
treat it as high severity. In the end, the conclusion was the
fatal vs. non-fatal split didn't make sense in relation to severity,
and since it doesn't correlate to whether you want exceptions to
flow or not, it's easier to just add severity as a separate concept
when reporting, and unify the code so everything is going through a
single reporting path.

The compiler story was a bit different: the compiler would only set
the "fatal" handler; the non-fatal handler was never set. This meant
that a call to ReportAndPropagate would crash the process,
ReportAndCatch would keep it going. This seems sensible at first glance,
except the ReportAndCatches in the compiler often were swallowing
exceptions and returning placeholder results from the SemanticModel;
in that case we're OK with the compiler crashing as well, since the
compiler is the source of those issues.
---
 .../Portable/InternalUtilities/FailFast.cs    |   6 +
 .../Portable/InternalUtilities/FatalError.cs  | 137 +++++++++---------
 .../VBCSCompiler/BuildServerController.cs     |   2 +-
 src/Compilers/Shared/Csc.cs                   |   2 +-
 src/Compilers/Shared/Vbc.cs                   |   2 +-
 .../SymbolSearch/SymbolSearchUpdateEngine.cs  |   2 +-
 .../Source/ResultProvider/ResultProvider.cs   |   2 +-
 .../HostProcess/InteractiveHostEntryPoint.cs  |   2 +-
 ...tLanguageService`2.IVsLanguageDebugInfo.cs |  14 +-
 .../Implementation/Watson/FaultReporter.cs    |  33 ++---
 .../Interactive/VsInteractiveWindowPackage.cs |  12 +-
 11 files changed, 109 insertions(+), 105 deletions(-)

diff --git a/src/Compilers/Core/Portable/InternalUtilities/FailFast.cs b/src/Compilers/Core/Portable/InternalUtilities/FailFast.cs
index 3703a31101344..3260ed46f5beb 100644
--- a/src/Compilers/Core/Portable/InternalUtilities/FailFast.cs
+++ b/src/Compilers/Core/Portable/InternalUtilities/FailFast.cs
@@ -6,12 +6,18 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
+using Microsoft.CodeAnalysis.ErrorReporting;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis
 {
     internal static class FailFast
     {
+        /// <summary>
+        /// A pre-created delegate to assign to <see cref="FatalError.ErrorReporterHandler" /> if needed.
+        /// </summary>
+        internal static readonly FatalError.ErrorReporterHandler Handler = static (e, _, _) => OnFatalException(e);
+
         [DebuggerHidden]
         [DoesNotReturn]
 #if !NETSTANDARD1_3
diff --git a/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs b/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs
index 67c2e466c2c4f..6a313555c6d88 100644
--- a/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs
+++ b/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs
@@ -5,6 +5,7 @@
 using System;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
 using System.Threading;
 
 #if NET20
@@ -16,11 +17,8 @@ namespace Microsoft.CodeAnalysis.ErrorReporting
 {
     internal static class FatalError
     {
-        private static Action<Exception>? s_fatalHandler;
-
-#if !NET20
-        private static Action<Exception, bool>? s_nonFatalHandler;
-#endif
+        public delegate void ErrorReporterHandler(Exception exception, ErrorSeverity severity, bool forceDump);
+        private static ErrorReporterHandler? s_handler;
 
 #pragma warning disable IDE0052 // Remove unread private members - We want to hold onto last exception to make investigation easier
         private static Exception? s_reportedException;
@@ -28,82 +26,84 @@ internal static class FatalError
 #pragma warning restore IDE0052
 
         /// <summary>
-        /// Set by the host to a fail fast trigger, 
-        /// if the host desires to crash the process on a fatal exception.
+        /// Set by the host to handle an error report; this may crash the process or report telemetry.
         /// </summary>
         [DisallowNull]
-        public static Action<Exception>? Handler
+        public static ErrorReporterHandler? Handler
         {
             get
             {
-                return s_fatalHandler;
+                return s_handler;
             }
 
             set
             {
-                if (s_fatalHandler != value)
+                if (s_handler != value)
                 {
-                    Debug.Assert(s_fatalHandler == null, "Handler already set");
-                    s_fatalHandler = value;
+                    Debug.Assert(s_handler == null, "Handler already set");
+                    s_handler = value;
                 }
             }
         }
 
-#if !NET20
+        // Same as setting the Handler property except that it avoids the assert.  This is useful in 
+        // test code which needs to verify the handler is called in specific cases and will continually
+        // overwrite this value.
+        public static void OverwriteHandler(ErrorReporterHandler? value)
+        {
+            s_handler = value;
+        }
+
+        // In the result provider, we aren't copying our handler to somewhere else, so we don't
+        // need this method. It's too much of a challenge to shared code to work in
+        // old versions of the runtime since APIs changed over time.
+#if !NET20 && !NETSTANDARD1_3 
 
         /// <summary>
-        /// Set by the host to a fail fast trigger, 
-        /// if the host desires to NOT crash the process on a non fatal exception.
+        /// Copies the handler in this instance to the linked copy of this type in this other assembly.
         /// </summary>
-        [DisallowNull]
-        public static Action<Exception, bool>? NonFatalHandler
+        /// <remarks>
+        /// This file is in linked into multiple layers, but we want to ensure that all layers have the same copy.
+        /// This lets us copy the handler in this instance into the same in another instance.</remarks>
+        public static void CopyHandlerTo(Assembly assembly)
         {
-            get
+            var targetType = assembly.GetType(typeof(FatalError).FullName!, throwOnError: true)!;
+            var targetHandlerProperty = targetType.GetProperty(nameof(FatalError.Handler), BindingFlags.Static | BindingFlags.Public)!;
+            if (Handler is not null)
             {
-                return s_nonFatalHandler;
+                // We need to convert the delegate type to the type in the linked copy since they won't have identity.
+                var convertedDelegate = Delegate.CreateDelegate(targetHandlerProperty.PropertyType, Handler.Target, method: Handler.Method);
+                targetHandlerProperty.SetValue(obj: null, value: convertedDelegate);
             }
-
-            set
+            else
             {
-                if (s_nonFatalHandler != value)
-                {
-                    Debug.Assert(s_nonFatalHandler == null, "Handler already set");
-                    s_nonFatalHandler = value;
-                }
+                targetHandlerProperty.SetValue(obj: null, value: null);
             }
         }
 
 #endif
 
-        // Same as setting the Handler property except that it avoids the assert.  This is useful in 
-        // test code which needs to verify the handler is called in specific cases and will continually
-        // overwrite this value.
-        public static void OverwriteHandler(Action<Exception>? value)
-        {
-            s_fatalHandler = value;
-        }
-
         private static bool IsCurrentOperationBeingCancelled(Exception exception, CancellationToken cancellationToken)
             => exception is OperationCanceledException && cancellationToken.IsCancellationRequested;
 
         /// <summary>
-        /// Use in an exception filter to report a fatal error (by calling <see cref="Handler"/>), unless the
+        /// Use in an exception filter to report an error (by calling <see cref="Handler"/>), unless the
         /// operation has been cancelled. The exception is never caught.
         /// </summary>
         /// <returns><see langword="false"/> to avoid catching the exception.</returns>
         [DebuggerHidden]
-        public static bool ReportAndPropagateUnlessCanceled(Exception exception)
+        public static bool ReportAndPropagateUnlessCanceled(Exception exception, ErrorSeverity severity = ErrorSeverity.Uncategorized)
         {
             if (exception is OperationCanceledException)
             {
                 return false;
             }
 
-            return ReportAndPropagate(exception);
+            return ReportAndPropagate(exception, severity);
         }
 
         /// <summary>
-        /// <para>Use in an exception filter to report a fatal error (by calling <see cref="Handler"/>), unless the
+        /// <para>Use in an exception filter to report an error (by calling <see cref="Handler"/>), unless the
         /// operation has been cancelled at the request of <paramref name="contextCancellationToken"/>. The exception is
         /// never caught.</para>
         ///
@@ -121,37 +121,35 @@ public static bool ReportAndPropagateUnlessCanceled(Exception exception)
         /// <see cref="CancellationToken.IsCancellationRequested"/> set if cancellation is expected.</param>
         /// <returns><see langword="false"/> to avoid catching the exception.</returns>
         [DebuggerHidden]
-        public static bool ReportAndPropagateUnlessCanceled(Exception exception, CancellationToken contextCancellationToken)
+        public static bool ReportAndPropagateUnlessCanceled(Exception exception, CancellationToken contextCancellationToken, ErrorSeverity severity = ErrorSeverity.Uncategorized)
         {
             if (IsCurrentOperationBeingCancelled(exception, contextCancellationToken))
             {
                 return false;
             }
 
-            return ReportAndPropagate(exception);
+            return ReportAndPropagate(exception, severity);
         }
 
-#if !NET20
-
         /// <summary>
-        /// Use in an exception filter to report a non-fatal error (by calling <see cref="NonFatalHandler"/>) and catch
+        /// Use in an exception filter to report an error (by calling <see cref="Handler"/>) and catch
         /// the exception, unless the operation was cancelled.
         /// </summary>
-        /// <returns><see langword="true"/> to catch the exception if the non-fatal error was reported; otherwise,
+        /// <returns><see langword="true"/> to catch the exception if the error was reported; otherwise,
         /// <see langword="false"/> to propagate the exception if the operation was cancelled.</returns>
         [DebuggerHidden]
-        public static bool ReportAndCatchUnlessCanceled(Exception exception)
+        public static bool ReportAndCatchUnlessCanceled(Exception exception, ErrorSeverity severity = ErrorSeverity.Uncategorized)
         {
             if (exception is OperationCanceledException)
             {
                 return false;
             }
 
-            return ReportAndCatch(exception);
+            return ReportAndCatch(exception, severity);
         }
 
         /// <summary>
-        /// <para>Use in an exception filter to report a non-fatal error (by calling <see cref="NonFatalHandler"/>) and
+        /// <para>Use in an exception filter to report an error (by calling <see cref="Handler"/>) and
         /// catch the exception, unless the operation was cancelled at the request of
         /// <paramref name="contextCancellationToken"/>.</para>
         ///
@@ -167,38 +165,34 @@ public static bool ReportAndCatchUnlessCanceled(Exception exception)
         /// </summary>
         /// <param name="contextCancellationToken">A <see cref="CancellationToken"/> which will have
         /// <see cref="CancellationToken.IsCancellationRequested"/> set if cancellation is expected.</param>
-        /// <returns><see langword="true"/> to catch the exception if the non-fatal error was reported; otherwise,
+        /// <returns><see langword="true"/> to catch the exception if the error was reported; otherwise,
         /// <see langword="false"/> to propagate the exception if the operation was cancelled.</returns>
         [DebuggerHidden]
-        public static bool ReportAndCatchUnlessCanceled(Exception exception, CancellationToken contextCancellationToken)
+        public static bool ReportAndCatchUnlessCanceled(Exception exception, CancellationToken contextCancellationToken, ErrorSeverity severity = ErrorSeverity.Uncategorized)
         {
             if (IsCurrentOperationBeingCancelled(exception, contextCancellationToken))
             {
                 return false;
             }
 
-            return ReportAndCatch(exception);
+            return ReportAndCatch(exception, severity);
         }
 
-#endif
-
         /// <summary>
-        /// Use in an exception filter to report a fatal error without catching the exception.
+        /// Use in an exception filter to report an error without catching the exception.
         /// The error is reported by calling <see cref="Handler"/>.
         /// </summary>
         /// <returns><see langword="false"/> to avoid catching the exception.</returns>
         [DebuggerHidden]
-        public static bool ReportAndPropagate(Exception exception)
+        public static bool ReportAndPropagate(Exception exception, ErrorSeverity severity = ErrorSeverity.Uncategorized)
         {
-            Report(exception, s_fatalHandler);
+            Report(exception, severity);
             return false;
         }
 
-#if !NET20
-
         /// <summary>
-        /// Report a non-fatal error.
-        /// Calls <see cref="NonFatalHandler"/> and doesn't pass the exception through (the method returns true).
+        /// Report an error.
+        /// Calls <see cref="Handler"/> and doesn't pass the exception through (the method returns true).
         /// This is generally expected to be used within an exception filter as that allows us to
         /// capture data at the point the exception is thrown rather than when it is handled.
         /// However, it can also be used outside of an exception filter. If the exception has not
@@ -207,30 +201,28 @@ public static bool ReportAndPropagate(Exception exception)
         /// </summary>
         /// <returns>True to catch the exception.</returns>
         [DebuggerHidden]
-        public static bool ReportAndCatch(Exception exception)
+        public static bool ReportAndCatch(Exception exception, ErrorSeverity severity = ErrorSeverity.Uncategorized)
         {
-            Report(exception, static (exception) => s_nonFatalHandler?.Invoke(exception, false));
+            Report(exception, severity);
             return true;
         }
 
         [DebuggerHidden]
-        public static bool ReportWithDumpAndCatch(Exception exception)
+        public static bool ReportWithDumpAndCatch(Exception exception, ErrorSeverity severity = ErrorSeverity.Uncategorized)
         {
-            Report(exception, static (exception) => s_nonFatalHandler?.Invoke(exception, true));
+            Report(exception, severity, forceDump: true);
             return true;
         }
 
-#endif
-
         private static readonly object s_reportedMarker = new();
 
-        private static void Report(Exception exception, Action<Exception>? handler)
+        private static void Report(Exception exception, ErrorSeverity severity = ErrorSeverity.Uncategorized, bool forceDump = false)
         {
             // hold onto last exception to make investigation easier
             s_reportedException = exception;
             s_reportedExceptionMessage = exception.ToString();
 
-            if (handler == null)
+            if (s_handler == null)
             {
                 return;
             }
@@ -247,12 +239,21 @@ private static void Report(Exception exception, Action<Exception>? handler)
                 return;
             }
 #endif
+
             if (!exception.Data.IsReadOnly)
             {
                 exception.Data[s_reportedMarker] = s_reportedMarker;
             }
 
-            handler.Invoke(exception);
+            s_handler(exception, severity, forceDump);
         }
     }
+
+    internal enum ErrorSeverity
+    {
+        Uncategorized,
+        Diagnostic,
+        General,
+        Critical
+    }
 }
diff --git a/src/Compilers/Server/VBCSCompiler/BuildServerController.cs b/src/Compilers/Server/VBCSCompiler/BuildServerController.cs
index 5f2cfd3a6f75c..4c1f2ca3ddc87 100644
--- a/src/Compilers/Server/VBCSCompiler/BuildServerController.cs
+++ b/src/Compilers/Server/VBCSCompiler/BuildServerController.cs
@@ -127,7 +127,7 @@ internal int RunServer(
                 }
 
                 compilerServerHost.Logger.Log("Keep alive timeout is: {0} milliseconds.", keepAlive?.TotalMilliseconds ?? 0);
-                FatalError.Handler = FailFast.OnFatalException;
+                FatalError.Handler = FailFast.Handler;
 
                 var dispatcher = new ServerDispatcher(compilerServerHost, clientConnectionHost, listener);
                 dispatcher.ListenAndDispatchConnections(keepAlive, cancellationToken);
diff --git a/src/Compilers/Shared/Csc.cs b/src/Compilers/Shared/Csc.cs
index 3915a62da5883..0836ba9ead740 100644
--- a/src/Compilers/Shared/Csc.cs
+++ b/src/Compilers/Shared/Csc.cs
@@ -21,7 +21,7 @@ internal Csc(string responseFile, BuildPaths buildPaths, string[] args, IAnalyze
 
         internal static int Run(string[] args, BuildPaths buildPaths, TextWriter textWriter, IAnalyzerAssemblyLoader analyzerLoader)
         {
-            FatalError.Handler = FailFast.OnFatalException;
+            FatalError.Handler = FailFast.Handler;
 
             var responseFile = Path.Combine(buildPaths.ClientDirectory, CSharpCompiler.ResponseFileName);
             var compiler = new Csc(responseFile, buildPaths, args, analyzerLoader);
diff --git a/src/Compilers/Shared/Vbc.cs b/src/Compilers/Shared/Vbc.cs
index 33bb186143152..0db6a1ae965e0 100644
--- a/src/Compilers/Shared/Vbc.cs
+++ b/src/Compilers/Shared/Vbc.cs
@@ -21,7 +21,7 @@ internal Vbc(string responseFile, BuildPaths buildPaths, string[] args, IAnalyze
 
         internal static int Run(string[] args, BuildPaths buildPaths, TextWriter textWriter, IAnalyzerAssemblyLoader analyzerLoader)
         {
-            FatalError.Handler = FailFast.OnFatalException;
+            FatalError.Handler = FailFast.Handler;
 
             var responseFile = Path.Combine(buildPaths.ClientDirectory, VisualBasicCompiler.ResponseFileName);
             var compiler = new Vbc(responseFile, buildPaths, args, analyzerLoader);
diff --git a/src/EditorFeatures/Core/SymbolSearch/SymbolSearchUpdateEngine.cs b/src/EditorFeatures/Core/SymbolSearch/SymbolSearchUpdateEngine.cs
index 0678a0e05d7f8..1859e136220cf 100644
--- a/src/EditorFeatures/Core/SymbolSearch/SymbolSearchUpdateEngine.cs
+++ b/src/EditorFeatures/Core/SymbolSearch/SymbolSearchUpdateEngine.cs
@@ -43,7 +43,7 @@ public SymbolSearchUpdateEngine()
                    new PatchService(),
                    new DatabaseFactoryService(),
                    // Report all exceptions we encounter, but don't crash on them. Propagate expected cancellation.
-                   FatalError.ReportAndCatchUnlessCanceled)
+                   static (e, ct) => FatalError.ReportAndCatchUnlessCanceled(e, ct))
         {
         }
 
diff --git a/src/ExpressionEvaluator/Core/Source/ResultProvider/ResultProvider.cs b/src/ExpressionEvaluator/Core/Source/ResultProvider/ResultProvider.cs
index 769be393a9114..721c759b4099b 100644
--- a/src/ExpressionEvaluator/Core/Source/ResultProvider/ResultProvider.cs
+++ b/src/ExpressionEvaluator/Core/Source/ResultProvider/ResultProvider.cs
@@ -48,7 +48,7 @@ public abstract class ResultProvider : IDkmClrResultProvider
 
         static ResultProvider()
         {
-            FatalError.Handler = FailFast.OnFatalException;
+            FatalError.Handler = FailFast.Handler;
         }
 
         internal ResultProvider(IDkmClrFormatter2 formatter2, IDkmClrFullNameProvider fullNameProvider)
diff --git a/src/Interactive/HostProcess/InteractiveHostEntryPoint.cs b/src/Interactive/HostProcess/InteractiveHostEntryPoint.cs
index 31767e75964cc..23821c81066a6 100644
--- a/src/Interactive/HostProcess/InteractiveHostEntryPoint.cs
+++ b/src/Interactive/HostProcess/InteractiveHostEntryPoint.cs
@@ -15,7 +15,7 @@ internal static class InteractiveHostEntryPoint
     {
         private static async Task<int> Main(string[] args)
         {
-            FatalError.Handler = FailFast.OnFatalException;
+            FatalError.Handler = FailFast.Handler;
 
             // Disables Windows Error Reporting for the process, so that the process fails fast.
             SetErrorMode(GetErrorMode() | ErrorMode.SEM_FAILCRITICALERRORS | ErrorMode.SEM_NOOPENFILEERRORBOX | ErrorMode.SEM_NOGPFAULTERRORBOX);
diff --git a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractLanguageService`2.IVsLanguageDebugInfo.cs b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractLanguageService`2.IVsLanguageDebugInfo.cs
index c95a196fef1e8..be03307e56431 100644
--- a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractLanguageService`2.IVsLanguageDebugInfo.cs
+++ b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractLanguageService`2.IVsLanguageDebugInfo.cs
@@ -22,7 +22,7 @@ int IVsLanguageDebugInfo.GetLanguageID(IVsTextBuffer pBuffer, int iLine, int iCo
             {
                 return LanguageDebugInfo.GetLanguageID(pBuffer, iLine, iCol, out pguidLanguageID);
             }
-            catch (Exception e) when (FatalError.ReportAndCatch(e) && false)
+            catch (Exception e) when (FatalError.ReportAndPropagate(e))
             {
                 throw ExceptionUtilities.Unreachable;
             }
@@ -34,7 +34,7 @@ int IVsLanguageDebugInfo.GetLocationOfName(string pszName, out string pbstrMkDoc
             {
                 return LanguageDebugInfo.GetLocationOfName(pszName, out pbstrMkDoc, out pspanLocation);
             }
-            catch (Exception e) when (FatalError.ReportAndCatch(e) && false)
+            catch (Exception e) when (FatalError.ReportAndPropagate(e))
             {
                 throw ExceptionUtilities.Unreachable;
             }
@@ -46,7 +46,7 @@ int IVsLanguageDebugInfo.GetNameOfLocation(IVsTextBuffer pBuffer, int iLine, int
             {
                 return LanguageDebugInfo.GetNameOfLocation(pBuffer, iLine, iCol, out pbstrName, out piLineOffset);
             }
-            catch (Exception e) when (FatalError.ReportAndCatch(e) && false)
+            catch (Exception e) when (FatalError.ReportAndPropagate(e))
             {
                 throw ExceptionUtilities.Unreachable;
             }
@@ -58,7 +58,7 @@ int IVsLanguageDebugInfo.GetProximityExpressions(IVsTextBuffer pBuffer, int iLin
             {
                 return LanguageDebugInfo.GetProximityExpressions(pBuffer, iLine, iCol, cLines, out ppEnum);
             }
-            catch (Exception e) when (FatalError.ReportAndCatch(e) && false)
+            catch (Exception e) when (FatalError.ReportAndPropagate(e))
             {
                 throw ExceptionUtilities.Unreachable;
             }
@@ -70,7 +70,7 @@ int IVsLanguageDebugInfo.IsMappedLocation(IVsTextBuffer pBuffer, int iLine, int
             {
                 return LanguageDebugInfo.IsMappedLocation(pBuffer, iLine, iCol);
             }
-            catch (Exception e) when (FatalError.ReportAndCatch(e) && false)
+            catch (Exception e) when (FatalError.ReportAndPropagate(e))
             {
                 throw ExceptionUtilities.Unreachable;
             }
@@ -82,7 +82,7 @@ int IVsLanguageDebugInfo.ResolveName(string pszName, uint dwFlags, out IVsEnumDe
             {
                 return LanguageDebugInfo.ResolveName(pszName, dwFlags, out ppNames);
             }
-            catch (Exception e) when (FatalError.ReportAndCatch(e) && false)
+            catch (Exception e) when (FatalError.ReportAndPropagate(e))
             {
                 throw ExceptionUtilities.Unreachable;
             }
@@ -94,7 +94,7 @@ int IVsLanguageDebugInfo.ValidateBreakpointLocation(IVsTextBuffer pBuffer, int i
             {
                 return LanguageDebugInfo.ValidateBreakpointLocation(pBuffer, iLine, iCol, pCodeSpan);
             }
-            catch (Exception e) when (FatalError.ReportAndCatch(e) && false)
+            catch (Exception e) when (FatalError.ReportAndPropagate(e))
             {
                 throw ExceptionUtilities.Unreachable;
             }
diff --git a/src/VisualStudio/Core/Def/Implementation/Watson/FaultReporter.cs b/src/VisualStudio/Core/Def/Implementation/Watson/FaultReporter.cs
index 1997e0fa87b6d..f97465ff8274a 100644
--- a/src/VisualStudio/Core/Def/Implementation/Watson/FaultReporter.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Watson/FaultReporter.cs
@@ -28,21 +28,20 @@ internal static class FaultReporter
 
         public static void InitializeFatalErrorHandlers()
         {
-            // Set both handlers to non-fatal Watson. Never fail-fast the ServiceHub process.
-            // Any exception that is not recovered from shall be propagated and communicated to the client.
-            var nonFatalHandler = FaultReporter.ReportFault;
-            var fatalHandler = new Action<Exception>(static (exception) => ReportFault(exception, forceDump: false));
-
-            FatalError.Handler = fatalHandler;
-            FatalError.NonFatalHandler = nonFatalHandler;
-
-            // We also must set the handlers for the compiler layer as well.
-            var compilerAssembly = typeof(Compilation).Assembly;
-            var compilerFatalErrorType = compilerAssembly.GetType(typeof(FatalError).FullName, throwOnError: true)!;
-            var compilerFatalErrorHandlerProperty = compilerFatalErrorType.GetProperty(nameof(FatalError.Handler), BindingFlags.Static | BindingFlags.Public)!;
-            var compilerNonFatalErrorHandlerProperty = compilerFatalErrorType.GetProperty(nameof(FatalError.NonFatalHandler), BindingFlags.Static | BindingFlags.Public)!;
-            compilerFatalErrorHandlerProperty.SetValue(null, fatalHandler);
-            compilerNonFatalErrorHandlerProperty.SetValue(null, nonFatalHandler);
+            FatalError.Handler = static (exception, severity, forceDump) => ReportFault(exception, ConvertSeverity(severity), forceDump);
+            FatalError.CopyHandlerTo(typeof(Compilation).Assembly);
+        }
+
+        private static FaultSeverity ConvertSeverity(ErrorSeverity severity)
+        {
+            return severity switch
+            {
+                ErrorSeverity.Uncategorized => FaultSeverity.Uncategorized,
+                ErrorSeverity.Diagnostic => FaultSeverity.Diagnostic,
+                ErrorSeverity.General => FaultSeverity.General,
+                ErrorSeverity.Critical => FaultSeverity.Critical,
+                _ => FaultSeverity.Uncategorized
+            };
         }
 
         public static void RegisterTelemetrySesssion(TelemetrySession session)
@@ -83,7 +82,7 @@ public static void UnregisterLogger(TraceSource logger)
         /// <param name="exception">Exception that triggered this non-fatal error</param>
         /// <param name="forceDump">Force a dump to be created, even if the telemetry system is not
         /// requesting one; we will still do a client-side limit to avoid sending too much at once.</param>
-        public static void ReportFault(Exception exception, bool forceDump)
+        public static void ReportFault(Exception exception, FaultSeverity severity, bool forceDump)
         {
             try
             {
@@ -100,7 +99,7 @@ public static void ReportFault(Exception exception, bool forceDump)
                 var faultEvent = new FaultEvent(
                     eventName: FunctionId.NonFatalWatson.GetEventName(),
                     description: GetDescription(exception),
-                    FaultSeverity.Diagnostic,
+                    severity,
                     exceptionObject: exception,
                     gatherEventDetails: faultUtility =>
                     {
diff --git a/src/VisualStudio/Core/Def/Interactive/VsInteractiveWindowPackage.cs b/src/VisualStudio/Core/Def/Interactive/VsInteractiveWindowPackage.cs
index 11d38047fba26..932694e5c7aae 100644
--- a/src/VisualStudio/Core/Def/Interactive/VsInteractiveWindowPackage.cs
+++ b/src/VisualStudio/Core/Def/Interactive/VsInteractiveWindowPackage.cs
@@ -51,15 +51,13 @@ protected override async Task InitializeAsync(CancellationToken cancellationToke
 
             // Set both handlers to non-fatal Watson. Never fail-fast the VS process.
             // Any exception that is not recovered from shall be propagated.
-            var nonFatalHandler = new Action<Exception>(static (exception) => FaultReporter.ReportFault(exception, forceDump: false));
-            InteractiveHostFatalError.Handler = nonFatalHandler;
-            InteractiveHostFatalError.NonFatalHandler = FaultReporter.ReportFault;
-
-            // Load the Roslyn package so that its FatalError handlers are hooked up.
-            shell.LoadPackage(Guids.RoslynPackageId, out var roslynPackage);
+            FaultReporter.InitializeFatalErrorHandlers();
+            FatalError.CopyHandlerTo(typeof(InteractiveHostFatalError).Assembly);
 
             // Explicitly set up FatalError handlers for the InteractiveWindowPackage.
-            var fatalHandler = nonFatalHandler;
+            Action<Exception> fatalHandler = e => FaultReporter.ReportFault(e, VisualStudio.Telemetry.FaultSeverity.Critical, forceDump: false);
+            Action<Exception> nonFatalHandler = e => FaultReporter.ReportFault(e, VisualStudio.Telemetry.FaultSeverity.General, forceDump: false);
+
             SetErrorHandlers(typeof(IInteractiveWindow).Assembly, fatalHandler, nonFatalHandler);
             SetErrorHandlers(typeof(IVsInteractiveWindow).Assembly, fatalHandler, nonFatalHandler);
 

From c7e5c3c321ee968a386ac15917c13d3d3c4923ae Mon Sep 17 00:00:00 2001
From: Jason Malinowski <jason.malinowski@microsoft.com>
Date: Thu, 2 Dec 2021 17:26:17 -0800
Subject: [PATCH 215/444] Give severities to a bunch of the IDE code

My logic for severities was this:

1. If it's anything in the core workspace that will break all features
   (like parsing, semantic model, etc.) it's Critical.
2. If the fault is going to prevent an explicit user gesture from
   working, it's Critical. So an exception breaking go to definition,
   a refactoring, etc., is Critical. We failed to do what the user told
   us.
3. Situations where we failed to do part of a feature are General.
   If we triggered completion but a single provider failed, we are
   missing content, but there's a good chance the user was still able to
   have happen what they wanted.
4. Errors while computing tags for features are General, since it's
   possible we'll catch up if the user had broken code.
5. Situations where we're updating background stuff and the user might
   never notice are Diagnostic.
---
 .../Portable/InternalUtilities/FatalError.cs  | 25 +++++++++++++++++++
 .../CSharpDecompiledSourceService.cs          |  2 +-
 .../Core.Wpf/InlineHints/InlineHintsTagger.cs |  2 +-
 .../CommandHandlers/RenameCommandHandler.cs   |  2 +-
 .../InlineRename/Dashboard/Dashboard.xaml.cs  |  2 +-
 .../Controller.Session_ComputeModel.cs        |  4 +--
 .../SuggestedActionWithNestedActions.cs       |  8 +-----
 .../SuggestedActions/SuggestedAction.cs       |  2 +-
 .../AsyncCompletion/CommitManager.cs          |  4 +--
 .../Implementation/IntelliSense/Helpers.cs    |  2 +-
 ...QuickInfoSourceProvider.QuickInfoSource.cs |  2 +-
 .../NavigationBar/NavigationBarController.cs  |  2 +-
 .../RenameTrackingTaggerProvider.cs           |  2 +-
 ...ReferenceHighlightingViewTaggerProvider.cs |  2 +-
 .../Extensions/ITextBufferEditExtensions.cs   |  2 +-
 .../CrefCompletionProvider.cs                 |  2 +-
 .../DeclarationNameCompletionProvider.cs      |  2 +-
 ...mAndCompletionListTagCompletionProvider.cs |  2 +-
 ...plicitInterfaceMemberCompletionProvider.cs |  2 +-
 ...ExplicitInterfaceTypeCompletionProvider.cs |  2 +-
 .../ExternAliasCompletionProvider.cs          |  2 +-
 ...agedCallingConventionCompletionProvider.cs |  2 +-
 .../NamedParameterCompletionProvider.cs       |  2 +-
 .../SnippetCompletionProvider.cs              |  2 +-
 .../SpeculativeTCompletionProvider.cs         |  2 +-
 .../TupleNameCompletionProvider.cs            |  2 +-
 .../XmlDocCommentCompletionProvider.cs        |  2 +-
 ...actInternalsVisibleToCompletionProvider.cs |  2 +-
 .../AbstractPartialTypeCompletionProvider.cs  |  2 +-
 .../AbstractSymbolCompletionProvider.cs       |  2 +-
 ...AbstractDirectivePathCompletionProvider.cs |  2 +-
 .../ExtractMethod/ExtractMethodMatrix.cs      |  2 +-
 .../AbstractNewDocumentFormattingService.cs   |  2 +-
 ...compilationMetadataAsSourceFileProvider.cs |  2 +-
 src/VisualStudio/CSharp/Impl/CSharpPackage.cs |  2 +-
 .../VisualStudioDesignerAttributeService.cs   |  2 +-
 ...AnalyzerProvider.WorkspaceEventListener.cs |  2 +-
 .../AbstractObjectBrowserLibraryManager.cs    |  5 ++--
 .../Library/ObjectBrowser/ObjectList.cs       |  2 +-
 .../Progression/GraphQueryManager.cs          |  2 +-
 .../ProjectSystem/InvisibleEditor.cs          |  2 +-
 .../VisualStudioProjectTelemetryService.cs    |  2 +-
 src/VisualStudio/Core/Def/RoslynPackage.cs    |  2 +-
 .../ConflictResolver.Session.cs               | 12 ++++-----
 .../Portable/Workspace/Solution/Document.cs   |  2 +-
 .../Workspace/Solution/DocumentState.cs       |  8 +++---
 .../Solution/ProjectState_Checksum.cs         |  2 +-
 .../SolutionState.CompilationTracker.cs       | 12 ++++-----
 .../Workspace/Solution/SolutionState.cs       |  6 ++---
 .../Portable/Workspace/Workspace_Editor.cs    |  2 +-
 .../Extensions/ITypeSymbolExtensions.cs       |  2 +-
 51 files changed, 93 insertions(+), 75 deletions(-)

diff --git a/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs b/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs
index 6a313555c6d88..985e5fc95836b 100644
--- a/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs
+++ b/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs
@@ -249,11 +249,36 @@ private static void Report(Exception exception, ErrorSeverity severity = ErrorSe
         }
     }
 
+    /// <summary>
+    /// The severity of the error, see the enum members for a description of when to use each. This is metadata that's included
+    /// in a non-fatal fault report, which we can take advantage of on the backend to automatically triage bugs. For example,
+    /// a critical severity issue we can open with a lower bug count compared to a low priority one.
+    /// </summary>
     internal enum ErrorSeverity
     {
+        /// <summary>
+        /// The severity hasn't been categorized. Don't use this in new code.
+        /// </summary>
         Uncategorized,
+
+        /// <summary>
+        /// Something failed, but the user is unlikely to notice. Especially useful for background things that we can silently recover
+        /// from, like bugs in caching systems.
+        /// </summary>
         Diagnostic,
+
+        /// <summary>
+        /// Something failed, and the user might notice, but they're still likely able to carry on. For example, if the user
+        /// asked for some information from the IDE (find references, completion, etc.) and we were able to give partial results.
+        /// </summary>
         General,
+
+        /// <summary>
+        /// Something failed, and the user likely noticed. For example, the user pressed a button to do an action, and
+        /// we threw an exception so we completely failed to do that in an unrecoverable way. This may also be used
+        /// for back-end systems where a failure is going to result in a highly broken experience, for example if parsing a file
+        /// catastrophically failed.
+        /// </summary>
         Critical
     }
 }
diff --git a/src/EditorFeatures/CSharp/DecompiledSource/CSharpDecompiledSourceService.cs b/src/EditorFeatures/CSharp/DecompiledSource/CSharpDecompiledSourceService.cs
index 0950c9f0384cc..965cd834f56e8 100644
--- a/src/EditorFeatures/CSharp/DecompiledSource/CSharpDecompiledSourceService.cs
+++ b/src/EditorFeatures/CSharp/DecompiledSource/CSharpDecompiledSourceService.cs
@@ -59,7 +59,7 @@ public async Task<Document> AddSourceToAsync(Document document, Compilation symb
                     var fullAssemblyName = symbol.ContainingAssembly.Identity.GetDisplayName();
                     GlobalAssemblyCache.Instance.ResolvePartialName(fullAssemblyName, out assemblyLocation, preferredCulture: CultureInfo.CurrentCulture);
                 }
-                catch (Exception e) when (FatalError.ReportAndCatch(e))
+                catch (Exception e) when (FatalError.ReportAndCatch(e, ErrorSeverity.Diagnostic))
                 {
                 }
             }
diff --git a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTagger.cs b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTagger.cs
index 11caa28addd81..f3d5a74fb41d5 100644
--- a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTagger.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTagger.cs
@@ -168,7 +168,7 @@ public IEnumerable<ITagSpan<IntraTextAdornmentTag>> GetTags(NormalizedSnapshotSp
 
                 return selectedSpans;
             }
-            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e))
+            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, ErrorSeverity.General))
             {
                 throw ExceptionUtilities.Unreachable;
             }
diff --git a/src/EditorFeatures/Core.Wpf/InlineRename/CommandHandlers/RenameCommandHandler.cs b/src/EditorFeatures/Core.Wpf/InlineRename/CommandHandlers/RenameCommandHandler.cs
index ab4214d0f94a3..586f40a466758 100644
--- a/src/EditorFeatures/Core.Wpf/InlineRename/CommandHandlers/RenameCommandHandler.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineRename/CommandHandlers/RenameCommandHandler.cs
@@ -104,7 +104,7 @@ protected override void Commit(InlineRenameSession activeSession, ITextView text
                 var notificationService = activeSession.Workspace.Services.GetService<INotificationService>();
                 notificationService?.SendNotification(ex.Message, title: EditorFeaturesResources.Rename, severity: NotificationSeverity.Error);
             }
-            catch (Exception ex) when (FatalError.ReportAndCatch(ex))
+            catch (Exception ex) when (FatalError.ReportAndCatch(ex, ErrorSeverity.Critical))
             {
                 // Show a nice error to the user via an info bar
                 var errorReportingService = activeSession.Workspace.Services.GetService<IErrorReportingService>();
diff --git a/src/EditorFeatures/Core.Wpf/InlineRename/Dashboard/Dashboard.xaml.cs b/src/EditorFeatures/Core.Wpf/InlineRename/Dashboard/Dashboard.xaml.cs
index cdbc0d90fd25c..33391dd5aa541 100644
--- a/src/EditorFeatures/Core.Wpf/InlineRename/Dashboard/Dashboard.xaml.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineRename/Dashboard/Dashboard.xaml.cs
@@ -343,7 +343,7 @@ private void Commit()
                 var notificationService = _model.Session.Workspace.Services.GetService<INotificationService>();
                 notificationService.SendNotification(ex.Message, title: EditorFeaturesResources.Rename, severity: NotificationSeverity.Error);
             }
-            catch (Exception ex) when (FatalError.ReportAndCatch(ex))
+            catch (Exception ex) when (FatalError.ReportAndCatch(ex, ErrorSeverity.Critical))
             {
                 // Show a nice error to the user via an info bar
                 var errorReportingService = _model.Session.Workspace.Services.GetService<IErrorReportingService>();
diff --git a/src/EditorFeatures/Core.Wpf/SignatureHelp/Controller.Session_ComputeModel.cs b/src/EditorFeatures/Core.Wpf/SignatureHelp/Controller.Session_ComputeModel.cs
index 0fcd7ece319a6..d317fb8f92c13 100644
--- a/src/EditorFeatures/Core.Wpf/SignatureHelp/Controller.Session_ComputeModel.cs
+++ b/src/EditorFeatures/Core.Wpf/SignatureHelp/Controller.Session_ComputeModel.cs
@@ -127,7 +127,7 @@ private async Task<Model> ComputeModelInBackgroundAsync(
                                     .WithSelectedParameter(selection.SelectedParameter);
                     }
                 }
-                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
+                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken, ErrorSeverity.Critical))
                 {
                     throw ExceptionUtilities.Unreachable;
                 }
@@ -220,7 +220,7 @@ private static bool CompareParts(TaggedText p1, TaggedText p2)
 
                     return (bestProvider, bestItems);
                 }
-                catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, cancellationToken))
+                catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, cancellationToken, ErrorSeverity.Critical))
                 {
                     return (null, null);
                 }
diff --git a/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionWithNestedActions.cs b/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionWithNestedActions.cs
index 805485d08aa56..be030502e72cc 100644
--- a/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionWithNestedActions.cs
+++ b/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActionWithNestedActions.cs
@@ -56,13 +56,7 @@ protected override Task InnerInvokeAsync(IProgressTracker progressTracker, Cance
             // Report a message in debug and log a watson exception so that if this is hit we can try to narrow down how
             // this happened.
             Debug.Fail($"{nameof(InnerInvokeAsync)} should not be called on a {nameof(SuggestedActionWithNestedActions)}");
-            try
-            {
-                throw new InvalidOperationException($"{nameof(InnerInvokeAsync)} should not be called on a {nameof(SuggestedActionWithNestedActions)}");
-            }
-            catch (Exception e) when (FatalError.ReportAndCatch(e))
-            {
-            }
+            FatalError.ReportAndCatch(new InvalidOperationException($"{nameof(InnerInvokeAsync)} should not be called on a {nameof(SuggestedActionWithNestedActions)}"), ErrorSeverity.Critical);
 
             return Task.CompletedTask;
         }
diff --git a/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActions/SuggestedAction.cs b/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActions/SuggestedAction.cs
index d0b9bbf148a31..619e455ae9dfb 100644
--- a/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActions/SuggestedAction.cs
+++ b/src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActions/SuggestedAction.cs
@@ -122,7 +122,7 @@ private async Task InvokeAsync()
             catch (OperationCanceledException)
             {
             }
-            catch (Exception ex) when (FatalError.ReportAndCatch(ex))
+            catch (Exception ex) when (FatalError.ReportAndCatch(ex, ErrorSeverity.Critical))
             {
             }
         }
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/CommitManager.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/CommitManager.cs
index 744288f43c5a4..7e9e52c4f060a 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/CommitManager.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/CommitManager.cs
@@ -186,13 +186,13 @@ private AsyncCompletionData.CommitResult Commit(
             if (!subjectBuffer.CheckEditAccess())
             {
                 // We are on the wrong thread.
-                FatalError.ReportAndCatch(new InvalidOperationException("Subject buffer did not provide Edit Access"));
+                FatalError.ReportAndCatch(new InvalidOperationException("Subject buffer did not provide Edit Access"), ErrorSeverity.Critical);
                 return new AsyncCompletionData.CommitResult(isHandled: true, AsyncCompletionData.CommitBehavior.None);
             }
 
             if (subjectBuffer.EditInProgress)
             {
-                FatalError.ReportAndCatch(new InvalidOperationException("Subject buffer is editing by someone else."));
+                FatalError.ReportAndCatch(new InvalidOperationException("Subject buffer is editing by someone else."), ErrorSeverity.Critical);
                 return new AsyncCompletionData.CommitResult(isHandled: true, AsyncCompletionData.CommitBehavior.None);
             }
 
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/Helpers.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/Helpers.cs
index 4b9273e518a69..616eabe5719a6 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/Helpers.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/Helpers.cs
@@ -225,7 +225,7 @@ await GoToDefinitionHelpers.TryGoToDefinitionAsync(
             catch (OperationCanceledException)
             {
             }
-            catch (Exception ex) when (FatalError.ReportAndCatch(ex))
+            catch (Exception ex) when (FatalError.ReportAndCatch(ex, ErrorSeverity.Critical))
             {
             }
         }
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/QuickInfoSourceProvider.QuickInfoSource.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/QuickInfoSourceProvider.QuickInfoSource.cs
index 5dc55ed918d27..8d976778353b6 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/QuickInfoSourceProvider.QuickInfoSource.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/QuickInfoSourceProvider.QuickInfoSource.cs
@@ -83,7 +83,7 @@ public async Task<IntellisenseQuickInfoItem> GetQuickInfoItemAsync(IAsyncQuickIn
                         return null;
                     }
                 }
-                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
+                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken, ErrorSeverity.Critical))
                 {
                     throw ExceptionUtilities.Unreachable;
                 }
diff --git a/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarController.cs b/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarController.cs
index 4a7fcfcbb667e..7d4858061767c 100644
--- a/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarController.cs
+++ b/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarController.cs
@@ -212,7 +212,7 @@ private async Task OnItemSelectedAsync(NavigationBarItem item)
             catch (OperationCanceledException)
             {
             }
-            catch (Exception e) when (FatalError.ReportAndCatch(e))
+            catch (Exception e) when (FatalError.ReportAndCatch(e, ErrorSeverity.Critical))
             {
             }
         }
diff --git a/src/EditorFeatures/Core/Implementation/RenameTracking/RenameTrackingTaggerProvider.cs b/src/EditorFeatures/Core/Implementation/RenameTracking/RenameTrackingTaggerProvider.cs
index eb25f64846d20..eccd539c59f90 100644
--- a/src/EditorFeatures/Core/Implementation/RenameTracking/RenameTrackingTaggerProvider.cs
+++ b/src/EditorFeatures/Core/Implementation/RenameTracking/RenameTrackingTaggerProvider.cs
@@ -129,7 +129,7 @@ public static (CodeAction action, TextSpan renameSpan) TryGetCodeAction(
 
                 return default;
             }
-            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
+            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken, ErrorSeverity.General))
             {
                 throw ExceptionUtilities.Unreachable;
             }
diff --git a/src/EditorFeatures/Core/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs b/src/EditorFeatures/Core/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs
index 9efa11206ebfa..c2154aff96fbe 100644
--- a/src/EditorFeatures/Core/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs
+++ b/src/EditorFeatures/Core/ReferenceHighlighting/ReferenceHighlightingViewTaggerProvider.cs
@@ -193,7 +193,7 @@ private static void AddTagSpans(
                         textSnapshot.GetSpan(Span.FromBounds(span.TextSpan.Start, span.TextSpan.End)), tag));
                 }
             }
-            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, cancellationToken))
+            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, cancellationToken, ErrorSeverity.General))
             {
                 // report NFW and continue.
                 // also, rather than return partial results, return nothing
diff --git a/src/EditorFeatures/Core/Shared/Extensions/ITextBufferEditExtensions.cs b/src/EditorFeatures/Core/Shared/Extensions/ITextBufferEditExtensions.cs
index f8f0ddbb21e02..4b89d10366aec 100644
--- a/src/EditorFeatures/Core/Shared/Extensions/ITextBufferEditExtensions.cs
+++ b/src/EditorFeatures/Core/Shared/Extensions/ITextBufferEditExtensions.cs
@@ -24,7 +24,7 @@ public static ITextSnapshot ApplyAndLogExceptions(this ITextBufferEdit edit)
             {
                 return edit.Apply();
             }
-            catch (Exception e) when (ErrorReporting.FatalError.ReportAndCatch(e))
+            catch (Exception e) when (ErrorReporting.FatalError.ReportAndCatch(e, ErrorReporting.ErrorSeverity.Critical))
             {
                 s_lastException = e;
 
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/CrefCompletionProvider.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/CrefCompletionProvider.cs
index 869522aacbd16..b8e03bf4936ee 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/CrefCompletionProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/CrefCompletionProvider.cs
@@ -103,7 +103,7 @@ public override async Task ProvideCompletionsAsync(CompletionContext context)
 
                 context.AddItems(items);
             }
-            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e))
+            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, ErrorSeverity.General))
             {
                 // nop
             }
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationNameCompletionProvider.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationNameCompletionProvider.cs
index 77ebde0e1ae8b..14594202831c4 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationNameCompletionProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationNameCompletionProvider.cs
@@ -85,7 +85,7 @@ public override async Task ProvideCompletionsAsync(CompletionContext completionC
                 completionContext.SuggestionModeItem = CommonCompletionItem.Create(
                     CSharpFeaturesResources.Name, displayTextSuffix: "", CompletionItemRules.Default);
             }
-            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e))
+            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, ErrorSeverity.General))
             {
                 // nop
             }
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/EnumAndCompletionListTagCompletionProvider.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/EnumAndCompletionListTagCompletionProvider.cs
index dc94d2fb05715..04acad8262680 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/EnumAndCompletionListTagCompletionProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/EnumAndCompletionListTagCompletionProvider.cs
@@ -97,7 +97,7 @@ public override async Task ProvideCompletionsAsync(CompletionContext context)
                 foreach (var type in types)
                     await HandleSingleTypeAsync(context, semanticModel, token, type, cancellationToken).ConfigureAwait(false);
             }
-            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e))
+            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, ErrorSeverity.General))
             {
                 throw ExceptionUtilities.Unreachable;
             }
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/ExplicitInterfaceMemberCompletionProvider.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/ExplicitInterfaceMemberCompletionProvider.cs
index eff5ffd36569f..58f311c6ec386 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/ExplicitInterfaceMemberCompletionProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/ExplicitInterfaceMemberCompletionProvider.cs
@@ -115,7 +115,7 @@ public override async Task ProvideCompletionsAsync(CompletionContext context)
                         rules: CompletionItemRules.Default));
                 }
             }
-            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e))
+            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, ErrorSeverity.General))
             {
                 // nop
             }
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/ExplicitInterfaceTypeCompletionProvider.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/ExplicitInterfaceTypeCompletionProvider.cs
index 1ee26b27a464d..369af6c796432 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/ExplicitInterfaceTypeCompletionProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/ExplicitInterfaceTypeCompletionProvider.cs
@@ -59,7 +59,7 @@ public override async Task ProvideCompletionsAsync(CompletionContext context)
                         CSharpFeaturesResources.Autoselect_disabled_due_to_member_declaration);
                 }
             }
-            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e))
+            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, ErrorSeverity.General))
             {
                 // nop
             }
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/ExternAliasCompletionProvider.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/ExternAliasCompletionProvider.cs
index 1c7242855f2e4..a6dd342e8c75a 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/ExternAliasCompletionProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/ExternAliasCompletionProvider.cs
@@ -88,7 +88,7 @@ public override async Task ProvideCompletionsAsync(CompletionContext context)
                     }
                 }
             }
-            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e))
+            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, ErrorSeverity.General))
             {
                 // nop
             }
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/FunctionPointerUnmanagedCallingConventionCompletionProvider.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/FunctionPointerUnmanagedCallingConventionCompletionProvider.cs
index f804c475cd500..3a7dbf9ea04d4 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/FunctionPointerUnmanagedCallingConventionCompletionProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/FunctionPointerUnmanagedCallingConventionCompletionProvider.cs
@@ -85,7 +85,7 @@ public override async Task ProvideCompletionsAsync(CompletionContext context)
 
                 context.AddItems(completionItems);
             }
-            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e))
+            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, ErrorSeverity.General))
             {
                 // nop
             }
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/NamedParameterCompletionProvider.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/NamedParameterCompletionProvider.cs
index e659c25c781b0..3c150e28420de 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/NamedParameterCompletionProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/NamedParameterCompletionProvider.cs
@@ -126,7 +126,7 @@ public override async Task ProvideCompletionsAsync(CompletionContext context)
                         filterText: escapedName));
                 }
             }
-            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e))
+            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, ErrorSeverity.General))
             {
                 // nop
             }
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/SnippetCompletionProvider.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/SnippetCompletionProvider.cs
index 1671ec5a51f57..3ffb2b6c6a304 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/SnippetCompletionProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/SnippetCompletionProvider.cs
@@ -68,7 +68,7 @@ public override async Task ProvideCompletionsAsync(CompletionContext context)
                         d => GetSnippetsForDocumentAsync(d, position, cancellationToken)).ConfigureAwait(false));
                 }
             }
-            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e))
+            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, ErrorSeverity.General))
             {
                 // nop
             }
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/SpeculativeTCompletionProvider.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/SpeculativeTCompletionProvider.cs
index d89fbf529f2f4..9ce5cb6095dd6 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/SpeculativeTCompletionProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/SpeculativeTCompletionProvider.cs
@@ -57,7 +57,7 @@ public override async Task ProvideCompletionsAsync(CompletionContext context)
                         T, displayTextSuffix: "", CompletionItemRules.Default, glyph: Glyph.TypeParameter));
                 }
             }
-            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e))
+            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, ErrorSeverity.General))
             {
                 // nop
             }
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/TupleNameCompletionProvider.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/TupleNameCompletionProvider.cs
index cffaa5013f7cc..74049eb26f8b2 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/TupleNameCompletionProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/TupleNameCompletionProvider.cs
@@ -62,7 +62,7 @@ public override async Task ProvideCompletionsAsync(CompletionContext completionC
 
                 AddItems(inferredTypes, index.Value, completionContext, context.TargetToken.Parent.SpanStart);
             }
-            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e))
+            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, ErrorSeverity.General))
             {
                 // nop
             }
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.cs
index 09282b49d44f3..10e98f38ec639 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.cs
@@ -156,7 +156,7 @@ public override bool IsInsertionTrigger(SourceText text, int characterPosition,
                 items.AddRange(GetAlwaysVisibleItems());
                 return items;
             }
-            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, cancellationToken))
+            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, cancellationToken, ErrorSeverity.General))
             {
                 return SpecializedCollections.EmptyEnumerable<CompletionItem>();
             }
diff --git a/src/Features/Core/Portable/Completion/Providers/AbstractInternalsVisibleToCompletionProvider.cs b/src/Features/Core/Portable/Completion/Providers/AbstractInternalsVisibleToCompletionProvider.cs
index 10f61282a7f52..badd89e5735e5 100644
--- a/src/Features/Core/Portable/Completion/Providers/AbstractInternalsVisibleToCompletionProvider.cs
+++ b/src/Features/Core/Portable/Completion/Providers/AbstractInternalsVisibleToCompletionProvider.cs
@@ -74,7 +74,7 @@ public override async Task ProvideCompletionsAsync(CompletionContext context)
                     }
                 }
             }
-            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e))
+            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, ErrorSeverity.General))
             {
                 // nop
             }
diff --git a/src/Features/Core/Portable/Completion/Providers/AbstractPartialTypeCompletionProvider.cs b/src/Features/Core/Portable/Completion/Providers/AbstractPartialTypeCompletionProvider.cs
index 01fc0d3685609..44af16ee4fd78 100644
--- a/src/Features/Core/Portable/Completion/Providers/AbstractPartialTypeCompletionProvider.cs
+++ b/src/Features/Core/Portable/Completion/Providers/AbstractPartialTypeCompletionProvider.cs
@@ -52,7 +52,7 @@ public sealed override async Task ProvideCompletionsAsync(CompletionContext comp
                     }
                 }
             }
-            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e))
+            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, ErrorSeverity.General))
             {
                 // nop
             }
diff --git a/src/Features/Core/Portable/Completion/Providers/AbstractSymbolCompletionProvider.cs b/src/Features/Core/Portable/Completion/Providers/AbstractSymbolCompletionProvider.cs
index cf5e438cdd7c5..ba57111097f0a 100644
--- a/src/Features/Core/Portable/Completion/Providers/AbstractSymbolCompletionProvider.cs
+++ b/src/Features/Core/Portable/Completion/Providers/AbstractSymbolCompletionProvider.cs
@@ -267,7 +267,7 @@ public override async Task ProvideCompletionsAsync(CompletionContext completionC
                     completionContext.AddItems(regularItems);
                 }
             }
-            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e))
+            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, ErrorSeverity.General))
             {
                 // nop
             }
diff --git a/src/Features/Core/Portable/Completion/Providers/Scripting/AbstractDirectivePathCompletionProvider.cs b/src/Features/Core/Portable/Completion/Providers/Scripting/AbstractDirectivePathCompletionProvider.cs
index 9c443daa0e12f..860415c398969 100644
--- a/src/Features/Core/Portable/Completion/Providers/Scripting/AbstractDirectivePathCompletionProvider.cs
+++ b/src/Features/Core/Portable/Completion/Providers/Scripting/AbstractDirectivePathCompletionProvider.cs
@@ -59,7 +59,7 @@ public sealed override async Task ProvideCompletionsAsync(CompletionContext cont
 
                 await ProvideCompletionsAsync(context, pathThroughLastSlash).ConfigureAwait(false);
             }
-            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e))
+            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, ErrorSeverity.General))
             {
                 // nop
             }
diff --git a/src/Features/Core/Portable/ExtractMethod/ExtractMethodMatrix.cs b/src/Features/Core/Portable/ExtractMethod/ExtractMethodMatrix.cs
index 55b7fe25afa52..69af3789af692 100644
--- a/src/Features/Core/Portable/ExtractMethod/ExtractMethodMatrix.cs
+++ b/src/Features/Core/Portable/ExtractMethod/ExtractMethodMatrix.cs
@@ -95,7 +95,7 @@ public static bool TryGetVariableStyle(
 
             // Some combination we didn't anticipate.  Can't do anything here.  Log the issue
             // and bail out.
-            FatalError.ReportAndCatch(new Exception($"extract method encountered unknown states: {key.ToString()}"));
+            FatalError.ReportAndCatch(new Exception($"extract method encountered unknown states: {key.ToString()}"), ErrorSeverity.Critical);
 
             return false;
         }
diff --git a/src/Features/Core/Portable/Formatting/AbstractNewDocumentFormattingService.cs b/src/Features/Core/Portable/Formatting/AbstractNewDocumentFormattingService.cs
index d7585381722b9..ab129104e169e 100644
--- a/src/Features/Core/Portable/Formatting/AbstractNewDocumentFormattingService.cs
+++ b/src/Features/Core/Portable/Formatting/AbstractNewDocumentFormattingService.cs
@@ -43,7 +43,7 @@ public async Task<Document> FormatNewDocumentAsync(Document document, Document?
                 {
                     document = await provider.FormatNewDocumentAsync(document, hintDocument, cancellationToken).ConfigureAwait(false);
                 }
-                catch (Exception ex) when (FatalError.ReportAndCatchUnlessCanceled(ex, cancellationToken))
+                catch (Exception ex) when (FatalError.ReportAndCatchUnlessCanceled(ex, cancellationToken, ErrorSeverity.General))
                 {
                 }
             }
diff --git a/src/Features/Core/Portable/MetadataAsSource/DecompilationMetadataAsSourceFileProvider.cs b/src/Features/Core/Portable/MetadataAsSource/DecompilationMetadataAsSourceFileProvider.cs
index 9ce773fbb8ba0..0112c5baf638a 100644
--- a/src/Features/Core/Portable/MetadataAsSource/DecompilationMetadataAsSourceFileProvider.cs
+++ b/src/Features/Core/Portable/MetadataAsSource/DecompilationMetadataAsSourceFileProvider.cs
@@ -84,7 +84,7 @@ public DecompilationMetadataAsSourceFileProvider()
                             useDecompiler = false;
                         }
                     }
-                    catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, cancellationToken))
+                    catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, cancellationToken, ErrorSeverity.General))
                     {
                         useDecompiler = false;
                     }
diff --git a/src/VisualStudio/CSharp/Impl/CSharpPackage.cs b/src/VisualStudio/CSharp/Impl/CSharpPackage.cs
index 70b3c4cc12017..06a800c402b74 100644
--- a/src/VisualStudio/CSharp/Impl/CSharpPackage.cs
+++ b/src/VisualStudio/CSharp/Impl/CSharpPackage.cs
@@ -75,7 +75,7 @@ protected override async Task InitializeAsync(CancellationToken cancellationToke
                     return new TempPECompilerService(workspace.Services.GetService<IMetadataService>());
                 });
             }
-            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e))
+            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, ErrorSeverity.General))
             {
             }
         }
diff --git a/src/VisualStudio/Core/Def/Implementation/DesignerAttribute/VisualStudioDesignerAttributeService.cs b/src/VisualStudio/Core/Def/Implementation/DesignerAttribute/VisualStudioDesignerAttributeService.cs
index 52df9e1854c5e..b52eed885ed53 100644
--- a/src/VisualStudio/Core/Def/Implementation/DesignerAttribute/VisualStudioDesignerAttributeService.cs
+++ b/src/VisualStudio/Core/Def/Implementation/DesignerAttribute/VisualStudioDesignerAttributeService.cs
@@ -104,7 +104,7 @@ private async Task StartAsync()
             {
                 // Cancellation is normal (during VS closing).  Just ignore.
             }
-            catch (Exception e) when (FatalError.ReportAndCatch(e))
+            catch (Exception e) when (FatalError.ReportAndCatch(e, ErrorSeverity.Diagnostic))
             {
                 // Otherwise report a watson for any other exception.  Don't bring down VS.  This is
                 // a BG service we don't want impacting the user experience.
diff --git a/src/VisualStudio/Core/Def/Implementation/Diagnostics/VisualStudioDiagnosticAnalyzerProvider.WorkspaceEventListener.cs b/src/VisualStudio/Core/Def/Implementation/Diagnostics/VisualStudioDiagnosticAnalyzerProvider.WorkspaceEventListener.cs
index d1b5c931b47bb..6bad518c9ea18 100644
--- a/src/VisualStudio/Core/Def/Implementation/Diagnostics/VisualStudioDiagnosticAnalyzerProvider.WorkspaceEventListener.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Diagnostics/VisualStudioDiagnosticAnalyzerProvider.WorkspaceEventListener.cs
@@ -67,7 +67,7 @@ private async Task InitializeWorkspaceAsync(ISolutionAnalyzerSetterWorkspaceServ
                     LogWorkspaceAnalyzerCount(references.Length);
                     setter.SetAnalyzerReferences(references);
                 }
-                catch (Exception e) when (FatalError.ReportAndPropagate(e))
+                catch (Exception e) when (FatalError.ReportAndPropagate(e, ErrorSeverity.Diagnostic))
                 {
                     throw ExceptionUtilities.Unreachable;
                 }
diff --git a/src/VisualStudio/Core/Def/Implementation/Library/ObjectBrowser/AbstractObjectBrowserLibraryManager.cs b/src/VisualStudio/Core/Def/Implementation/Library/ObjectBrowser/AbstractObjectBrowserLibraryManager.cs
index 6f51d8148d9a2..ef568a77b161d 100644
--- a/src/VisualStudio/Core/Def/Implementation/Library/ObjectBrowser/AbstractObjectBrowserLibraryManager.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Library/ObjectBrowser/AbstractObjectBrowserLibraryManager.cs
@@ -133,9 +133,8 @@ private void UpdateDocument(Document oldDocument, Document newDocument)
 
                 UpdateClassAndMemberVersions();
             }
-            catch (Exception e) when (FatalError.ReportAndPropagate(e))
+            catch (Exception e) when (FatalError.ReportAndCatch(e, ErrorSeverity.Diagnostic))
             {
-                // make it crash VS on any exception
             }
         }
 
@@ -539,7 +538,7 @@ await Task.Run(
             catch (OperationCanceledException)
             {
             }
-            catch (Exception e) when (FatalError.ReportAndCatch(e))
+            catch (Exception e) when (FatalError.ReportAndCatch(e, ErrorSeverity.Critical))
             {
             }
         }
diff --git a/src/VisualStudio/Core/Def/Implementation/Library/ObjectBrowser/ObjectList.cs b/src/VisualStudio/Core/Def/Implementation/Library/ObjectBrowser/ObjectList.cs
index 9f17a30f983c7..15a48b5f35d4a 100644
--- a/src/VisualStudio/Core/Def/Implementation/Library/ObjectBrowser/ObjectList.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Library/ObjectBrowser/ObjectList.cs
@@ -765,7 +765,7 @@ protected override async Task GoToSourceAsync(uint index, VSOBJGOTOSRCTYPE srcTy
             catch (OperationCanceledException)
             {
             }
-            catch (Exception ex) when (FatalError.ReportAndCatch(ex))
+            catch (Exception ex) when (FatalError.ReportAndCatch(ex, ErrorSeverity.Critical))
             {
             }
         }
diff --git a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueryManager.cs b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueryManager.cs
index 496a36eba710b..d5d278a403db1 100644
--- a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueryManager.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueryManager.cs
@@ -176,7 +176,7 @@ private static async Task PopulateContextGraphAsync(Solution solution, List<IGra
 
                 transaction.Complete();
             }
-            catch (Exception ex) when (FatalError.ReportAndPropagateUnlessCanceled(ex))
+            catch (Exception ex) when (FatalError.ReportAndPropagateUnlessCanceled(ex, ErrorSeverity.Diagnostic))
             {
                 throw ExceptionUtilities.Unreachable;
             }
diff --git a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/InvisibleEditor.cs b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/InvisibleEditor.cs
index be59497aad5e6..a682d829480c2 100644
--- a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/InvisibleEditor.cs
+++ b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/InvisibleEditor.cs
@@ -153,7 +153,7 @@ public void Dispose()
 
                 GC.SuppressFinalize(this);
             }
-            catch (Exception ex) when (FatalError.ReportAndPropagate(ex))
+            catch (Exception ex) when (FatalError.ReportAndPropagate(ex, ErrorSeverity.Critical)) // critical severity, since this means we're not saving edited files
             {
                 throw ExceptionUtilities.Unreachable;
             }
diff --git a/src/VisualStudio/Core/Def/Implementation/ProjectTelemetry/VisualStudioProjectTelemetryService.cs b/src/VisualStudio/Core/Def/Implementation/ProjectTelemetry/VisualStudioProjectTelemetryService.cs
index f29c8a9d05d17..b5c3aeeebcfc5 100644
--- a/src/VisualStudio/Core/Def/Implementation/ProjectTelemetry/VisualStudioProjectTelemetryService.cs
+++ b/src/VisualStudio/Core/Def/Implementation/ProjectTelemetry/VisualStudioProjectTelemetryService.cs
@@ -94,7 +94,7 @@ private async Task StartAsync()
             {
                 // Cancellation is normal (during VS closing).  Just ignore.
             }
-            catch (Exception e) when (FatalError.ReportAndCatch(e))
+            catch (Exception e) when (FatalError.ReportAndCatch(e, ErrorSeverity.Diagnostic))
             {
                 // Otherwise report a watson for any other exception.  Don't bring down VS.  This is
                 // a BG service we don't want impacting the user experience.
diff --git a/src/VisualStudio/Core/Def/RoslynPackage.cs b/src/VisualStudio/Core/Def/RoslynPackage.cs
index 5cfd84c835325..20b0357de6aca 100644
--- a/src/VisualStudio/Core/Def/RoslynPackage.cs
+++ b/src/VisualStudio/Core/Def/RoslynPackage.cs
@@ -396,7 +396,7 @@ void StartBulkFileOperationNotification()
                     // so guarding us from them
                     if (localRegistration != null)
                     {
-                        FatalError.ReportAndCatch(new InvalidOperationException("BulkFileOperation already exist"));
+                        FatalError.ReportAndCatch(new InvalidOperationException("BulkFileOperation already exist"), ErrorSeverity.General);
                         return;
                     }
 
diff --git a/src/Workspaces/Core/Portable/Rename/ConflictEngine/ConflictResolver.Session.cs b/src/Workspaces/Core/Portable/Rename/ConflictEngine/ConflictResolver.Session.cs
index bf2602c858595..bd37bdd8c01f9 100644
--- a/src/Workspaces/Core/Portable/Rename/ConflictEngine/ConflictResolver.Session.cs
+++ b/src/Workspaces/Core/Portable/Rename/ConflictEngine/ConflictResolver.Session.cs
@@ -252,7 +252,7 @@ await conflictResolution.CurrentSolution.GetRequiredDocument(_documentIdOfRename
 
                     return conflictResolution;
                 }
-                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e))
+                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, ErrorSeverity.Critical))
                 {
                     throw ExceptionUtilities.Unreachable;
                 }
@@ -458,7 +458,7 @@ await AddDeclarationConflictsAsync(
 
                     return conflictResolution.RelatedLocations.Any(r => r.Type == RelatedLocationType.PossiblyResolvableConflict);
                 }
-                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e))
+                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, ErrorSeverity.Critical))
                 {
                     throw ExceptionUtilities.Unreachable;
                 }
@@ -638,7 +638,7 @@ private async Task<bool> CheckForConflictAsync(
 
                     return hasConflict;
                 }
-                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e))
+                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, ErrorSeverity.Critical))
                 {
                     throw ExceptionUtilities.Unreachable;
                 }
@@ -680,7 +680,7 @@ private async Task<ISymbol> GetRenamedSymbolInCurrentSolutionAsync(MutableConfli
                     var newSymbol = await SymbolFinder.FindSymbolAtPositionAsync(document, start, cancellationToken: _cancellationToken).ConfigureAwait(false);
                     return newSymbol;
                 }
-                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e))
+                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, ErrorSeverity.Critical))
                 {
                     throw ExceptionUtilities.Unreachable;
                 }
@@ -711,7 +711,7 @@ private async Task FindDocumentsAndPossibleNameConflictsAsync()
 
                     await AddDocumentsWithPotentialConflictsAsync(documentsFromAffectedProjects).ConfigureAwait(false);
                 }
-                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e))
+                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, ErrorSeverity.Critical))
                 {
                     throw ExceptionUtilities.Unreachable;
                 }
@@ -752,7 +752,7 @@ private async Task AddDocumentsWithPotentialConflictsAsync(IEnumerable<Document>
                         }
                     }
                 }
-                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e))
+                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, ErrorSeverity.Critical))
                 {
                     throw ExceptionUtilities.Unreachable;
                 }
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs b/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs
index 36e124ca40c92..d6e00ff23f2e8 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs
@@ -312,7 +312,7 @@ public bool TryGetSemanticModel([NotNullWhen(returnValue: true)] out SemanticMod
                     return result;
                 }
             }
-            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
+            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken, ErrorSeverity.Critical))
             {
                 throw ExceptionUtilities.Unreachable;
             }
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/DocumentState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/DocumentState.cs
index 6b87063f9a3ff..5bdab8050746d 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/DocumentState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/DocumentState.cs
@@ -227,7 +227,7 @@ private static async Task<TreeAndVersion> IncrementallyParseTreeAsync(
                     return IncrementallyParse(newTextAndVersion, oldTreeAndVersion, cancellationToken);
                 }
             }
-            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
+            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken, ErrorSeverity.Critical))
             {
                 throw ExceptionUtilities.Unreachable;
             }
@@ -248,7 +248,7 @@ private static TreeAndVersion IncrementallyParseTree(
                     return IncrementallyParse(newTextAndVersion, oldTreeAndVersion, cancellationToken);
                 }
             }
-            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
+            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken, ErrorSeverity.Critical))
             {
                 throw ExceptionUtilities.Unreachable;
             }
@@ -735,8 +735,8 @@ private static void CheckTree(
             var oldTextContent = oldText?.ToString();
 
             // we time to time see (incremental) parsing bug where text <-> tree round tripping is broken.
-            // send NFW for those cases
-            FatalError.ReportAndCatch(new Exception($"tree and text has different length {newTree.Length} vs {newText.Length}"));
+            // send NFW for those cases, since we'll be in a very broken state at that point
+            FatalError.ReportAndCatch(new Exception($"tree and text has different length {newTree.Length} vs {newText.Length}"), ErrorSeverity.Critical);
 
             // this will make sure that these variables are not thrown away in the dump
             GC.KeepAlive(newTreeContent);
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/ProjectState_Checksum.cs b/src/Workspaces/Core/Portable/Workspace/Solution/ProjectState_Checksum.cs
index 99e41b0fa1ee3..5b26ef0ce4276 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/ProjectState_Checksum.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/ProjectState_Checksum.cs
@@ -79,7 +79,7 @@ private async Task<ProjectStateChecksums> ComputeChecksumsAsync(CancellationToke
                         analyzerConfigDocumentChecksumCollection: new ChecksumCollection(analyzerConfigDocumentChecksums));
                 }
             }
-            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
+            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken, ErrorSeverity.Critical))
             {
                 throw ExceptionUtilities.Unreachable;
             }
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs
index 6eafed98ca82b..96a1c855ccf22 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.cs
@@ -427,7 +427,7 @@ private async Task<Compilation> GetOrBuildDeclarationCompilationAsync(SolutionSe
                         return compilation;
                     }
                 }
-                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
+                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken, ErrorSeverity.Critical))
                 {
                     throw ExceptionUtilities.Unreachable;
                 }
@@ -470,7 +470,7 @@ private async Task<CompilationInfo> GetOrBuildCompilationInfoAsync(
                         }
                     }
                 }
-                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
+                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken, ErrorSeverity.Critical))
                 {
                     throw ExceptionUtilities.Unreachable;
                 }
@@ -545,7 +545,7 @@ private async Task<CompilationInfo> BuildCompilationInfoFromScratchAsync(
                         compilationWithStaleGeneratedTrees: null,
                         cancellationToken).ConfigureAwait(false);
                 }
-                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
+                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken, ErrorSeverity.Critical))
                 {
                     throw ExceptionUtilities.Unreachable;
                 }
@@ -575,7 +575,7 @@ private async Task<Compilation> BuildDeclarationCompilationFromScratchAsync(
                     WriteState(new AllSyntaxTreesParsedState(compilation, generatorInfo), solutionServices);
                     return compilation;
                 }
-                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
+                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken, ErrorSeverity.Critical))
                 {
                     throw ExceptionUtilities.Unreachable;
                 }
@@ -678,7 +678,7 @@ private async Task<CompilationInfo> BuildFinalStateFromInProgressStateAsync(
 
                     return (compilationWithoutGenerators, compilationWithGenerators, generatorDriver);
                 }
-                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
+                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken, ErrorSeverity.Critical))
                 {
                     throw ExceptionUtilities.Unreachable;
                 }
@@ -937,7 +937,7 @@ private async Task<CompilationInfo> FinalizeCompilationAsync(
                     await Task.Yield().ConfigureAwait(false);
                     throw;
                 }
-                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
+                catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken, ErrorSeverity.Critical))
                 {
                     throw ExceptionUtilities.Unreachable;
                 }
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.cs
index 73640d6a710dd..f3efc439083c0 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.cs
@@ -1701,7 +1701,7 @@ public SolutionState WithFrozenPartialCompilationIncludingSpecificDocument(Docum
                     return currentPartialSolution;
                 }
             }
-            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
+            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken, ErrorSeverity.Critical))
             {
                 throw ExceptionUtilities.Unreachable;
             }
@@ -1881,7 +1881,7 @@ public SolutionState WithFrozenSourceGeneratedDocument(SourceGeneratedDocumentId
                 var tracker = this.GetCompilationTracker(projectReference.ProjectId);
                 return GetMetadataReferenceAsync(tracker, fromProject, projectReference, cancellationToken);
             }
-            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
+            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken, ErrorSeverity.Critical))
             {
                 throw ExceptionUtilities.Unreachable;
             }
@@ -1915,7 +1915,7 @@ public SolutionState WithFrozenSourceGeneratedDocument(SourceGeneratedDocumentId
                         tracker, this, properties, cancellationToken).ConfigureAwait(false);
                 }
             }
-            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
+            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken, ErrorSeverity.Critical))
             {
                 throw ExceptionUtilities.Unreachable;
             }
diff --git a/src/Workspaces/Core/Portable/Workspace/Workspace_Editor.cs b/src/Workspaces/Core/Portable/Workspace/Workspace_Editor.cs
index 3d8edc63df431..3933a55127b98 100644
--- a/src/Workspaces/Core/Portable/Workspace/Workspace_Editor.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Workspace_Editor.cs
@@ -612,7 +612,7 @@ protected internal void OnDocumentClosed(DocumentId documentId, TextLoader reloa
                     this.RaiseDocumentClosedEventAsync(newDoc); // don't wait for this
                 }
             }
-            catch (Exception e) when (FatalError.ReportAndPropagate(e))
+            catch (Exception e) when (FatalError.ReportAndPropagate(e, ErrorSeverity.General))
             {
                 throw ExceptionUtilities.Unreachable;
             }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ITypeSymbolExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ITypeSymbolExtensions.cs
index 6ce0a108884b6..5968c168f302b 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ITypeSymbolExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ITypeSymbolExtensions.cs
@@ -140,7 +140,7 @@ public static bool ContainingTypesOrSelfHasUnsafeKeyword(this ITypeSymbol contai
 
                 return null;
             }
-            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
+            catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken, ErrorSeverity.General))
             {
                 throw ExceptionUtilities.Unreachable;
             }

From 409f385d91bfa4da85da8a3f707a87f1764f1cc0 Mon Sep 17 00:00:00 2001
From: Jason Malinowski <jason.malinowski@microsoft.com>
Date: Wed, 15 Dec 2021 17:14:13 -0800
Subject: [PATCH 216/444] Tweak how the compiler is catching exceptions

When I started down the path of unifying our fatal/non-fatal handlers,
we didn't believe there was anywhere the compiler was catching
exceptions while reporting them, because in the command line compiler
case that would simply be equivalent to catching and silently swallowing
the issue. Upon further investigation, there were a handful of places
where the compiler was doing exactly that! Worse off, those are places
where if an exception is thrown we'd return invalid nulls from some APIs
which probably would make the caller crash.

We agreed that we need to remove those catches -- some of them seem
to be in service of our IOperation APIs, which at some point must have
been fairly unstable and we didn't want that causing stability issues.
But by now, any issues should be worked out, and if they're not they're
causing analyzers to not analyze code which may be a problem. However,
since we don't know if there's surprises lurking, we're going to keep
the existing behavior for now and then remove those try/catches at
the start of the 17.2 cycle where we'll have sufficient time to react.

This commit does the following then:

1. Makes all the ReportAndCatch* APIs private if we're compiling at
   the compiler layer, to prevent any future use of them.
2. Adds an [Obsolete] API for the current behavior under a new name.
3. Moves the callers over to it.

Once 17.2 cycle starts we will:

1. Delete these new APIs.
2. Clean up the scoping around ReportAndCatch to simply
   #if !COMPILERCORE around the whole thing.
3. Remove the flag added that's set by the IDE.

At that point, the command line compiler has no way to catch and report
non-fatal errors that wouldn't be fatal if it's the command line
compiler. If we decide we need that, we can change this.
---
 .../Portable/Compilation/SemanticModel.cs     |   4 +-
 .../DiagnosticAnalyzer/AnalyzerDriver.cs      |   4 +-
 .../DiagnosticAnalyzer/AnalyzerExecutor.cs    |   4 +-
 .../Portable/InternalUtilities/FatalError.cs  | 158 ++++++++++++++----
 .../Portable/Operations/ControlFlowGraph.cs   |   4 +-
 .../SourceGeneration/GeneratorDriver.cs       |   4 +-
 .../Portable/SourceGeneration/UserFunction.cs |  12 +-
 .../Implementation/Watson/FaultReporter.cs    |   1 +
 8 files changed, 149 insertions(+), 42 deletions(-)

diff --git a/src/Compilers/Core/Portable/Compilation/SemanticModel.cs b/src/Compilers/Core/Portable/Compilation/SemanticModel.cs
index bcf4486ee99a3..b5363bf7d9b00 100644
--- a/src/Compilers/Core/Portable/Compilation/SemanticModel.cs
+++ b/src/Compilers/Core/Portable/Compilation/SemanticModel.cs
@@ -79,7 +79,9 @@ public SyntaxTree SyntaxTree
             {
                 return GetOperationCore(node, cancellationToken);
             }
-            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, cancellationToken))
+#pragma warning disable CS0618 // ReportIfNonFatalAndCatchUnlessCanceled is obsolete; tracked by https://github.com/dotnet/roslyn/issues/58375
+            catch (Exception e) when (FatalError.ReportIfNonFatalAndCatchUnlessCanceled(e, cancellationToken))
+#pragma warning restore CS0618 // ReportIfNonFatalAndCatchUnlessCanceled is obsolete
             {
                 // Log a Non-fatal-watson and then ignore the crash in the attempt of getting operation
                 Debug.Assert(false, "\n" + e.ToString());
diff --git a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerDriver.cs b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerDriver.cs
index c97d562f4aadd..cb89b1d2ac3a1 100644
--- a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerDriver.cs
+++ b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerDriver.cs
@@ -2697,7 +2697,9 @@ ImmutableArray<IOperation> getOperationsToAnalyzeWithStackGuard(ImmutableArray<I
                 {
                     return GetOperationsToAnalyze(operationBlocksToAnalyze);
                 }
-                catch (Exception ex) when (ex is InsufficientExecutionStackException || FatalError.ReportAndCatchUnlessCanceled(ex, cancellationToken))
+#pragma warning disable CS0618 // ReportIfNonFatalAndCatchUnlessCanceled is obsolete; tracked by https://github.com/dotnet/roslyn/issues/58375
+                catch (Exception ex) when (ex is InsufficientExecutionStackException || FatalError.ReportIfNonFatalAndCatchUnlessCanceled(ex, cancellationToken))
+#pragma warning restore CS0618 // ReportIfNonFatalAndCatchUnlessCanceled is obsolete
                 {
                     // the exception filter will short-circuit if `ex` is `InsufficientExecutionStackException` (from OperationWalker)
                     // and no non-fatal-watson will be logged as a result.
diff --git a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerExecutor.cs b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerExecutor.cs
index f81406ca15ad1..b14db2b1619d0 100644
--- a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerExecutor.cs
+++ b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerExecutor.cs
@@ -1657,7 +1657,9 @@ private static string CreateDisablingMessage(DiagnosticAnalyzer analyzer)
                     diagnosticIds = diagnosticIds.Add(diagnostic.Id);
                 }
             }
-            catch (Exception e) when (FatalError.ReportAndCatch(e))
+#pragma warning disable CS0618 // ReportIfNonFatalAndCatchUnlessCanceled is obsolete; tracked by https://github.com/dotnet/roslyn/issues/58375
+            catch (Exception e) when (FatalError.ReportIfNonFatalAndCatchUnlessCanceled(e))
+#pragma warning restore CS0618 // ReportIfNonFatalAndCatchUnlessCanceled is obsolete
             {
                 // Intentionally empty
             }
diff --git a/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs b/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs
index 985e5fc95836b..6007023687490 100644
--- a/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs
+++ b/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs
@@ -46,9 +46,13 @@ public static ErrorReporterHandler? Handler
             }
         }
 
-        // Same as setting the Handler property except that it avoids the assert.  This is useful in 
-        // test code which needs to verify the handler is called in specific cases and will continually
-        // overwrite this value.
+        public static bool HandlerIsNonFatal { get; set; }
+
+        /// <summary>
+        /// Same as setting the Handler property except that it avoids the assert.  This is useful in
+        /// test code which needs to verify the handler is called in specific cases and will continually
+        /// overwrite this value.
+        /// </summary>
         public static void OverwriteHandler(ErrorReporterHandler? value)
         {
             s_handler = value;
@@ -64,7 +68,8 @@ public static void OverwriteHandler(ErrorReporterHandler? value)
         /// </summary>
         /// <remarks>
         /// This file is in linked into multiple layers, but we want to ensure that all layers have the same copy.
-        /// This lets us copy the handler in this instance into the same in another instance.</remarks>
+        /// This lets us copy the handler in this instance into the same in another instance.
+        /// </remarks>
         public static void CopyHandlerTo(Assembly assembly)
         {
             var targetType = assembly.GetType(typeof(FatalError).FullName!, throwOnError: true)!;
@@ -79,6 +84,9 @@ public static void CopyHandlerTo(Assembly assembly)
             {
                 targetHandlerProperty.SetValue(obj: null, value: null);
             }
+
+            var targetIsNonFatalProperty = targetType.GetProperty(nameof(HandlerIsNonFatal), BindingFlags.Static | BindingFlags.Public)!;
+            targetIsNonFatalProperty.SetValue(obj: null, value: HandlerIsNonFatal);
         }
 
 #endif
@@ -86,6 +94,18 @@ public static void CopyHandlerTo(Assembly assembly)
         private static bool IsCurrentOperationBeingCancelled(Exception exception, CancellationToken cancellationToken)
             => exception is OperationCanceledException && cancellationToken.IsCancellationRequested;
 
+        /// <summary>
+        /// Use in an exception filter to report an error without catching the exception.
+        /// The error is reported by calling <see cref="Handler"/>.
+        /// </summary>
+        /// <returns><see langword="false"/> to avoid catching the exception.</returns>
+        [DebuggerHidden]
+        public static bool ReportAndPropagate(Exception exception, ErrorSeverity severity = ErrorSeverity.Uncategorized)
+        {
+            Report(exception, severity);
+            return false;
+        }
+
         /// <summary>
         /// Use in an exception filter to report an error (by calling <see cref="Handler"/>), unless the
         /// operation has been cancelled. The exception is never caught.
@@ -131,6 +151,40 @@ public static bool ReportAndPropagateUnlessCanceled(Exception exception, Cancell
             return ReportAndPropagate(exception, severity);
         }
 
+        /// <summary>
+        /// Report an error.
+        /// Calls <see cref="Handler"/> and doesn't pass the exception through (the method returns true).
+        /// This is generally expected to be used within an exception filter as that allows us to
+        /// capture data at the point the exception is thrown rather than when it is handled.
+        /// However, it can also be used outside of an exception filter. If the exception has not
+        /// already been thrown the method will throw and catch it itself to ensure we get a useful
+        /// stack trace.
+        /// </summary>
+        /// <returns>True to catch the exception.</returns>
+        [DebuggerHidden]
+#if COMPILERCORE
+        private
+#else
+        public
+#endif
+            static bool ReportAndCatch(Exception exception, ErrorSeverity severity = ErrorSeverity.Uncategorized)
+        {
+            Report(exception, severity);
+            return true;
+        }
+
+        [DebuggerHidden]
+#if COMPILERCORE
+        private
+#else
+        public
+#endif
+            static bool ReportWithDumpAndCatch(Exception exception, ErrorSeverity severity = ErrorSeverity.Uncategorized)
+        {
+            Report(exception, severity, forceDump: true);
+            return true;
+        }
+
         /// <summary>
         /// Use in an exception filter to report an error (by calling <see cref="Handler"/>) and catch
         /// the exception, unless the operation was cancelled.
@@ -138,7 +192,12 @@ public static bool ReportAndPropagateUnlessCanceled(Exception exception, Cancell
         /// <returns><see langword="true"/> to catch the exception if the error was reported; otherwise,
         /// <see langword="false"/> to propagate the exception if the operation was cancelled.</returns>
         [DebuggerHidden]
-        public static bool ReportAndCatchUnlessCanceled(Exception exception, ErrorSeverity severity = ErrorSeverity.Uncategorized)
+#if COMPILERCORE
+        private
+#else
+        public
+#endif
+            static bool ReportAndCatchUnlessCanceled(Exception exception, ErrorSeverity severity = ErrorSeverity.Uncategorized)
         {
             if (exception is OperationCanceledException)
             {
@@ -148,6 +207,30 @@ public static bool ReportAndCatchUnlessCanceled(Exception exception, ErrorSeveri
             return ReportAndCatch(exception, severity);
         }
 
+        /// <summary>
+        /// Use in an exception filter to report an error (by calling <see cref="Handler"/>) and catch
+        /// the exception, unless the operation was cancelled.
+        /// </summary>
+        /// <returns><see langword="true"/> to catch the exception if the error was reported; otherwise,
+        /// <see langword="false"/> to propagate the exception if the operation was cancelled.</returns>
+        // This is only a temporary shim; the removal is tracked by https://github.com/dotnet/roslyn/issues/58375.
+        [DebuggerHidden]
+        [Obsolete("This is only to support places the compiler is catching exceptions on the command line; do not use in new code.")]
+        public static bool ReportIfNonFatalAndCatchUnlessCanceled(Exception exception, ErrorSeverity severity = ErrorSeverity.Uncategorized)
+        {
+            if (exception is OperationCanceledException)
+            {
+                return false;
+            }
+
+            if (!HandlerIsNonFatal)
+            {
+                return true;
+            }
+
+            return ReportAndCatch(exception, severity);
+        }
+
         /// <summary>
         /// <para>Use in an exception filter to report an error (by calling <see cref="Handler"/>) and
         /// catch the exception, unless the operation was cancelled at the request of
@@ -168,7 +251,12 @@ public static bool ReportAndCatchUnlessCanceled(Exception exception, ErrorSeveri
         /// <returns><see langword="true"/> to catch the exception if the error was reported; otherwise,
         /// <see langword="false"/> to propagate the exception if the operation was cancelled.</returns>
         [DebuggerHidden]
-        public static bool ReportAndCatchUnlessCanceled(Exception exception, CancellationToken contextCancellationToken, ErrorSeverity severity = ErrorSeverity.Uncategorized)
+#if COMPILERCORE
+        private
+#else
+        public
+#endif
+            static bool ReportAndCatchUnlessCanceled(Exception exception, CancellationToken contextCancellationToken, ErrorSeverity severity = ErrorSeverity.Uncategorized)
         {
             if (IsCurrentOperationBeingCancelled(exception, contextCancellationToken))
             {
@@ -179,39 +267,41 @@ public static bool ReportAndCatchUnlessCanceled(Exception exception, Cancellatio
         }
 
         /// <summary>
-        /// Use in an exception filter to report an error without catching the exception.
-        /// The error is reported by calling <see cref="Handler"/>.
+        /// <para>Use in an exception filter to report an error (by calling <see cref="Handler"/>) and
+        /// catch the exception, unless the operation was cancelled at the request of
+        /// <paramref name="contextCancellationToken"/>.</para>
+        ///
+        /// <para>Cancellable operations are only expected to throw <see cref="OperationCanceledException"/> if the
+        /// applicable <paramref name="contextCancellationToken"/> indicates cancellation is requested by setting
+        /// <see cref="CancellationToken.IsCancellationRequested"/>. Unexpected cancellation, i.e. an
+        /// <see cref="OperationCanceledException"/> which occurs without <paramref name="contextCancellationToken"/>
+        /// requesting cancellation, is treated as an error by this method.</para>
+        ///
+        /// <para>This method does not require <see cref="OperationCanceledException.CancellationToken"/> to match
+        /// <paramref name="contextCancellationToken"/>, provided cancellation is expected per the previous
+        /// paragraph.</para>
         /// </summary>
-        /// <returns><see langword="false"/> to avoid catching the exception.</returns>
+        /// <param name="contextCancellationToken">A <see cref="CancellationToken"/> which will have
+        /// <see cref="CancellationToken.IsCancellationRequested"/> set if cancellation is expected.</param>
+        /// <returns><see langword="true"/> to catch the exception if the error was reported; otherwise,
+        /// <see langword="false"/> to propagate the exception if the operation was cancelled.</returns>
+        // This is only a temporary shim; the removal is tracked by https://github.com/dotnet/roslyn/issues/58375.
         [DebuggerHidden]
-        public static bool ReportAndPropagate(Exception exception, ErrorSeverity severity = ErrorSeverity.Uncategorized)
+        [Obsolete("This is only to support places the compiler is catching and swallowing exceptions on the command line; do not use in new code.")]
+        public static bool ReportIfNonFatalAndCatchUnlessCanceled(Exception exception, CancellationToken contextCancellationToken, ErrorSeverity severity = ErrorSeverity.Uncategorized)
         {
-            Report(exception, severity);
-            return false;
-        }
+            if (IsCurrentOperationBeingCancelled(exception, contextCancellationToken))
+            {
+                return false;
+            }
 
-        /// <summary>
-        /// Report an error.
-        /// Calls <see cref="Handler"/> and doesn't pass the exception through (the method returns true).
-        /// This is generally expected to be used within an exception filter as that allows us to
-        /// capture data at the point the exception is thrown rather than when it is handled.
-        /// However, it can also be used outside of an exception filter. If the exception has not
-        /// already been thrown the method will throw and catch it itself to ensure we get a useful
-        /// stack trace.
-        /// </summary>
-        /// <returns>True to catch the exception.</returns>
-        [DebuggerHidden]
-        public static bool ReportAndCatch(Exception exception, ErrorSeverity severity = ErrorSeverity.Uncategorized)
-        {
-            Report(exception, severity);
-            return true;
-        }
+            if (!HandlerIsNonFatal)
+            {
+                // We'll catch the exception, but we won't report anything.
+                return true;
+            }
 
-        [DebuggerHidden]
-        public static bool ReportWithDumpAndCatch(Exception exception, ErrorSeverity severity = ErrorSeverity.Uncategorized)
-        {
-            Report(exception, severity, forceDump: true);
-            return true;
+            return ReportAndCatch(exception, severity);
         }
 
         private static readonly object s_reportedMarker = new();
diff --git a/src/Compilers/Core/Portable/Operations/ControlFlowGraph.cs b/src/Compilers/Core/Portable/Operations/ControlFlowGraph.cs
index 3f971aea1c98a..0401307413e92 100644
--- a/src/Compilers/Core/Portable/Operations/ControlFlowGraph.cs
+++ b/src/Compilers/Core/Portable/Operations/ControlFlowGraph.cs
@@ -184,7 +184,9 @@ internal static ControlFlowGraph CreateCore(IOperation operation, string argumen
                 Debug.Assert(controlFlowGraph.OriginalOperation == operation);
                 return controlFlowGraph;
             }
-            catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, cancellationToken))
+#pragma warning disable CS0618 // ReportIfNonFatalAndCatchUnlessCanceled is obsolete; tracked by https://github.com/dotnet/roslyn/issues/58375
+            catch (Exception e) when (FatalError.ReportIfNonFatalAndCatchUnlessCanceled(e, cancellationToken))
+#pragma warning restore CS0618 // ReportIfNonFatalAndCatchUnlessCanceled is obsolete
             {
                 // Log a Non-fatal-watson and then ignore the crash in the attempt of getting flow graph.
                 Debug.Assert(false, "\n" + e.ToString());
diff --git a/src/Compilers/Core/Portable/SourceGeneration/GeneratorDriver.cs b/src/Compilers/Core/Portable/SourceGeneration/GeneratorDriver.cs
index 4cdd7d502ad4b..d4d845a7c20eb 100644
--- a/src/Compilers/Core/Portable/SourceGeneration/GeneratorDriver.cs
+++ b/src/Compilers/Core/Portable/SourceGeneration/GeneratorDriver.cs
@@ -193,7 +193,9 @@ internal GeneratorDriverState RunGeneratorsCore(Compilation compilation, Diagnos
                     {
                         generator.Initialize(pipelineContext);
                     }
-                    catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, cancellationToken))
+#pragma warning disable CS0618 // ReportIfNonFatalAndCatchUnlessCanceled is obsolete; tracked by https://github.com/dotnet/roslyn/issues/58375
+                    catch (Exception e) when (FatalError.ReportIfNonFatalAndCatchUnlessCanceled(e, cancellationToken))
+#pragma warning restore CS0618 // ReportIfNonFatalAndCatchUnlessCanceled is obsolete
                     {
                         ex = e;
                     }
diff --git a/src/Compilers/Core/Portable/SourceGeneration/UserFunction.cs b/src/Compilers/Core/Portable/SourceGeneration/UserFunction.cs
index 7aaeafd0000ef..f38b4cc2864b2 100644
--- a/src/Compilers/Core/Portable/SourceGeneration/UserFunction.cs
+++ b/src/Compilers/Core/Portable/SourceGeneration/UserFunction.cs
@@ -30,7 +30,9 @@ internal static Func<TInput, CancellationToken, TOutput> WrapUserFunction<TInput
                 {
                     return userFunction(input, token);
                 }
-                catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, token))
+#pragma warning disable CS0618 // ReportIfNonFatalAndCatchUnlessCanceled is obsolete; tracked by https://github.com/dotnet/roslyn/issues/58375
+                catch (Exception e) when (FatalError.ReportIfNonFatalAndCatchUnlessCanceled(e, token))
+#pragma warning restore CS0618 // ReportIfNonFatalAndCatchUnlessCanceled is obsolete
                 {
                     throw new UserFunctionException(e);
                 }
@@ -50,7 +52,9 @@ internal static Action<TInput> WrapUserAction<TInput>(this Action<TInput> userAc
                 {
                     userAction(input);
                 }
-                catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e))
+#pragma warning disable CS0618 // ReportIfNonFatalAndCatchUnlessCanceled is obsolete; tracked by https://github.com/dotnet/roslyn/issues/58375
+                catch (Exception e) when (FatalError.ReportIfNonFatalAndCatchUnlessCanceled(e))
+#pragma warning restore CS0618 // ReportIfNonFatalAndCatchUnlessCanceled is obsolete
                 {
                     throw new UserFunctionException(e);
                 }
@@ -65,7 +69,9 @@ internal static Action<TInput1, TInput2> WrapUserAction<TInput1, TInput2>(this A
                 {
                     userAction(input1, input2);
                 }
-                catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e))
+#pragma warning disable CS0618 // ReportIfNonFatalAndCatchUnlessCanceled is obsolete; tracked by https://github.com/dotnet/roslyn/issues/58375
+                catch (Exception e) when (FatalError.ReportIfNonFatalAndCatchUnlessCanceled(e))
+#pragma warning restore CS0618 // ReportIfNonFatalAndCatchUnlessCanceled is obsolete
                 {
                     throw new UserFunctionException(e);
                 }
diff --git a/src/VisualStudio/Core/Def/Implementation/Watson/FaultReporter.cs b/src/VisualStudio/Core/Def/Implementation/Watson/FaultReporter.cs
index f97465ff8274a..8477fbd5f7556 100644
--- a/src/VisualStudio/Core/Def/Implementation/Watson/FaultReporter.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Watson/FaultReporter.cs
@@ -29,6 +29,7 @@ internal static class FaultReporter
         public static void InitializeFatalErrorHandlers()
         {
             FatalError.Handler = static (exception, severity, forceDump) => ReportFault(exception, ConvertSeverity(severity), forceDump);
+            FatalError.HandlerIsNonFatal = true;
             FatalError.CopyHandlerTo(typeof(Compilation).Assembly);
         }
 

From a8bf84c5fbd787d27c54ec7cdfb0d2f7daee7e2b Mon Sep 17 00:00:00 2001
From: Jason Malinowski <jason.malinowski@microsoft.com>
Date: Wed, 15 Dec 2021 18:23:31 -0800
Subject: [PATCH 217/444] Move a class only used in integration tests to where
 it's called

No reason it can't just be with the other integration-test-only fault
handlers.
---
 .../TestSetup/IntegrationTestServiceCommands.cs               | 2 +-
 .../Microsoft.VisualStudio.IntegrationTest.Setup.csproj       | 3 ---
 .../TestSetup/TestTraceListener.cs}                           | 4 ++--
 3 files changed, 3 insertions(+), 6 deletions(-)
 rename src/VisualStudio/{Core/Def/Implementation/Watson/WatsonTraceListener.cs => IntegrationTest/TestSetup/TestTraceListener.cs} (95%)

diff --git a/src/VisualStudio/IntegrationTest/TestSetup/IntegrationTestServiceCommands.cs b/src/VisualStudio/IntegrationTest/TestSetup/IntegrationTestServiceCommands.cs
index 9a472ccfbc420..ca2f91d3d07b2 100644
--- a/src/VisualStudio/IntegrationTest/TestSetup/IntegrationTestServiceCommands.cs
+++ b/src/VisualStudio/IntegrationTest/TestSetup/IntegrationTestServiceCommands.cs
@@ -102,7 +102,7 @@ private void StartServiceCallback(object sender, EventArgs e)
             {
                 AppDomain.CurrentDomain.AssemblyResolve += CurrentDomainAssemblyResolve;
 
-                WatsonTraceListener.Install();
+                TestTraceListener.Install();
 
                 _service = new IntegrationService();
 
diff --git a/src/VisualStudio/IntegrationTest/TestSetup/Microsoft.VisualStudio.IntegrationTest.Setup.csproj b/src/VisualStudio/IntegrationTest/TestSetup/Microsoft.VisualStudio.IntegrationTest.Setup.csproj
index 829029222b816..66ea327988a75 100644
--- a/src/VisualStudio/IntegrationTest/TestSetup/Microsoft.VisualStudio.IntegrationTest.Setup.csproj
+++ b/src/VisualStudio/IntegrationTest/TestSetup/Microsoft.VisualStudio.IntegrationTest.Setup.csproj
@@ -14,9 +14,6 @@
     <IncludeDebugSymbolsInVSIXContainer>false</IncludeDebugSymbolsInVSIXContainer>
     <IncludeDebugSymbolsInLocalVSIXDeployment>true</IncludeDebugSymbolsInLocalVSIXDeployment>
   </PropertyGroup>
-  <ItemGroup>
-    <Compile Include="..\..\Core\Def\Implementation\Watson\WatsonTraceListener.cs" Link="WatsonTraceListener.cs" />
-  </ItemGroup>
   <ItemGroup Label="PkgDef">
     <PkgDefPackageRegistration Include="{d02dac01-ddd0-4ecc-8687-79a554852b14}"
                                Name="IntegrationTestServicePackage"
diff --git a/src/VisualStudio/Core/Def/Implementation/Watson/WatsonTraceListener.cs b/src/VisualStudio/IntegrationTest/TestSetup/TestTraceListener.cs
similarity index 95%
rename from src/VisualStudio/Core/Def/Implementation/Watson/WatsonTraceListener.cs
rename to src/VisualStudio/IntegrationTest/TestSetup/TestTraceListener.cs
index e52572acf958d..22f0f2318e656 100644
--- a/src/VisualStudio/Core/Def/Implementation/Watson/WatsonTraceListener.cs
+++ b/src/VisualStudio/IntegrationTest/TestSetup/TestTraceListener.cs
@@ -7,7 +7,7 @@
 
 namespace Microsoft.CodeAnalysis.ErrorReporting
 {
-    internal class WatsonTraceListener : TraceListener
+    internal class TestTraceListener : TraceListener
     {
         public override void Fail(string? message, string? detailMessage)
         {
@@ -97,7 +97,7 @@ private static void Exit(string? message)
         internal static void Install()
         {
             Trace.Listeners.Clear();
-            Trace.Listeners.Add(new WatsonTraceListener());
+            Trace.Listeners.Add(new TestTraceListener());
         }
     }
 }

From a7400921ebfa60de0a04f93e16de918011bd936c Mon Sep 17 00:00:00 2001
From: Jason Malinowski <jason.malinowski@microsoft.com>
Date: Wed, 15 Dec 2021 18:23:57 -0800
Subject: [PATCH 218/444] Delete unused enum

---
 .../Core/Def/Implementation/Watson/FaultReporter.cs | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/Watson/FaultReporter.cs b/src/VisualStudio/Core/Def/Implementation/Watson/FaultReporter.cs
index 8477fbd5f7556..4fb705285bb7b 100644
--- a/src/VisualStudio/Core/Def/Implementation/Watson/FaultReporter.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Watson/FaultReporter.cs
@@ -253,17 +253,4 @@ private static void CaptureFilesInMemory(IEnumerable<string> paths)
             }
         }
     }
-
-    internal enum WatsonSeverity
-    {
-        /// <summary>
-        /// Indicate that this watson is informative and not urgent
-        /// </summary>
-        Default,
-
-        /// <summary>
-        /// Indicate that this watson is critical and need to be addressed soon
-        /// </summary>
-        Critical,
-    }
 }

From e1054c3263df08971e81ef72d2ec7c4ff3442147 Mon Sep 17 00:00:00 2001
From: Jason Malinowski <jason.malinowski@microsoft.com>
Date: Wed, 15 Dec 2021 18:28:16 -0800
Subject: [PATCH 219/444] Delete all the code that's setting custom bucket
 parameters

There's a few things this piece of code is trying to do:

1. If we have an aggregate exception, try to update the bucket
   parameters to represent the stuff inside. Rather than doing that
   it's much easier to just do a report for each inner exception, which
   will not interfere with other targeted notification policies.
2. If we have a remote exception, try to bucket on some other
   information. What I don't get is the information there is the stack
   trace (which is the client stack trace) and the message which we'd
   already include anyways -- nothing there is any more actionable
   than just falling into the default error reporting logic.
3. Trying to report inner exceptions over the outer exception if
   ever one exists. I can't say that's a great idea unless we actually
   know the type of exception more directly.

Just deleting this all seems much easier.
---
 .../CSharp/Test/Watson/WatsonTests.cs         | 209 ------------------
 .../Implementation/Watson/FaultReporter.cs    |  16 +-
 .../Implementation/Watson/WatsonExtensions.cs |  92 +-------
 3 files changed, 12 insertions(+), 305 deletions(-)
 delete mode 100644 src/VisualStudio/CSharp/Test/Watson/WatsonTests.cs

diff --git a/src/VisualStudio/CSharp/Test/Watson/WatsonTests.cs b/src/VisualStudio/CSharp/Test/Watson/WatsonTests.cs
deleted file mode 100644
index 64eb069ac4926..0000000000000
--- a/src/VisualStudio/CSharp/Test/Watson/WatsonTests.cs
+++ /dev/null
@@ -1,209 +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.
-
-#nullable disable
-
-using System;
-using System.Collections.Generic;
-using Microsoft.CodeAnalysis.ErrorReporting;
-using Microsoft.VisualStudio.Telemetry;
-using StreamJsonRpc;
-using Xunit;
-
-namespace Roslyn.VisualStudio.CSharp.UnitTests.Watson
-{
-    public class WatsonTests
-    {
-        [Fact]
-        public void TestRegularException()
-        {
-            try
-            {
-                // throw one
-                throw new Exception("test");
-            }
-            catch (Exception exception)
-            {
-                var mockFault = new MockFault();
-                mockFault.SetExtraParameters(exception, emptyCallstack: false);
-
-                // there should be no extra bucket info
-                // for regular exception
-                Assert.False(mockFault.Map.ContainsKey(7));
-            }
-        }
-
-        [Fact]
-        public void TestRegularWithInnerexception()
-        {
-            try
-            {
-                try
-                {
-                    // throw one
-                    throw new Exception("inner");
-                }
-                catch (Exception inner)
-                {
-                    throw new Exception("outter", inner);
-                }
-            }
-            catch (Exception exception)
-            {
-                var mockFault = new MockFault();
-                mockFault.SetExtraParameters(exception, emptyCallstack: false);
-
-                Assert.Equal(exception.InnerException.GetParameterString(), mockFault.Map[7]);
-            }
-        }
-
-        [Fact]
-        public void TestRemoteInvocationException()
-        {
-            var mockFault = new MockFault();
-
-            var exception = new RemoteInvocationException("test", errorCode: 100, "remoteErrorData");
-            mockFault.SetExtraParameters(exception, emptyCallstack: false);
-
-            Assert.Equal(exception.GetParameterString(), mockFault.Map[7]);
-        }
-
-        [Fact]
-        public void TestRemoteInvocationExceptionNull()
-        {
-            var mockFault = new MockFault();
-
-            var exception = new RemoteInvocationException(message: null, errorCode: -1, errorData: null);
-            mockFault.SetExtraParameters(exception, emptyCallstack: false);
-
-            Assert.Equal(exception.GetParameterString(), mockFault.Map[7]);
-        }
-
-        [Fact]
-        public void TestAggregateException()
-        {
-            try
-            {
-                // throw one
-                throw new AggregateException("no inner");
-            }
-            catch (Exception exception)
-            {
-                var mockFault = new MockFault();
-                mockFault.SetExtraParameters(exception, emptyCallstack: false);
-
-                // there should be no extra bucket info
-                // for regular exception
-                Assert.False(mockFault.Map.ContainsKey(7));
-            }
-        }
-
-        [Fact]
-        public void TestAggregateWithInnerexception()
-        {
-            try
-            {
-                try
-                {
-                    // throw one
-                    throw new Exception("inner");
-                }
-                catch (Exception inner)
-                {
-                    throw new AggregateException(inner);
-                }
-            }
-            catch (Exception exception)
-            {
-                var mockFault = new MockFault();
-                mockFault.SetExtraParameters(exception, emptyCallstack: false);
-
-                Assert.Equal(exception.GetParameterString(), mockFault.Map[7]);
-            }
-        }
-
-        [Fact]
-        public void TestAggregateWithMultipleInnerexceptions()
-        {
-            try
-            {
-                var inners = new List<Exception>();
-
-                try
-                {
-                    // throw one
-                    throw new Exception("inner1");
-                }
-                catch (Exception inner)
-                {
-                    inners.Add(inner);
-                }
-
-                try
-                {
-                    // throw one
-                    throw new Exception("inner2");
-                }
-                catch (Exception inner)
-                {
-                    inners.Add(inner);
-                }
-
-                throw new AggregateException(inners);
-            }
-            catch (AggregateException exception)
-            {
-                var mockFault = new MockFault();
-                mockFault.SetExtraParameters(exception, emptyCallstack: false);
-
-                var flatten = exception.Flatten();
-                Assert.Equal(flatten.CalculateHash(), mockFault.Map[6]);
-                Assert.Equal(flatten.InnerException.GetParameterString(), mockFault.Map[7]);
-            }
-        }
-
-        [Fact]
-        public void TestEmptyCallstack()
-        {
-            var mockFault = new MockFault();
-
-            var exception = new Exception("not thrown");
-            mockFault.SetExtraParameters(exception, emptyCallstack: true);
-
-            Assert.NotNull(mockFault.Map[3]);
-        }
-
-        public class MockFault : IFaultUtility
-        {
-            public readonly Dictionary<int, string> Map = new Dictionary<int, string>();
-
-            public void SetBucketParameter(int bucketNumber, string value)
-            {
-                Map.Add(bucketNumber, value);
-            }
-
-            #region not used
-            public void AddErrorInformation(string information)
-            {
-                throw new NotImplementedException();
-            }
-
-            public void AddFile(string fullpathname)
-            {
-                throw new NotImplementedException();
-            }
-
-            public void AddProcessDump(int pid)
-            {
-                throw new NotImplementedException();
-            }
-
-            public string GetBucketParameter(int bucketNumber)
-            {
-                throw new NotImplementedException();
-            }
-            #endregion
-        }
-    }
-}
diff --git a/src/VisualStudio/Core/Def/Implementation/Watson/FaultReporter.cs b/src/VisualStudio/Core/Def/Implementation/Watson/FaultReporter.cs
index 4fb705285bb7b..48f120b37326a 100644
--- a/src/VisualStudio/Core/Def/Implementation/Watson/FaultReporter.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Watson/FaultReporter.cs
@@ -87,7 +87,16 @@ public static void ReportFault(Exception exception, FaultSeverity severity, bool
         {
             try
             {
-                var emptyCallstack = exception.SetCallstackIfEmpty();
+                if (exception is AggregateException aggregateException)
+                {
+                    // We (potentially) have multiple exceptions; let's just report each of them
+                    foreach (var innerException in aggregateException.Flatten().InnerExceptions)
+                        ReportFault(innerException, severity, forceDump);
+
+                    return;
+                }
+
+                exception.SetCallstackIfEmpty();
                 var currentProcess = Process.GetCurrentProcess();
 
                 // write the exception to a log file:
@@ -127,11 +136,6 @@ public static void ReportFault(Exception exception, FaultSeverity severity, bool
                         return 0;
                     });
 
-                // add extra bucket parameters to bucket better in NFW
-                // we do it here so that it gets bucketted better in both
-                // watson and telemetry. 
-                faultEvent.SetExtraParameters(exception, emptyCallstack);
-
                 foreach (var session in s_telemetrySessions)
                 {
                     session.PostEvent(faultEvent);
diff --git a/src/VisualStudio/Core/Def/Implementation/Watson/WatsonExtensions.cs b/src/VisualStudio/Core/Def/Implementation/Watson/WatsonExtensions.cs
index 84fdcfab24047..49f9ed62e04ed 100644
--- a/src/VisualStudio/Core/Def/Implementation/Watson/WatsonExtensions.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Watson/WatsonExtensions.cs
@@ -2,99 +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.
 
-#nullable disable
-
 using System;
-using Microsoft.VisualStudio.Telemetry;
-using Roslyn.Utilities;
-using StreamJsonRpc;
 
 namespace Microsoft.CodeAnalysis.ErrorReporting
 {
     internal static class WatsonExtensions
     {
-        // NFW API let caller to customize watson report to make them better bucketed by
-        // putting custom string in reserved slots. normally those 3 slots will be empty.
-        private const int Reserved1 = 7;
-        private const int Reserved2 = 6;
-
-        // replace exception slot for callstack since the exception (with empty callstack) 
-        // given is synthesized one that doesn't provide any meaningful data
-        private const int Reserved3 = 3;
-
-        /// <summary>
-        /// This sets extra watson bucket parameters to make bucketting better
-        /// in non fatal watson report
-        /// </summary>
-        public static void SetExtraParameters(this IFaultUtility fault, Exception exception, bool emptyCallstack)
-        {
-            if (emptyCallstack)
-            {
-                // if exception we got started with empty callstack, put hash of runtime
-                // callstack in one of reserved slot for better bucketting.
-                // we put hash since NFW just takes certain length of callstack which
-                // makes the callstack useless
-                fault.SetBucketParameter(Reserved3, $"{Environment.StackTrace?.GetHashCode() ?? 0}");
-            }
-
-            switch (exception)
-            {
-                case RemoteInvocationException remote:
-                    fault.SetBucketParameter(Reserved1, remote.GetParameterString());
-                    return;
-                case AggregateException aggregate:
-                    if (aggregate.InnerException == null)
-                    {
-                        return;
-                    }
-                    else if (aggregate.InnerExceptions.Count == 1)
-                    {
-                        fault.SetBucketParameter(Reserved1, aggregate.GetParameterString());
-                        return;
-                    }
-                    else
-                    {
-                        var flatten = aggregate.Flatten();
-
-                        fault.SetBucketParameter(Reserved1, flatten.InnerException.GetParameterString());
-                        fault.SetBucketParameter(Reserved2, flatten.CalculateHash());
-
-                        return;
-                    }
-                default:
-                    if (exception.InnerException == null)
-                    {
-                        return;
-                    }
-
-                    fault.SetBucketParameter(Reserved1, exception.InnerException.GetParameterString());
-                    return;
-            }
-        }
-
-        public static string CalculateHash(this AggregateException exception)
-        {
-            var hash = 1;
-            foreach (var inner in exception.InnerExceptions)
-            {
-                var parameterString = inner.GetParameterString();
-                hash = Hash.Combine(parameterString, hash);
-            }
-
-            return hash.ToString();
-        }
-
-        public static string GetParameterString(this Exception exception)
-            => exception switch
-            {
-                RemoteInvocationException remote => $"{remote.ErrorCode} {remote.StackTrace ?? exception.Message}",
-                AggregateException aggregate when aggregate.InnerException != null =>
-                    // get first exception that is not aggregated exception
-                    GetParameterString(aggregate.InnerException),
-                _ => $"{exception.GetType()} {exception.StackTrace ?? exception.ToString()}",
-            };
-
-        public static bool SetCallstackIfEmpty(this Exception exception)
+        public static void SetCallstackIfEmpty(this Exception exception)
         {
             // There have been cases where a new, unthrown exception has been passed to this method.
             // In these cases the exception won't have a stack trace, which isn't very helpful. We
@@ -102,7 +16,7 @@ public static bool SetCallstackIfEmpty(this Exception exception)
             // better than nothing.
             if (exception.StackTrace != null)
             {
-                return false;
+                return;
             }
 
             try
@@ -113,8 +27,6 @@ public static bool SetCallstackIfEmpty(this Exception exception)
             {
                 // Empty; we just need the exception to have a stack trace.
             }
-
-            return true;
         }
     }
 }

From ec7e122b72af01353691f5b5ea0f8c0e884c72a0 Mon Sep 17 00:00:00 2001
From: Jason Malinowski <jason.malinowski@microsoft.com>
Date: Wed, 15 Dec 2021 18:45:23 -0800
Subject: [PATCH 220/444] Delete more unused code

---
 .../Implementation/Watson/FaultReporter.cs    | 19 -------------------
 1 file changed, 19 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/Watson/FaultReporter.cs b/src/VisualStudio/Core/Def/Implementation/Watson/FaultReporter.cs
index 48f120b37326a..3c5d8ea53dc3d 100644
--- a/src/VisualStudio/Core/Def/Implementation/Watson/FaultReporter.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Watson/FaultReporter.cs
@@ -18,8 +18,6 @@ namespace Microsoft.CodeAnalysis.ErrorReporting
 {
     internal static class FaultReporter
     {
-        private static Dictionary<string, string>? s_capturedFileContent;
-
         private static readonly object _guard = new();
         private static ImmutableArray<TelemetrySession> s_telemetrySessions = ImmutableArray<TelemetrySession>.Empty;
         private static ImmutableArray<TraceSource> s_loggers = ImmutableArray<TraceSource>.Empty;
@@ -239,22 +237,5 @@ private static List<string> CollectServiceHubLogFilePaths()
 
             return paths;
         }
-
-        private static void CaptureFilesInMemory(IEnumerable<string> paths)
-        {
-            s_capturedFileContent = new Dictionary<string, string>();
-
-            foreach (var path in paths)
-            {
-                try
-                {
-                    s_capturedFileContent[path] = File.ReadAllText(path);
-                }
-                catch
-                {
-                    // ignore file that can't be read
-                }
-            }
-        }
     }
 }

From ae09b90c96fe0ee178a3f239a2426b7741bf979e Mon Sep 17 00:00:00 2001
From: Shen Chen <shech@microsoft.com>
Date: Tue, 4 Jan 2022 12:26:35 -0800
Subject: [PATCH 221/444] Change the reference to
 Microsoft.NETFramework.ReferenceAssemblies

---
 .../IntegrationTests/Workspace/WorkspaceBase.cs        | 10 ++--------
 .../IntegrationTests/Workspace/WorkspacesNetCore.cs    |  3 ++-
 2 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspaceBase.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspaceBase.cs
index 317c70c0ab0a9..287581f41c8f2 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspaceBase.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspaceBase.cs
@@ -64,16 +64,10 @@ public virtual void MetadataReference()
 
         public void PackageReference()
         {
-            var systemTextJson = new ProjectUtils.PackageReference("System.Text.Json", "6.0.0");
             var project = new ProjectUtils.Project(ProjectName);
-            VisualStudio.SolutionExplorer.AddPackageReference(project, systemTextJson);
+            var referenceAssemblies = new ProjectUtils.PackageReference("Microsoft.NETFramework.ReferenceAssemblies", "1.0.2");
+            VisualStudio.SolutionExplorer.AddPackageReference(project, referenceAssemblies);
             VisualStudio.SolutionExplorer.RestoreNuGetPackages(project);
-            VisualStudio.Editor.SetText("class C { System.Text.Json.JsonElement p; }");
-            VisualStudio.Editor.PlaceCaret("JsonElement");
-            VisualStudio.Editor.Verify.CurrentTokenType("struct name");
-            VisualStudio.SolutionExplorer.RemovePackageReference(project, systemTextJson);
-            VisualStudio.SolutionExplorer.RestoreNuGetPackages(project);
-            VisualStudio.Editor.Verify.CurrentTokenType("identifier");
         }
 
         public virtual void ProjectReference()
diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspacesNetCore.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspacesNetCore.cs
index 5b8cf69a935b9..19c2a17ea77ee 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspacesNetCore.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspacesNetCore.cs
@@ -49,7 +49,8 @@ public override void MetadataReference()
             // https://github.com/dotnet/roslyn/issues/34264
             VisualStudio.Workspace.WaitForAllAsyncOperations(Helper.HangMitigatingTimeout);
             VisualStudio.SolutionExplorer.OpenFile(project, "Class1.cs");
-            base.PackageReference();
+            PackageReference();
+            base.MetadataReference();
         }
 
         [WpfFact]

From b46986356b02554968906e88fdf96884470c417f Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Tue, 4 Jan 2022 14:32:39 -0800
Subject: [PATCH 222/444] Make TryNavigateToMetadataSymbol asynchronous

Fixes #58612
---
 .../DefinitionItem.DefaultDefinitionItem.cs   | 36 +++++++------------
 1 file changed, 13 insertions(+), 23 deletions(-)

diff --git a/src/Features/Core/Portable/FindUsages/DefinitionItem.DefaultDefinitionItem.cs b/src/Features/Core/Portable/FindUsages/DefinitionItem.DefaultDefinitionItem.cs
index d1d5c57c0c225..ec13d642ee034 100644
--- a/src/Features/Core/Portable/FindUsages/DefinitionItem.DefaultDefinitionItem.cs
+++ b/src/Features/Core/Portable/FindUsages/DefinitionItem.DefaultDefinitionItem.cs
@@ -51,7 +51,7 @@ public sealed override async Task<bool> CanNavigateToAsync(Workspace workspace,
                     return false;
 
                 if (Properties.TryGetValue(MetadataSymbolKey, out var symbolKey))
-                    return CanNavigateToMetadataSymbol(workspace, symbolKey);
+                    return await CanNavigateToMetadataSymbolAsync(workspace, symbolKey).ConfigureAwait(false);
 
                 return await this.SourceSpans[0].CanNavigateToAsync(cancellationToken).ConfigureAwait(false);
             }
@@ -62,7 +62,7 @@ public sealed override async Task<bool> TryNavigateToAsync(Workspace workspace,
                     return false;
 
                 if (Properties.TryGetValue(MetadataSymbolKey, out var symbolKey))
-                    return TryNavigateToMetadataSymbol(workspace, symbolKey);
+                    return await TryNavigateToMetadataSymbolAsync(workspace, symbolKey).ConfigureAwait(false);
 
                 return await this.SourceSpans[0].TryNavigateToAsync(showInPreviewTab, activateTab, cancellationToken).ConfigureAwait(false);
             }
@@ -70,12 +70,12 @@ public sealed override async Task<bool> TryNavigateToAsync(Workspace workspace,
             public DetachedDefinitionItem Detach()
                 => new(Tags, DisplayParts, NameDisplayParts, OriginationParts, SourceSpans, Properties, DisplayableProperties, DisplayIfNoReferences);
 
-            private bool CanNavigateToMetadataSymbol(Workspace workspace, string symbolKey)
-                => TryNavigateToMetadataSymbol(workspace, symbolKey, action: (symbol, project, service) => true);
+            private Task<bool> CanNavigateToMetadataSymbolAsync(Workspace workspace, string symbolKey)
+                => TryNavigateToMetadataSymbolAsync(workspace, symbolKey, action: (symbol, project, service) => true);
 
-            private bool TryNavigateToMetadataSymbol(Workspace workspace, string symbolKey)
+            private Task<bool> TryNavigateToMetadataSymbolAsync(Workspace workspace, string symbolKey)
             {
-                return TryNavigateToMetadataSymbol(
+                return TryNavigateToMetadataSymbolAsync(
                     workspace, symbolKey,
                     action: (symbol, project, service) =>
                     {
@@ -84,19 +84,11 @@ private bool TryNavigateToMetadataSymbol(Workspace workspace, string symbolKey)
                     });
             }
 
-            private bool TryNavigateToMetadataSymbol(
+            private async Task<bool> TryNavigateToMetadataSymbolAsync(
                 Workspace workspace, string symbolKey, Func<ISymbol, Project, ISymbolNavigationService, bool> action)
             {
-                var projectAndSymbol = TryResolveSymbolInCurrentSolution(workspace, symbolKey);
-
-                var project = projectAndSymbol.project;
-                var symbol = projectAndSymbol.symbol;
-                if (symbol == null || project == null)
-                {
-                    return false;
-                }
-
-                if (symbol.Kind == SymbolKind.Namespace)
+                var projectAndSymbol = await TryResolveSymbolInCurrentSolutionAsync(workspace, symbolKey).ConfigureAwait(false);
+                if (projectAndSymbol is not (var project, { Kind: not SymbolKind.Namespace } symbol))
                 {
                     return false;
                 }
@@ -105,21 +97,19 @@ private bool TryNavigateToMetadataSymbol(
                 return action(symbol, project, navigationService);
             }
 
-            private (Project? project, ISymbol? symbol) TryResolveSymbolInCurrentSolution(Workspace workspace, string symbolKey)
+            private async ValueTask<(Project project, ISymbol? symbol)?> TryResolveSymbolInCurrentSolutionAsync(Workspace workspace, string symbolKey)
             {
                 if (!Properties.TryGetValue(MetadataSymbolOriginatingProjectIdGuid, out var projectIdGuid) ||
                     !Properties.TryGetValue(MetadataSymbolOriginatingProjectIdDebugName, out var projectDebugName))
                 {
-                    return default;
+                    return null;
                 }
 
                 var project = workspace.CurrentSolution.GetProject(ProjectId.CreateFromSerialized(Guid.Parse(projectIdGuid), projectDebugName));
                 if (project == null)
-                    return default;
-
-                var compilation = project.GetRequiredCompilationAsync(CancellationToken.None)
-                                         .WaitAndGetResult(CancellationToken.None);
+                    return null;
 
+                var compilation = await project.GetRequiredCompilationAsync(CancellationToken.None).ConfigureAwait(false);
                 var symbol = SymbolKey.ResolveString(symbolKey, compilation).Symbol;
                 return (project, symbol);
             }

From 39c57377c6075b2ee9ae343d293a5ce3b368e6bc Mon Sep 17 00:00:00 2001
From: AlekseyTs <AlekseyTs@users.noreply.github.com>
Date: Tue, 4 Jan 2022 15:04:51 -0800
Subject: [PATCH 223/444] Adjust design behind Nullable analysis for
 target-typed expressions and add handling for target-typed new. (#58509)

With the new approach the analysis steps that should be completed later, when the target type with all nullability information becomes known, are stored in a map as a delegate. The delegate is invoked by `VisitConversion` and completes the analysis.

The implementation is intentionally carefully structured in such a way that it avoids code duplication and deviations between regular analysis and target-typed analysis . Helper functions are either executed normally for a non-target-typed scenario, or are folded into the final completion as delegates. Effectively the final completion delegate is a composition of delegates.

This change also creates a BoundConversion node for successful target-typed new conversions. Here is the quote from ([https://github.com/dotnet/csharplang/blob/main/proposals/csharp-9.0/target-typed-new.md#specification](https://github.com/dotnet/csharplang/blob/main/proposals/csharp-9.0/target-typed-new.md#specification)): "**there is a new object creation conversion that is an implicit conversion from expression**, that exists from a target_typed_new to every type." Presence of this node simplifies Nullable analysis.

Fixes #49736.
Fixes #58369.
---
 .../Portable/Binder/Binder_Conversions.cs     |  127 +-
 .../Portable/Binder/Binder_Expressions.cs     |  131 +-
 .../Portable/Binder/Binder_Operators.cs       |    2 +-
 .../Semantics/Conversions/Conversion.cs       |    2 +-
 .../BoundDynamicObjectCreationExpression.cs   |   17 +
 .../CSharp/Portable/BoundTree/BoundNewT.cs    |   20 +
 .../BoundNoPiaObjectCreationExpression.cs     |   20 +
 .../CSharp/Portable/BoundTree/BoundNodes.xml  |   60 +-
 .../BoundObjectCreationExpressionBase.cs      |   22 +
 .../Portable/FlowAnalysis/NullableWalker.cs   | 1496 ++++++++++++-----
 .../FlowAnalysis/NullableWalker_Patterns.cs   |  106 +-
 .../Generated/BoundNodes.xml.Generated.cs     |  204 ++-
 .../ClosureConversion/ClosureConversion.cs    |    2 +
 .../LocalRewriter/LocalRewriter_Conversion.cs |   27 +-
 ...ocalRewriter_DelegateCreationExpression.cs |    4 +-
 .../LocalRewriter/LocalRewriter_Event.cs      |    2 +
 .../LocalRewriter/LocalRewriter_Index.cs      |   20 +-
 .../LocalRewriter_ObjectCreationExpression.cs |    2 +-
 .../LocalRewriter/LocalRewriter_Range.cs      |    7 +-
 .../Lowering/MethodToClassRewriter.cs         |    2 +-
 .../Portable/Lowering/SpillSequenceSpiller.cs |    2 +-
 .../CSharp/Portable/PublicAPI.Unshipped.txt   |    1 +
 .../Symbols/Source/ParameterHelpers.cs        |   29 +-
 ...perationTests_IObjectCreationExpression.cs |  858 +++++-----
 ...tionTests_IParameterReferenceExpression.cs |    6 +-
 .../Semantics/ImplicitObjectCreationTests.cs  |   56 +-
 .../Semantics/NullableReferenceTypesTests.cs  | 1424 ++++++++++++++++
 .../Semantics/StructConstructorTests.cs       |   83 +-
 .../SemanticModelGetSemanticInfoTests.cs      |   40 +-
 29 files changed, 3608 insertions(+), 1164 deletions(-)
 create mode 100644 src/Compilers/CSharp/Portable/BoundTree/BoundDynamicObjectCreationExpression.cs
 create mode 100644 src/Compilers/CSharp/Portable/BoundTree/BoundNewT.cs
 create mode 100644 src/Compilers/CSharp/Portable/BoundTree/BoundNoPiaObjectCreationExpression.cs
 create mode 100644 src/Compilers/CSharp/Portable/BoundTree/BoundObjectCreationExpressionBase.cs

diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs
index 12bed509e29ef..7afffae813852 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs
@@ -227,24 +227,16 @@ BoundExpression createConversion(
 
                 if (conversion.IsObjectCreation)
                 {
-                    return ConvertObjectCreationExpression(syntax, (BoundUnconvertedObjectCreationExpression)source, isCast, destination, diagnostics);
+                    return ConvertObjectCreationExpression(syntax, (BoundUnconvertedObjectCreationExpression)source, conversion, isCast, destination, conversionGroupOpt, wasCompilerGenerated, diagnostics);
                 }
 
                 if (source.Kind == BoundKind.UnconvertedConditionalOperator)
                 {
-                    TypeSymbol? type = source.Type;
-                    if (type is null)
-                    {
-                        Debug.Assert(!conversion.Exists);
-                        type = CreateErrorType();
-                        hasErrors = true;
-                    }
+                    Debug.Assert(source.Type is null);
+                    Debug.Assert(!conversion.Exists);
+                    hasErrors = true;
 
-                    source = ConvertConditionalExpression((BoundUnconvertedConditionalOperator)source, type, conversionIfTargetTyped: null, diagnostics, hasErrors);
-                    if (destination.Equals(type, TypeCompareKind.ConsiderEverything) && wasCompilerGenerated)
-                    {
-                        return source;
-                    }
+                    source = ConvertConditionalExpression((BoundUnconvertedConditionalOperator)source, CreateErrorType(), conversionIfTargetTyped: null, diagnostics, hasErrors);
                 }
 
                 if (conversion.IsUserDefined)
@@ -336,65 +328,68 @@ internal void CheckConstraintLanguageVersionAndRuntimeSupportForConversion(Synta
             }
         }
 
-        private BoundExpression ConvertObjectCreationExpression(SyntaxNode syntax, BoundUnconvertedObjectCreationExpression node, bool isCast, TypeSymbol destination, BindingDiagnosticBag diagnostics)
+        private BoundExpression ConvertObjectCreationExpression(
+            SyntaxNode syntax, BoundUnconvertedObjectCreationExpression node, Conversion conversion, bool isCast, TypeSymbol destination,
+            ConversionGroup? conversionGroupOpt, bool wasCompilerGenerated, BindingDiagnosticBag diagnostics)
         {
             var arguments = AnalyzedArguments.GetInstance(node.Arguments, node.ArgumentRefKindsOpt, node.ArgumentNamesOpt);
-            BoundExpression expr = BindObjectCreationExpression(node, destination.StrippedType(), arguments, diagnostics);
-            if (destination.IsNullableType())
-            {
-                // We manually create an ImplicitNullable conversion
-                // if the destination is nullable, in which case we
-                // target the underlying type e.g. `S? x = new();`
-                // is actually identical to `S? x = new S();`.
-                CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);
-                var conversion = Conversions.ClassifyStandardConversion(null, expr.Type, destination, ref useSiteInfo);
-                Debug.Assert(conversion.IsNullable);
-                Debug.Assert(conversion.UnderlyingConversions.Single().IsIdentity);
-                conversion.MarkUnderlyingConversionsChecked();
-                expr = new BoundConversion(
-                    node.Syntax,
-                    operand: expr,
-                    conversion: conversion,
-                    @checked: false,
-                    explicitCastInCode: isCast,
-                    conversionGroupOpt: new ConversionGroup(conversion),
-                    constantValueOpt: expr.ConstantValue,
-                    type: destination);
+            BoundExpression expr = bindObjectCreationExpression(node, destination.StrippedType(), arguments, diagnostics);
+            arguments.Free();
+
+            Debug.Assert(expr is BoundObjectCreationExpressionBase { WasTargetTyped: true } or
+                                 BoundDelegateCreationExpression { WasTargetTyped: true } or
+                                 BoundBadExpression);
 
-                diagnostics.Add(syntax, useSiteInfo);
+            // Assert that the shape of the BoundBadExpression is sound and is not going to confuse NullableWalker for target-typed 'new'.
+            Debug.Assert(expr is not BoundBadExpression { ChildBoundNodes: var children } || !children.Any((child, node) => child.Syntax == node.Syntax, node));
+
+            if (wasCompilerGenerated)
+            {
+                expr.MakeCompilerGenerated();
             }
-            arguments.Free();
+
+            expr = new BoundConversion(
+                                  syntax,
+                                  expr,
+                                  expr is BoundBadExpression ? Conversion.NoConversion : conversion,
+                                  CheckOverflowAtRuntime,
+                                  explicitCastInCode: isCast && !wasCompilerGenerated,
+                                  conversionGroupOpt,
+                                  expr.ConstantValue,
+                                  destination)
+            { WasCompilerGenerated = wasCompilerGenerated };
+
             return expr;
-        }
 
-        private BoundExpression BindObjectCreationExpression(BoundUnconvertedObjectCreationExpression node, TypeSymbol type, AnalyzedArguments arguments, BindingDiagnosticBag diagnostics)
-        {
-            var syntax = node.Syntax;
-            switch (type.TypeKind)
-            {
-                case TypeKind.Enum:
-                case TypeKind.Struct:
-                case TypeKind.Class when !type.IsAnonymousType: // We don't want to enable object creation with unspeakable types
-                    return BindClassCreationExpression(syntax, type.Name, typeNode: syntax, (NamedTypeSymbol)type, arguments, diagnostics, node.InitializerOpt, wasTargetTyped: true);
-                case TypeKind.TypeParameter:
-                    return BindTypeParameterCreationExpression(syntax, (TypeParameterSymbol)type, arguments, node.InitializerOpt, typeSyntax: syntax, diagnostics);
-                case TypeKind.Delegate:
-                    return BindDelegateCreationExpression(syntax, (NamedTypeSymbol)type, arguments, node.InitializerOpt, diagnostics);
-                case TypeKind.Interface:
-                    return BindInterfaceCreationExpression(syntax, (NamedTypeSymbol)type, diagnostics, typeNode: syntax, arguments, node.InitializerOpt, wasTargetTyped: true);
-                case TypeKind.Array:
-                case TypeKind.Class:
-                case TypeKind.Dynamic:
-                    Error(diagnostics, ErrorCode.ERR_ImplicitObjectCreationIllegalTargetType, syntax, type);
-                    goto case TypeKind.Error;
-                case TypeKind.Pointer:
-                case TypeKind.FunctionPointer:
-                    Error(diagnostics, ErrorCode.ERR_UnsafeTypeInObjectCreation, syntax, type);
-                    goto case TypeKind.Error;
-                case TypeKind.Error:
-                    return MakeBadExpressionForObjectCreation(syntax, type, arguments, node.InitializerOpt, typeSyntax: syntax, diagnostics);
-                case var v:
-                    throw ExceptionUtilities.UnexpectedValue(v);
+            BoundExpression bindObjectCreationExpression(BoundUnconvertedObjectCreationExpression node, TypeSymbol type, AnalyzedArguments arguments, BindingDiagnosticBag diagnostics)
+            {
+                var syntax = node.Syntax;
+                switch (type.TypeKind)
+                {
+                    case TypeKind.Enum:
+                    case TypeKind.Struct:
+                    case TypeKind.Class when !type.IsAnonymousType: // We don't want to enable object creation with unspeakable types
+                        return BindClassCreationExpression(syntax, type.Name, typeNode: syntax, (NamedTypeSymbol)type, arguments, diagnostics, node.InitializerOpt, wasTargetTyped: true);
+                    case TypeKind.TypeParameter:
+                        return BindTypeParameterCreationExpression(syntax, (TypeParameterSymbol)type, arguments, node.InitializerOpt, typeSyntax: syntax, wasTargetTyped: true, diagnostics);
+                    case TypeKind.Delegate:
+                        return BindDelegateCreationExpression(syntax, (NamedTypeSymbol)type, arguments, node.InitializerOpt, wasTargetTyped: true, diagnostics);
+                    case TypeKind.Interface:
+                        return BindInterfaceCreationExpression(syntax, (NamedTypeSymbol)type, diagnostics, typeNode: syntax, arguments, node.InitializerOpt, wasTargetTyped: true);
+                    case TypeKind.Array:
+                    case TypeKind.Class:
+                    case TypeKind.Dynamic:
+                        Error(diagnostics, ErrorCode.ERR_ImplicitObjectCreationIllegalTargetType, syntax, type);
+                        goto case TypeKind.Error;
+                    case TypeKind.Pointer:
+                    case TypeKind.FunctionPointer:
+                        Error(diagnostics, ErrorCode.ERR_UnsafeTypeInObjectCreation, syntax, type);
+                        goto case TypeKind.Error;
+                    case TypeKind.Error:
+                        return MakeBadExpressionForObjectCreation(syntax, type, arguments, node.InitializerOpt, typeSyntax: syntax, diagnostics);
+                    case var v:
+                        throw ExceptionUtilities.UnexpectedValue(v);
+                }
             }
         }
 
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
index 11c4afb8019ea..eebef6195fe3e 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
@@ -4202,52 +4202,62 @@ private BoundExpression BindImplicitObjectCreationExpression(ImplicitObjectCreat
 
         protected BoundExpression BindObjectCreationExpression(ObjectCreationExpressionSyntax node, BindingDiagnosticBag diagnostics)
         {
-            var typeWithAnnotations = BindType(node.Type, diagnostics);
-            var type = typeWithAnnotations.Type;
-            var originalType = type;
+            BoundExpression result = bindObjectCreationExpression(node, diagnostics);
 
-            if (typeWithAnnotations.NullableAnnotation.IsAnnotated() && !type.IsNullableType())
-            {
-                diagnostics.Add(ErrorCode.ERR_AnnotationDisallowedInObjectCreation, node.Location, type);
-            }
+            // Assert that the shape of the BoundBadExpression is sound and is not going to confuse NullableWalker for target-typed 'new'.
+            Debug.Assert(result is not BoundBadExpression { ChildBoundNodes: var children } || !children.Any((child, node) => child.Syntax == node, node));
+
+            return result;
 
-            switch (type.TypeKind)
+            BoundExpression bindObjectCreationExpression(ObjectCreationExpressionSyntax node, BindingDiagnosticBag diagnostics)
             {
-                case TypeKind.Struct:
-                case TypeKind.Class:
-                case TypeKind.Enum:
-                case TypeKind.Error:
-                    return BindClassCreationExpression(node, (NamedTypeSymbol)type, GetName(node.Type), diagnostics, originalType);
+                var typeWithAnnotations = BindType(node.Type, diagnostics);
+                var type = typeWithAnnotations.Type;
+                var originalType = type;
 
-                case TypeKind.Delegate:
-                    return BindDelegateCreationExpression(node, (NamedTypeSymbol)type, diagnostics);
+                if (typeWithAnnotations.NullableAnnotation.IsAnnotated() && !type.IsNullableType())
+                {
+                    diagnostics.Add(ErrorCode.ERR_AnnotationDisallowedInObjectCreation, node.Location, type);
+                }
 
-                case TypeKind.Interface:
-                    return BindInterfaceCreationExpression(node, (NamedTypeSymbol)type, diagnostics);
+                switch (type.TypeKind)
+                {
+                    case TypeKind.Struct:
+                    case TypeKind.Class:
+                    case TypeKind.Enum:
+                    case TypeKind.Error:
+                        return BindClassCreationExpression(node, (NamedTypeSymbol)type, GetName(node.Type), diagnostics, originalType);
 
-                case TypeKind.TypeParameter:
-                    return BindTypeParameterCreationExpression(node, (TypeParameterSymbol)type, diagnostics);
+                    case TypeKind.Delegate:
+                        return BindDelegateCreationExpression(node, (NamedTypeSymbol)type, diagnostics);
 
-                case TypeKind.Submission:
-                    // script class is synthesized and should not be used as a type of a new expression:
-                    throw ExceptionUtilities.UnexpectedValue(type.TypeKind);
+                    case TypeKind.Interface:
+                        return BindInterfaceCreationExpression(node, (NamedTypeSymbol)type, diagnostics);
 
-                case TypeKind.Pointer:
-                case TypeKind.FunctionPointer:
-                    type = new ExtendedErrorTypeSymbol(type, LookupResultKind.NotCreatable,
-                        diagnostics.Add(ErrorCode.ERR_UnsafeTypeInObjectCreation, node.Location, type));
-                    goto case TypeKind.Class;
+                    case TypeKind.TypeParameter:
+                        return BindTypeParameterCreationExpression(node, (TypeParameterSymbol)type, diagnostics);
 
-                case TypeKind.Dynamic:
-                // we didn't find any type called "dynamic" so we are using the builtin dynamic type, which has no constructors:
-                case TypeKind.Array:
-                    // ex: new ref[]
-                    type = new ExtendedErrorTypeSymbol(type, LookupResultKind.NotCreatable,
-                        diagnostics.Add(ErrorCode.ERR_InvalidObjectCreation, node.Type.Location, type));
-                    goto case TypeKind.Class;
+                    case TypeKind.Submission:
+                        // script class is synthesized and should not be used as a type of a new expression:
+                        throw ExceptionUtilities.UnexpectedValue(type.TypeKind);
 
-                default:
-                    throw ExceptionUtilities.UnexpectedValue(type.TypeKind);
+                    case TypeKind.Pointer:
+                    case TypeKind.FunctionPointer:
+                        type = new ExtendedErrorTypeSymbol(type, LookupResultKind.NotCreatable,
+                            diagnostics.Add(ErrorCode.ERR_UnsafeTypeInObjectCreation, node.Location, type));
+                        goto case TypeKind.Class;
+
+                    case TypeKind.Dynamic:
+                    // we didn't find any type called "dynamic" so we are using the builtin dynamic type, which has no constructors:
+                    case TypeKind.Array:
+                        // ex: new ref[]
+                        type = new ExtendedErrorTypeSymbol(type, LookupResultKind.NotCreatable,
+                            diagnostics.Add(ErrorCode.ERR_InvalidObjectCreation, node.Type.Location, type));
+                        goto case TypeKind.Class;
+
+                    default:
+                        throw ExceptionUtilities.UnexpectedValue(type.TypeKind);
+                }
             }
         }
 
@@ -4255,12 +4265,12 @@ private BoundExpression BindDelegateCreationExpression(ObjectCreationExpressionS
         {
             AnalyzedArguments analyzedArguments = AnalyzedArguments.GetInstance();
             BindArgumentsAndNames(node.ArgumentList, diagnostics, analyzedArguments, isDelegateCreation: true);
-            var result = BindDelegateCreationExpression(node, type, analyzedArguments, node.Initializer, diagnostics);
+            var result = BindDelegateCreationExpression(node, type, analyzedArguments, node.Initializer, wasTargetTyped: false, diagnostics);
             analyzedArguments.Free();
             return result;
         }
 
-        private BoundExpression BindDelegateCreationExpression(SyntaxNode node, NamedTypeSymbol type, AnalyzedArguments analyzedArguments, InitializerExpressionSyntax initializerOpt, BindingDiagnosticBag diagnostics)
+        private BoundExpression BindDelegateCreationExpression(SyntaxNode node, NamedTypeSymbol type, AnalyzedArguments analyzedArguments, InitializerExpressionSyntax initializerOpt, bool wasTargetTyped, BindingDiagnosticBag diagnostics)
         {
             bool hasErrors = false;
             if (analyzedArguments.HasErrors)
@@ -4333,7 +4343,7 @@ private BoundExpression BindDelegateCreationExpression(SyntaxNode node, NamedTyp
                 // Just stuff the bound lambda into the delegate creation expression. When we lower the lambda to
                 // its method form we will rewrite this expression to refer to the method.
 
-                return new BoundDelegateCreationExpression(node, boundLambda, methodOpt: null, isExtensionMethod: false, type: type, hasErrors: !conversion.IsImplicit);
+                return new BoundDelegateCreationExpression(node, boundLambda, methodOpt: null, isExtensionMethod: false, wasTargetTyped, type: type, hasErrors: !conversion.IsImplicit);
             }
 
             else if (analyzedArguments.HasErrors)
@@ -4348,7 +4358,7 @@ private BoundExpression BindDelegateCreationExpression(SyntaxNode node, NamedTyp
                 BoundMethodGroup methodGroup = (BoundMethodGroup)argument;
                 hasErrors = MethodGroupConversionDoesNotExistOrHasErrors(methodGroup, type, node.Location, diagnostics, out conversion);
                 methodGroup = FixMethodGroupWithTypeOrValue(methodGroup, conversion, diagnostics);
-                return new BoundDelegateCreationExpression(node, methodGroup, conversion.Method, conversion.IsExtensionMethod, type, hasErrors);
+                return new BoundDelegateCreationExpression(node, methodGroup, conversion.Method, conversion.IsExtensionMethod, wasTargetTyped, type, hasErrors);
             }
 
             else if ((object)argument.Type == null)
@@ -4359,7 +4369,7 @@ private BoundExpression BindDelegateCreationExpression(SyntaxNode node, NamedTyp
             // 3. A value of the compile-time type dynamic (which is dynamically case 4), or
             else if (argument.HasDynamicType())
             {
-                return new BoundDelegateCreationExpression(node, argument, methodOpt: null, isExtensionMethod: false, type: type);
+                return new BoundDelegateCreationExpression(node, argument, methodOpt: null, isExtensionMethod: false, wasTargetTyped, type: type);
             }
 
             // 4. A delegate type.
@@ -4401,7 +4411,7 @@ private BoundExpression BindDelegateCreationExpression(SyntaxNode node, NamedTyp
                         if (!this.MethodGroupConversionHasErrors(argument.Syntax, conv, argument, conv.IsExtensionMethod, isAddressOf: false, type, diagnostics))
                         {
                             // we do not place the "Invoke" method in the node, indicating that it did not appear in source.
-                            return new BoundDelegateCreationExpression(node, argument, methodOpt: null, isExtensionMethod: false, type: type);
+                            return new BoundDelegateCreationExpression(node, argument, methodOpt: null, isExtensionMethod: false, wasTargetTyped, type: type);
                         }
                     }
                 }
@@ -5333,6 +5343,7 @@ protected BoundExpression BindClassCreationExpression(
                         refKindsArray,
                         boundInitializerOpt,
                         overloadResolutionResult.GetAllApplicableMembers(),
+                        wasTargetTyped,
                         type,
                         hasErrors);
                 }
@@ -5354,7 +5365,8 @@ protected BoundExpression BindClassCreationExpression(
                     diagnostics,
                     out MemberResolutionResult<MethodSymbol> memberResolutionResult,
                     out ImmutableArray<MethodSymbol> candidateConstructors,
-                    allowProtectedConstructorsOfBaseType: false))
+                    allowProtectedConstructorsOfBaseType: false) &&
+                !type.IsAbstract)
             {
                 var method = memberResolutionResult.Member;
 
@@ -5415,12 +5427,6 @@ protected BoundExpression BindClassCreationExpression(
                     type,
                     hasError);
 
-                // CONSIDER: Add ResultKind field to BoundObjectCreationExpression to avoid wrapping result with BoundBadExpression.
-                if (type.IsAbstract)
-                {
-                    result = BadExpression(node, LookupResultKind.NotCreatable, result);
-                }
-
                 return result;
             }
 
@@ -5539,7 +5545,7 @@ private BoundExpression BindComImportCoClassCreationExpression(SyntaxNode node,
                 // NoPIA support
                 if (interfaceType.ContainingAssembly.IsLinked)
                 {
-                    return BindNoPiaObjectCreationExpression(node, interfaceType, coClassType, diagnostics, typeNode, analyzedArguments, initializerOpt);
+                    return BindNoPiaObjectCreationExpression(node, interfaceType, coClassType, diagnostics, typeNode, analyzedArguments, initializerOpt, wasTargetTyped);
                 }
 
                 var classCreation = BindClassCreationExpression(
@@ -5592,7 +5598,8 @@ private BoundExpression BindNoPiaObjectCreationExpression(
             BindingDiagnosticBag diagnostics,
             SyntaxNode typeNode,
             AnalyzedArguments analyzedArguments,
-            InitializerExpressionSyntax initializerOpt)
+            InitializerExpressionSyntax initializerOpt,
+            bool wasTargetTyped)
         {
             string guidString;
             if (!coClassType.GetGuidString(out guidString))
@@ -5609,29 +5616,35 @@ private BoundExpression BindNoPiaObjectCreationExpression(
                     isForNewInstance: true,
                     diagnostics: diagnostics);
 
-            var creation = new BoundNoPiaObjectCreationExpression(node, guidString, boundInitializerOpt, interfaceType);
-
             if (analyzedArguments.Arguments.Count > 0)
             {
                 diagnostics.Add(ErrorCode.ERR_BadCtorArgCount, typeNode.Location, interfaceType, analyzedArguments.Arguments.Count);
 
-                var children = BuildArgumentsForErrorRecovery(analyzedArguments).Add(creation);
-                return new BoundBadExpression(node, LookupResultKind.OverloadResolutionFailure, ImmutableArray<Symbol>.Empty, children, creation.Type);
+                var children = BuildArgumentsForErrorRecovery(analyzedArguments);
+
+                if (boundInitializerOpt is not null)
+                {
+                    children = children.Add(boundInitializerOpt);
+                }
+
+                return new BoundBadExpression(node, LookupResultKind.OverloadResolutionFailure, ImmutableArray<Symbol>.Empty, children, interfaceType);
             }
 
-            return creation;
+            return new BoundNoPiaObjectCreationExpression(node, guidString, boundInitializerOpt, wasTargetTyped, interfaceType);
         }
 
         private BoundExpression BindTypeParameterCreationExpression(ObjectCreationExpressionSyntax node, TypeParameterSymbol typeParameter, BindingDiagnosticBag diagnostics)
         {
             AnalyzedArguments analyzedArguments = AnalyzedArguments.GetInstance();
             BindArgumentsAndNames(node.ArgumentList, diagnostics, analyzedArguments);
-            var result = BindTypeParameterCreationExpression(node, typeParameter, analyzedArguments, node.Initializer, node.Type, diagnostics);
+            var result = BindTypeParameterCreationExpression(node, typeParameter, analyzedArguments, node.Initializer, node.Type, wasTargetTyped: false, diagnostics);
             analyzedArguments.Free();
             return result;
         }
 
-        private BoundExpression BindTypeParameterCreationExpression(SyntaxNode node, TypeParameterSymbol typeParameter, AnalyzedArguments analyzedArguments, InitializerExpressionSyntax initializerOpt, SyntaxNode typeSyntax, BindingDiagnosticBag diagnostics)
+        private BoundExpression BindTypeParameterCreationExpression(
+            SyntaxNode node, TypeParameterSymbol typeParameter, AnalyzedArguments analyzedArguments, InitializerExpressionSyntax initializerOpt,
+            SyntaxNode typeSyntax, bool wasTargetTyped, BindingDiagnosticBag diagnostics)
         {
             if (!typeParameter.HasConstructorConstraint && !typeParameter.IsValueType)
             {
@@ -5651,7 +5664,7 @@ private BoundExpression BindTypeParameterCreationExpression(SyntaxNode node, Typ
                         typeSyntax: typeSyntax,
                         isForNewInstance: true,
                         diagnostics: diagnostics);
-                return new BoundNewT(node, boundInitializerOpt, typeParameter);
+                return new BoundNewT(node, boundInitializerOpt, wasTargetTyped, typeParameter);
             }
 
             return MakeBadExpressionForObjectCreation(node, typeParameter, analyzedArguments, initializerOpt, typeSyntax, diagnostics);
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Operators.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Operators.cs
index aa526e3bc8970..c250ecad554c4 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Operators.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Operators.cs
@@ -4106,7 +4106,7 @@ private BoundExpression BindValueConditionalOperator(ConditionalExpressionSyntax
             {
                 ErrorCode noCommonTypeError = hadMultipleCandidates ? ErrorCode.ERR_AmbigQM : ErrorCode.ERR_InvalidQM;
                 constantValue = FoldConditionalOperator(condition, trueExpr, falseExpr);
-                return new BoundUnconvertedConditionalOperator(node, condition, trueExpr, falseExpr, constantValue, noCommonTypeError, type: null, hasErrors: constantValue?.IsBad == true);
+                return new BoundUnconvertedConditionalOperator(node, condition, trueExpr, falseExpr, constantValue, noCommonTypeError, hasErrors: constantValue?.IsBad == true);
             }
 
             TypeSymbol type;
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/Conversion.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/Conversion.cs
index 7a36b42b7d106..0d7dfe75573a9 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/Conversion.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/Conversion.cs
@@ -624,7 +624,7 @@ public bool IsThrow
         /// <summary>
         /// Returns true if the conversion is an implicit object creation expression conversion.
         /// </summary>
-        internal bool IsObjectCreation
+        public bool IsObjectCreation
         {
             get
             {
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundDynamicObjectCreationExpression.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundDynamicObjectCreationExpression.cs
new file mode 100644
index 0000000000000..fc5294f46c036
--- /dev/null
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundDynamicObjectCreationExpression.cs
@@ -0,0 +1,17 @@
+// 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.CSharp.Symbols;
+
+namespace Microsoft.CodeAnalysis.CSharp
+{
+    partial class BoundDynamicObjectCreationExpression
+    {
+        public override MethodSymbol? Constructor => null;
+        public override bool Expanded => false;
+        public override ImmutableArray<int> ArgsToParamsOpt => default;
+        public override BitVector DefaultArguments => default;
+    }
+}
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundNewT.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundNewT.cs
new file mode 100644
index 0000000000000..fbceb40a79fad
--- /dev/null
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundNewT.cs
@@ -0,0 +1,20 @@
+// 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.CSharp.Symbols;
+
+namespace Microsoft.CodeAnalysis.CSharp
+{
+    partial class BoundNewT
+    {
+        public override MethodSymbol? Constructor => null;
+        public override ImmutableArray<BoundExpression> Arguments => ImmutableArray<BoundExpression>.Empty;
+        public override ImmutableArray<string> ArgumentNamesOpt => default;
+        public override ImmutableArray<RefKind> ArgumentRefKindsOpt => default;
+        public override bool Expanded => false;
+        public override ImmutableArray<int> ArgsToParamsOpt => default;
+        public override BitVector DefaultArguments => default;
+    }
+}
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundNoPiaObjectCreationExpression.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundNoPiaObjectCreationExpression.cs
new file mode 100644
index 0000000000000..b0e92f46aea41
--- /dev/null
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundNoPiaObjectCreationExpression.cs
@@ -0,0 +1,20 @@
+// 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.CSharp.Symbols;
+
+namespace Microsoft.CodeAnalysis.CSharp
+{
+    partial class BoundNoPiaObjectCreationExpression
+    {
+        public override MethodSymbol? Constructor => null;
+        public override ImmutableArray<BoundExpression> Arguments => ImmutableArray<BoundExpression>.Empty;
+        public override ImmutableArray<string> ArgumentNamesOpt => default;
+        public override ImmutableArray<RefKind> ArgumentRefKindsOpt => default;
+        public override bool Expanded => false;
+        public override ImmutableArray<int> ArgsToParamsOpt => default;
+        public override BitVector DefaultArguments => default;
+    }
+}
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
index 8f5c584ea5641..819613f95226e 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
@@ -611,6 +611,9 @@
   </Node>
 
   <Node Name="BoundUnconvertedConditionalOperator" Base="BoundExpression">
+    <!-- Type is null. -->
+    <Field Name="Type" Type="TypeSymbol?" Override="true" Null="always"/>
+
     <Field Name="Condition" Type="BoundExpression"/>
     <Field Name="Consequence" Type="BoundExpression"/>
     <Field Name="Alternative" Type="BoundExpression"/>
@@ -1769,29 +1772,31 @@
       <Field Name="InitializerOpt" Type="InitializerExpressionSyntax?" Null="allow"/>
   </Node>
 
+  <AbstractNode Name="BoundObjectCreationExpressionBase" Base="BoundExpression">
+    <!-- Non-null type is required for this node kind -->
+    <Field Name="Type" Type="TypeSymbol" Override="true" Null="disallow"/>
+  </AbstractNode>
+
   <!-- 
   Constructor is optional because value types can be created without calling any constructor -
  
      int x = new int();        
   -->
-  <Node Name="BoundObjectCreationExpression" Base="BoundExpression">
-    <!-- Non-null type is required for this node kind -->
-    <Field Name="Type" Type="TypeSymbol" Override="true" Null="disallow"/>
-
-    <Field Name="Constructor" Type="MethodSymbol"/>
+  <Node Name="BoundObjectCreationExpression" Base="BoundObjectCreationExpressionBase">
+    <Field Name="Constructor" Type="MethodSymbol" PropertyOverrides="true"/>
     
     <!-- These symbols will be returned from the GetSemanticInfo API if it examines this bound node. -->
     <Field Name="ConstructorsGroup" Type="ImmutableArray&lt;MethodSymbol&gt;"/>
     
-    <Field Name="Arguments" Type="ImmutableArray&lt;BoundExpression&gt;"/>
-    <Field Name="ArgumentNamesOpt" Type="ImmutableArray&lt;string&gt;" Null="allow"/>
-    <Field Name="ArgumentRefKindsOpt" Type="ImmutableArray&lt;RefKind&gt;" Null="allow"/>
-    <Field Name="Expanded" Type="bool"/>
-    <Field Name="ArgsToParamsOpt" Type="ImmutableArray&lt;int&gt;" Null="allow"/>
-    <Field Name="DefaultArguments" Type="BitVector" />
+    <Field Name="Arguments" Type="ImmutableArray&lt;BoundExpression&gt;" PropertyOverrides="true"/>
+    <Field Name="ArgumentNamesOpt" Type="ImmutableArray&lt;string&gt;" Null="allow" PropertyOverrides="true"/>
+    <Field Name="ArgumentRefKindsOpt" Type="ImmutableArray&lt;RefKind&gt;" Null="allow" PropertyOverrides="true"/>
+    <Field Name="Expanded" Type="bool" PropertyOverrides="true"/>
+    <Field Name="ArgsToParamsOpt" Type="ImmutableArray&lt;int&gt;" Null="allow" PropertyOverrides="true"/>
+    <Field Name="DefaultArguments" Type="BitVector" PropertyOverrides="true"/>
     <Field Name="ConstantValueOpt" Type="ConstantValue?"/>
-    <Field Name="InitializerExpressionOpt" Type="BoundObjectInitializerExpressionBase?"/>
-    <Field Name="WasTargetTyped" Type="bool"/>
+    <Field Name="InitializerExpressionOpt" Type="BoundObjectInitializerExpressionBase?" PropertyOverrides="true"/>
+    <Field Name="WasTargetTyped" Type="bool" PropertyOverrides="true"/>
   </Node>
   
 
@@ -1835,22 +1840,20 @@
     <Field Name="WasTargetTyped" Type="bool" />
   </Node>
 
-  <Node Name="BoundDynamicObjectCreationExpression" Base="BoundExpression">
-    <!-- Non-null type is required for this node kind -->
-    <Field Name="Type" Type="TypeSymbol" Override="true" Null="disallow"/>
+  <Node Name="BoundDynamicObjectCreationExpression" Base="BoundObjectCreationExpressionBase">
     <Field Name="Name" Type="string" Null="disallow"/>
-    <Field Name="Arguments" Type="ImmutableArray&lt;BoundExpression&gt;"/>
-    <Field Name="ArgumentNamesOpt" Type="ImmutableArray&lt;string&gt;" Null="allow"/>
-    <Field Name="ArgumentRefKindsOpt" Type="ImmutableArray&lt;RefKind&gt;" Null="allow"/>
-    <Field Name="InitializerExpressionOpt" Type="BoundObjectInitializerExpressionBase?"/>
+    <Field Name="Arguments" Type="ImmutableArray&lt;BoundExpression&gt;" PropertyOverrides="true"/>
+    <Field Name="ArgumentNamesOpt" Type="ImmutableArray&lt;string&gt;" Null="allow" PropertyOverrides="true"/>
+    <Field Name="ArgumentRefKindsOpt" Type="ImmutableArray&lt;RefKind&gt;" Null="allow" PropertyOverrides="true"/>
+    <Field Name="InitializerExpressionOpt" Type="BoundObjectInitializerExpressionBase?" PropertyOverrides="true"/>
     <Field Name="ApplicableMethods" Type="ImmutableArray&lt;MethodSymbol&gt;" />
+    <Field Name="WasTargetTyped" Type="bool" PropertyOverrides="true"/>
   </Node>
 
-  <Node Name="BoundNoPiaObjectCreationExpression" Base="BoundExpression">
-    <!-- Non-null type is required for this node kind -->
-    <Field Name="Type" Type="TypeSymbol" Override="true" Null="disallow"/>
+  <Node Name="BoundNoPiaObjectCreationExpression" Base="BoundObjectCreationExpressionBase">
     <Field Name="GuidString" Type="string?"/>
-    <Field Name="InitializerExpressionOpt" Type="BoundObjectInitializerExpressionBase?"/>
+    <Field Name="InitializerExpressionOpt" Type="BoundObjectInitializerExpressionBase?" PropertyOverrides="true"/>
+    <Field Name="WasTargetTyped" Type="bool" PropertyOverrides="true"/>
   </Node>
 
   <AbstractNode Name="BoundObjectInitializerExpressionBase" Base="BoundExpression">
@@ -1945,11 +1948,9 @@
     <Field Name="Property" Type="PropertySymbol" Null="disallow"/>
   </Node>
   
-  <Node Name="BoundNewT" Base="BoundExpression">
-    <!-- Non-null type is required for this node kind -->
-    <Field Name="Type" Type="TypeSymbol" Override="true" Null="disallow"/>
-  
-    <Field Name="InitializerExpressionOpt" Type="BoundObjectInitializerExpressionBase?"/>
+  <Node Name="BoundNewT" Base="BoundObjectCreationExpressionBase">
+    <Field Name="InitializerExpressionOpt" Type="BoundObjectInitializerExpressionBase?" PropertyOverrides="true"/>
+    <Field Name="WasTargetTyped" Type="bool" PropertyOverrides="true"/>
   </Node>
 
   <Node Name="BoundDelegateCreationExpression" Base="BoundExpression">
@@ -1970,6 +1971,7 @@
     <Field Name="Argument" Type="BoundExpression"/>
     <Field Name="MethodOpt" Type="MethodSymbol?"/>
     <Field Name="IsExtensionMethod" Type="bool"/>
+    <Field Name="WasTargetTyped" Type="bool"/>
   </Node>
 
   <Node Name="BoundArrayCreation" Base="BoundExpression">
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundObjectCreationExpressionBase.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundObjectCreationExpressionBase.cs
new file mode 100644
index 0000000000000..68e9bdbdfd80e
--- /dev/null
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundObjectCreationExpressionBase.cs
@@ -0,0 +1,22 @@
+// 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.CSharp.Symbols;
+
+namespace Microsoft.CodeAnalysis.CSharp
+{
+    partial class BoundObjectCreationExpressionBase
+    {
+        public abstract MethodSymbol? Constructor { get; }
+        public abstract ImmutableArray<BoundExpression> Arguments { get; }
+        public abstract ImmutableArray<string> ArgumentNamesOpt { get; }
+        public abstract ImmutableArray<RefKind> ArgumentRefKindsOpt { get; }
+        public abstract bool Expanded { get; }
+        public abstract ImmutableArray<int> ArgsToParamsOpt { get; }
+        public abstract BitVector DefaultArguments { get; }
+        public abstract BoundObjectInitializerExpressionBase? InitializerExpressionOpt { get; }
+        public abstract bool WasTargetTyped { get; }
+    }
+}
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
index 29567c7962c0e..75580eee88add 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
@@ -211,16 +211,18 @@ public VisitArgumentResult(VisitResult visitResult, Optional<LocalState> stateFo
         /// Variables instances for each lambda or local function defined within the analyzed region.
         /// </summary>
         private PooledDictionary<MethodSymbol, Variables>? _nestedFunctionVariables;
-
-        private PooledDictionary<BoundExpression, ImmutableArray<(LocalState State, TypeWithState ResultType, bool EndReachable)>>? _conditionalInfoForConversionOpt;
+#if DEBUG
+        private bool _completingTargetTypedExpression;
+#endif
+        private PooledDictionary<BoundExpression, Func<TypeWithAnnotations, TypeWithState>>? _targetTypedAnalysisCompletionOpt;
 
         /// <summary>
-        /// Map from a target-typed conditional expression (such as a target-typed conditional or switch) to the nullable state on each branch. This
-        /// is then used by VisitConversion to properly set the state before each branch when visiting a conversion applied to such a construct. These
-        /// states will be the state after visiting the underlying arm value, but before visiting the conversion on top of the arm value.
+        /// Map from a target-typed expression (such as a target-typed conditional, switch or new) to the delegate
+        /// that completes analysis once the target type is known.
+        /// The delegate is invoked by <see cref="VisitConversion(BoundConversion, BoundExpression, Conversion, TypeWithAnnotations, TypeWithState, bool, bool, bool, AssignmentKind, ParameterSymbol, bool, bool, bool, Optional&lt;LocalState&gt;,bool, Location, ArrayBuilder&lt;VisitResult&gt;)"/>.
         /// </summary>
-        private PooledDictionary<BoundExpression, ImmutableArray<(LocalState State, TypeWithState ResultType, bool EndReachable)>> ConditionalInfoForConversion
-            => _conditionalInfoForConversionOpt ??= PooledDictionary<BoundExpression, ImmutableArray<(LocalState, TypeWithState, bool)>>.GetInstance();
+        private PooledDictionary<BoundExpression, Func<TypeWithAnnotations, TypeWithState>> TargetTypedAnalysisCompletion
+            => _targetTypedAnalysisCompletionOpt ??= PooledDictionary<BoundExpression, Func<TypeWithAnnotations, TypeWithState>>.GetInstance();
 
         /// <summary>
         /// True if we're analyzing speculative code. This turns off some initialization steps
@@ -269,6 +271,11 @@ private void SetResultType(BoundExpression? expression, TypeWithState type, bool
             SetResult(expression, resultType: type, lvalueType: type.ToTypeWithAnnotations(compilation), updateAnalyzedNullability: updateAnalyzedNullability);
         }
 
+        private void SetAnalyzedNullability(BoundExpression? expression, TypeWithState type)
+        {
+            SetAnalyzedNullability(expression, resultType: type, lvalueType: type.ToTypeWithAnnotations(compilation));
+        }
+
         /// <summary>
         /// Force the inference of the LValueResultType from ResultType.
         /// </summary>
@@ -306,6 +313,11 @@ private void SetResult(BoundExpression? expression, TypeWithState resultType, Ty
             }
         }
 
+        private void SetAnalyzedNullability(BoundExpression? expression, TypeWithState resultType, TypeWithAnnotations lvalueType, bool? isLvalue = null)
+        {
+            SetAnalyzedNullability(expression, new VisitResult(resultType, lvalueType), isLvalue);
+        }
+
         private bool ShouldMakeNotNullRvalue(BoundExpression node) => node.IsSuppressed || node.HasAnyErrors || !IsReachable();
 
         /// <summary>
@@ -390,8 +402,8 @@ protected override void Free()
             _methodGroupReceiverMapOpt?.Free();
             _placeholderLocalsOpt?.Free();
             _variables.Free();
-            Debug.Assert(_conditionalInfoForConversionOpt is null or { Count: 0 });
-            _conditionalInfoForConversionOpt?.Free();
+            Debug.Assert(_targetTypedAnalysisCompletionOpt is null or { Count: 0 });
+            _targetTypedAnalysisCompletionOpt?.Free();
             base.Free();
         }
 
@@ -1757,6 +1769,10 @@ int makeSlot(BoundExpression node)
                                         }
                                     }
                                     break;
+
+                                case ConversionKind.ConditionalExpression or ConversionKind.SwitchExpression or ConversionKind.ObjectCreation when
+                                         IsTargetTypedExpression(conv.Operand) &&
+                                         TypeSymbol.Equals(conv.Type, conv.Operand.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes):
                                 case ConversionKind.Identity:
                                 case ConversionKind.DefaultLiteral:
                                 case ConversionKind.ImplicitReference:
@@ -2805,7 +2821,10 @@ private void AnalyzeLocalFunctionOrLambda(
 
             var oldReturnTypes = _returnTypesOpt;
             _returnTypesOpt = null;
-
+#if DEBUG
+            var oldCompletingTargetTypedExpression = _completingTargetTypedExpression;
+            _completingTargetTypedExpression = false;
+#endif
             var oldState = this.State;
             _variables = GetOrCreateNestedFunctionVariables(_variables, lambdaOrFunctionSymbol);
             this.State = state.CreateNestedMethodState(_variables);
@@ -2851,6 +2870,9 @@ private void AnalyzeLocalFunctionOrLambda(
 
             _variables = _variables.Container!;
             this.State = oldState;
+#if DEBUG
+            _completingTargetTypedExpression = oldCompletingTargetTypedExpression;
+#endif
             _returnTypesOpt = oldReturnTypes;
             _useDelegateInvokeReturnType = oldUseDelegateInvokeReturnType;
             _useDelegateInvokeParameterTypes = oldUseDelegateInvokeParameterTypes;
@@ -2903,14 +2925,14 @@ private void VisitLocalFunctionUse(LocalFunctionSymbol symbol)
             VisitRvalue(receiver);
             _ = CheckPossibleNullReceiver(receiver);
 
-            var resultType = withExpr.CloneMethod?.ReturnTypeWithAnnotations ?? ResultType.ToTypeWithAnnotations(compilation);
+            var resultType = ResultType.ToTypeWithAnnotations(compilation);
             var resultState = ApplyUnconditionalAnnotations(resultType.ToTypeWithState(), GetRValueAnnotations(withExpr.CloneMethod));
             var resultSlot = GetOrCreatePlaceholderSlot(withExpr);
             // carry over the null state of members of 'receiver' to the result of the with-expression.
             TrackNullableStateForAssignment(receiver, resultType, resultSlot, resultState, MakeSlot(receiver));
             // use the declared nullability of Clone() for the top-level nullability of the result of the with-expression.
             SetResult(withExpr, resultState, resultType);
-            VisitObjectCreationInitializer(containingSymbol: null, resultSlot, withExpr.InitializerExpression, FlowAnalysisAnnotations.None);
+            VisitObjectCreationInitializer(resultSlot, resultType.Type, withExpr.InitializerExpression, delayCompletionForType: false);
 
             // Note: this does not account for the scenario where `Clone()` returns maybe-null and the with-expression has no initializers.
             // Tracking in https://github.com/dotnet/roslyn/issues/44759
@@ -3128,6 +3150,9 @@ private BoundNode VisitLValue(BoundNode node)
 
         private BoundNode Visit(BoundNode? node, bool expressionIsRead)
         {
+#if DEBUG
+            Debug.Assert(!_completingTargetTypedExpression);
+#endif
             bool originalExpressionIsRead = _expressionIsRead;
             _expressionIsRead = expressionIsRead;
 
@@ -3147,10 +3172,7 @@ protected override void VisitStatement(BoundStatement statement)
 
         public override BoundNode? VisitObjectCreationExpression(BoundObjectCreationExpression node)
         {
-            Debug.Assert(!IsConditionalState);
-            var arguments = node.Arguments;
-            var argumentResults = VisitArguments(node, arguments, node.ArgumentRefKindsOpt, node.Constructor, node.ArgsToParamsOpt, node.DefaultArguments, node.Expanded, invokedAsExtensionMethod: false).results;
-            VisitObjectOrDynamicObjectCreation(node, arguments, argumentResults, node.InitializerExpressionOpt);
+            VisitObjectCreationExpressionBase(node);
             return null;
         }
 
@@ -3162,93 +3184,209 @@ protected override void VisitStatement(BoundStatement statement)
             return null;
         }
 
-        private void VisitObjectOrDynamicObjectCreation(
-            BoundExpression node,
-            ImmutableArray<BoundExpression> arguments,
-            ImmutableArray<VisitArgumentResult> argumentResults,
-            BoundExpression? initializerOpt)
+        private void VisitObjectCreationExpressionBase(BoundObjectCreationExpressionBase node)
         {
-            Debug.Assert(node.Kind is BoundKind.ObjectCreationExpression or BoundKind.DynamicObjectCreationExpression or BoundKind.NewT or BoundKind.NoPiaObjectCreationExpression);
+            Debug.Assert(!IsConditionalState);
+            bool isTargetTyped = node.WasTargetTyped;
+            MethodSymbol? constructor = getConstructor(node, node.Type);
+            var arguments = node.Arguments;
 
-            var argumentTypes = argumentResults.SelectAsArray(ar => ar.RValueType);
+            (_, ImmutableArray<VisitArgumentResult> argumentResults, _, ArgumentsCompletionDelegate? argumentsCompletion) =
+                VisitArguments(
+                           node, arguments, node.ArgumentRefKindsOpt, constructor?.Parameters ?? default,
+                           node.ArgsToParamsOpt, node.DefaultArguments, node.Expanded, invokedAsExtensionMethod: false,
+                           constructor, delayCompletionForTargetMember: isTargetTyped);
+            Debug.Assert(isTargetTyped == argumentsCompletion is not null);
 
-            int slot = -1;
             var type = node.Type;
-            var resultState = NullableFlowState.NotNull;
-            if (type is object)
+            (int slot, NullableFlowState resultState, Func<TypeSymbol, MethodSymbol?, int>? initialStateInferenceCompletion) = inferInitialObjectState(node, type, constructor, arguments, argumentResults, isTargetTyped);
+
+            Action<int, TypeSymbol>? initializerCompletion = null;
+            var initializerOpt = node.InitializerExpressionOpt;
+            if (initializerOpt != null)
             {
-                slot = GetOrCreatePlaceholderSlot(node);
-                if (slot > 0)
+                initializerCompletion = VisitObjectCreationInitializer(slot, type, initializerOpt, delayCompletionForType: isTargetTyped);
+            }
+
+            TypeWithState result = setAnalyzedNullability(node, type, argumentResults, argumentsCompletion, initialStateInferenceCompletion, initializerCompletion, resultState, isTargetTyped);
+            SetResultType(node, result, updateAnalyzedNullability: false);
+            return;
+
+            TypeWithState setAnalyzedNullability(
+                BoundObjectCreationExpressionBase node,
+                TypeSymbol? type,
+                ImmutableArray<VisitArgumentResult> argumentResults,
+                ArgumentsCompletionDelegate? argumentsCompletion,
+                Func<TypeSymbol, MethodSymbol?, int>? initialStateInferenceCompletion,
+                Action<int, TypeSymbol>? initializerCompletion,
+                NullableFlowState resultState,
+                bool isTargetTyped)
+            {
+                var result = TypeWithState.Create(type, resultState);
+
+                if (isTargetTyped)
                 {
-                    var boundObjectCreationExpression = node as BoundObjectCreationExpression;
-                    var constructor = boundObjectCreationExpression?.Constructor;
-                    bool isDefaultValueTypeConstructor = constructor?.IsDefaultValueTypeConstructor(requireZeroInit: true) == true;
+                    Debug.Assert(argumentsCompletion is not null);
+                    Debug.Assert(initialStateInferenceCompletion is not null);
+                    setAnalyzedNullabilityAsContinuation(node, argumentResults, argumentsCompletion, initialStateInferenceCompletion, initializerCompletion, resultState);
+                }
+                else
+                {
+                    Debug.Assert(argumentsCompletion is null);
+                    Debug.Assert(initialStateInferenceCompletion is null);
+                    Debug.Assert(initializerCompletion is null);
+
+                    SetAnalyzedNullability(node, result);
+                }
+
+                return result;
+            }
 
-                    if (EmptyStructTypeCache.IsTrackableStructType(type))
+            void setAnalyzedNullabilityAsContinuation(
+                BoundObjectCreationExpressionBase node,
+                ImmutableArray<VisitArgumentResult> argumentResults,
+                ArgumentsCompletionDelegate argumentsCompletion,
+                Func<TypeSymbol, MethodSymbol?, int> initialStateInferenceCompletion,
+                Action<int, TypeSymbol>? initializerCompletion,
+                NullableFlowState resultState)
+            {
+                Debug.Assert(resultState == NullableFlowState.NotNull);
+
+                TargetTypedAnalysisCompletion[node] =
+                    (TypeWithAnnotations resultTypeWithAnnotations) =>
                     {
-                        var containingType = constructor?.ContainingType;
-                        if (containingType?.IsTupleType == true && !isDefaultValueTypeConstructor)
-                        {
-                            // new System.ValueTuple<T1, ..., TN>(e1, ..., eN)
-                            TrackNullableStateOfTupleElements(slot, containingType, arguments, argumentTypes, boundObjectCreationExpression!.ArgsToParamsOpt, useRestField: true);
-                        }
-                        else
-                        {
-                            InheritNullableStateOfTrackableStruct(
-                                type,
-                                slot,
-                                valueSlot: -1,
-                                isDefaultValue: isDefaultValueTypeConstructor);
-                        }
-                    }
-                    else if (type.IsNullableType())
+                        Debug.Assert(TypeSymbol.Equals(resultTypeWithAnnotations.Type, node.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes));
+
+                        var arguments = node.Arguments;
+                        var type = resultTypeWithAnnotations.Type;
+                        MethodSymbol? constructor = getConstructor(node, type);
+
+                        argumentsCompletion(argumentResults, constructor?.Parameters ?? default, constructor);
+                        int slot = initialStateInferenceCompletion(type, constructor);
+                        initializerCompletion?.Invoke(slot, type);
+
+                        return setAnalyzedNullability(
+                                   node, type, argumentResults,
+                                   argumentsCompletion: null, initialStateInferenceCompletion: null, initializerCompletion: null, resultState, isTargetTyped: false);
+                    };
+            }
+
+            static MethodSymbol? getConstructor(BoundObjectCreationExpressionBase node, TypeSymbol type)
+            {
+                var constructor = node.Constructor;
+
+                if (constructor is not null && !type.IsInterfaceType())
+                {
+                    constructor = (MethodSymbol)AsMemberOfType(type, constructor);
+                }
+
+                return constructor;
+            }
+
+            (int slot, NullableFlowState resultState, Func<TypeSymbol, MethodSymbol?, int>? completion) inferInitialObjectState(
+                BoundExpression node, TypeSymbol type, MethodSymbol? constructor,
+                ImmutableArray<BoundExpression> arguments, ImmutableArray<VisitArgumentResult> argumentResults,
+                bool isTargetTyped)
+            {
+                if (isTargetTyped)
+                {
+                    return (-1, NullableFlowState.NotNull, inferInitialObjectStateAsContinuation(node, arguments, argumentResults));
+                }
+
+                Debug.Assert(node.Kind is BoundKind.ObjectCreationExpression or BoundKind.DynamicObjectCreationExpression or BoundKind.NewT or BoundKind.NoPiaObjectCreationExpression);
+
+                var argumentTypes = argumentResults.SelectAsArray(ar => ar.RValueType);
+
+                int slot = -1;
+                var resultState = NullableFlowState.NotNull;
+                if (type is object)
+                {
+                    slot = GetOrCreatePlaceholderSlot(node);
+                    if (slot > 0)
                     {
-                        if (isDefaultValueTypeConstructor)
+                        bool isDefaultValueTypeConstructor = constructor?.IsDefaultValueTypeConstructor(requireZeroInit: true) == true;
+
+                        if (EmptyStructTypeCache.IsTrackableStructType(type))
                         {
-                            // a nullable value type created with its default constructor is by definition null
-                            resultState = NullableFlowState.MaybeNull;
+                            var containingType = constructor?.ContainingType;
+                            if (containingType?.IsTupleType == true && !isDefaultValueTypeConstructor)
+                            {
+                                // new System.ValueTuple<T1, ..., TN>(e1, ..., eN)
+                                TrackNullableStateOfTupleElements(slot, containingType, arguments, argumentTypes, ((BoundObjectCreationExpression)node).ArgsToParamsOpt, useRestField: true);
+                            }
+                            else
+                            {
+                                InheritNullableStateOfTrackableStruct(
+                                    type,
+                                    slot,
+                                    valueSlot: -1,
+                                    isDefaultValue: isDefaultValueTypeConstructor);
+                            }
                         }
-                        else if (constructor?.ParameterCount == 1)
+                        else if (type.IsNullableType())
                         {
-                            // if we deal with one-parameter ctor that takes underlying, then Value state is inferred from the argument.
-                            var parameterType = constructor.ParameterTypesWithAnnotations[0];
-                            if (AreNullableAndUnderlyingTypes(type, parameterType.Type, out TypeWithAnnotations underlyingType))
+                            if (isDefaultValueTypeConstructor)
                             {
-                                var operand = arguments[0];
-                                int valueSlot = MakeSlot(operand);
-                                if (valueSlot > 0)
+                                // a nullable value type created with its default constructor is by definition null
+                                resultState = NullableFlowState.MaybeNull;
+                            }
+                            else if (constructor?.ParameterCount == 1)
+                            {
+                                // if we deal with one-parameter ctor that takes underlying, then Value state is inferred from the argument.
+                                var parameterType = constructor.ParameterTypesWithAnnotations[0];
+                                if (AreNullableAndUnderlyingTypes(type, parameterType.Type, out TypeWithAnnotations underlyingType))
                                 {
-                                    TrackNullableStateOfNullableValue(slot, type, operand, underlyingType.ToTypeWithState(), valueSlot);
+                                    var operand = arguments[0];
+                                    int valueSlot = MakeSlot(operand);
+                                    if (valueSlot > 0)
+                                    {
+                                        TrackNullableStateOfNullableValue(slot, type, operand, underlyingType.ToTypeWithState(), valueSlot);
+                                    }
                                 }
                             }
                         }
-                    }
 
-                    this.State[slot] = resultState;
+                        this.State[slot] = resultState;
+                    }
                 }
+
+                return (slot, resultState, null);
             }
 
-            if (initializerOpt != null)
+            Func<TypeSymbol, MethodSymbol?, int> inferInitialObjectStateAsContinuation(
+                BoundExpression node,
+                ImmutableArray<BoundExpression> arguments,
+                ImmutableArray<VisitArgumentResult> argumentResults)
             {
-                VisitObjectCreationInitializer(containingSymbol: null, slot, initializerOpt, leftAnnotations: FlowAnalysisAnnotations.None);
+                return (TypeSymbol type, MethodSymbol? constructor) =>
+                {
+                    var (slot, resultState, completion) = inferInitialObjectState(node, type, constructor, arguments, argumentResults, isTargetTyped: false);
+                    Debug.Assert(completion is null);
+                    Debug.Assert(resultState == NullableFlowState.NotNull);
+                    return slot;
+                };
             }
-
-            SetResultType(node, TypeWithState.Create(type, resultState));
         }
 
-        private void VisitObjectCreationInitializer(Symbol? containingSymbol, int containingSlot, BoundExpression node, FlowAnalysisAnnotations leftAnnotations)
+        /// <summary>
+        /// If <paramref name="delayCompletionForType"/>, <paramref name="containingSlot"/> is known only within returned delegate.
+        /// </summary>
+        /// <returns>A delegate to complete the initializer analysis.</returns>
+        private Action<int, TypeSymbol>? VisitObjectCreationInitializer(int containingSlot, TypeSymbol containingType, BoundObjectInitializerExpressionBase node, bool delayCompletionForType)
         {
+            Debug.Assert(!delayCompletionForType || containingSlot == -1);
+            Action<int, TypeSymbol>? completion = null;
+
             TakeIncrementalSnapshot(node);
             switch (node)
             {
                 case BoundObjectInitializerExpression objectInitializer:
-                    checkImplicitReceiver(objectInitializer);
                     foreach (var initializer in objectInitializer.Initializers)
                     {
                         switch (initializer.Kind)
                         {
                             case BoundKind.AssignmentOperator:
-                                VisitObjectElementInitializer(containingSlot, (BoundAssignmentOperator)initializer);
+                                completion += VisitObjectElementInitializer(containingSlot, containingType, (BoundAssignmentOperator)initializer, delayCompletionForType);
                                 break;
                             default:
                                 VisitRvalue(initializer);
@@ -3258,13 +3396,12 @@ private void VisitObjectCreationInitializer(Symbol? containingSymbol, int contai
                     SetNotNullResult(objectInitializer.Placeholder);
                     break;
                 case BoundCollectionInitializerExpression collectionInitializer:
-                    checkImplicitReceiver(collectionInitializer);
                     foreach (var initializer in collectionInitializer.Initializers)
                     {
                         switch (initializer.Kind)
                         {
                             case BoundKind.CollectionElementInitializer:
-                                VisitCollectionElementInitializer((BoundCollectionElementInitializer)initializer);
+                                completion += VisitCollectionElementInitializer((BoundCollectionElementInitializer)initializer, containingType, delayCompletionForType);
                                 break;
                             default:
                                 VisitRvalue(initializer);
@@ -3274,93 +3411,330 @@ private void VisitObjectCreationInitializer(Symbol? containingSymbol, int contai
                     SetNotNullResult(collectionInitializer.Placeholder);
                     break;
                 default:
-                    Debug.Assert(containingSymbol is object);
-                    if (containingSymbol is object)
-                    {
-                        var type = ApplyLValueAnnotations(containingSymbol.GetTypeOrReturnType(), leftAnnotations);
-                        TypeWithState resultType = VisitOptionalImplicitConversion(node, type, useLegacyWarnings: false, trackMembers: true, AssignmentKind.Assignment);
-                        TrackNullableStateForAssignment(node, type, containingSlot, resultType, MakeSlot(node));
-                    }
+                    ExceptionUtilities.UnexpectedValue(node.Kind);
                     break;
             }
 
-            void checkImplicitReceiver(BoundObjectInitializerExpressionBase node)
-            {
-                if (containingSlot >= 0 && !node.Initializers.IsEmpty)
-                {
-                    if (!node.Type.IsValueType && State[containingSlot].MayBeNull())
-                    {
-                        if (containingSymbol is null)
-                        {
-                            ReportDiagnostic(ErrorCode.WRN_NullReferenceReceiver, node.Syntax);
-                        }
-                        else
-                        {
-                            ReportDiagnostic(ErrorCode.WRN_NullReferenceInitializer, node.Syntax, containingSymbol);
-                        }
-                    }
-                }
-            }
+            return completion;
         }
 
-        private void VisitObjectElementInitializer(int containingSlot, BoundAssignmentOperator node)
+        /// <summary>
+        /// If <paramref name="delayCompletionForType"/>, <paramref name="containingSlot"/> is known only within returned delegate.
+        /// </summary>
+        /// <returns>A delegate to complete the element initializer analysis.</returns>
+        private Action<int, TypeSymbol>? VisitObjectElementInitializer(int containingSlot, TypeSymbol containingType, BoundAssignmentOperator node, bool delayCompletionForType)
         {
+            Debug.Assert(!delayCompletionForType || containingSlot == -1);
+
             TakeIncrementalSnapshot(node);
             var left = node.Left;
             switch (left.Kind)
             {
                 case BoundKind.ObjectInitializerMember:
                     {
-                        var objectInitializer = (BoundObjectInitializerMember)left;
                         TakeIncrementalSnapshot(left);
-                        var symbol = objectInitializer.MemberSymbol;
-                        if (!objectInitializer.Arguments.IsDefaultOrEmpty)
-                        {
-                            // It is an error for an interpolated string to use the receiver of an object initializer indexer here, so we just use
-                            // a default visit result
-                            VisitArguments(objectInitializer, objectInitializer.Arguments, objectInitializer.ArgumentRefKindsOpt, (PropertySymbol?)symbol, objectInitializer.ArgsToParamsOpt, objectInitializer.DefaultArguments, objectInitializer.Expanded);
-                        }
+                        return visitMemberInitializer(containingSlot, containingType, node, delayCompletionForType);
+                    }
 
-                        if (symbol is object)
-                        {
-                            int slot = (containingSlot < 0 || !IsSlotMember(containingSlot, symbol)) ? -1 : GetOrCreateSlot(symbol, containingSlot);
-                            VisitObjectCreationInitializer(symbol, slot, node.Right, GetLValueAnnotations(node.Left));
-                            // https://github.com/dotnet/roslyn/issues/35040: Should likely be setting _resultType in VisitObjectCreationInitializer
-                            // and using that value instead of reconstructing here
-                        }
+                default:
+                    VisitRvalue(node);
+                    return null;
+            }
+
+            Action<int, TypeSymbol>? visitMemberInitializer(int containingSlot, TypeSymbol containingType, BoundAssignmentOperator node, bool delayCompletionForType)
+            {
+                var objectInitializer = (BoundObjectInitializerMember)node.Left;
+                Symbol? symbol = getTargetMember(containingType, objectInitializer);
+
+                ImmutableArray<VisitArgumentResult> argumentResults = default;
+                ArgumentsCompletionDelegate? argumentsCompletion = null;
+                if (!objectInitializer.Arguments.IsDefaultOrEmpty)
+                {
+                    // It is an error for an interpolated string to use the receiver of an object initializer indexer here, so we just use
+                    // a default visit result
+                    (_, argumentResults, _, argumentsCompletion) =
+                        VisitArguments(
+                            objectInitializer, objectInitializer.Arguments, objectInitializer.ArgumentRefKindsOpt,
+                            ((PropertySymbol?)symbol)?.Parameters ?? default, objectInitializer.ArgsToParamsOpt,
+                            objectInitializer.DefaultArguments, objectInitializer.Expanded,
+                            invokedAsExtensionMethod: false, method: null, delayCompletionForTargetMember: delayCompletionForType);
+                }
 
-                        var result = new VisitResult(objectInitializer.Type, NullableAnnotation.NotAnnotated, NullableFlowState.NotNull);
-                        SetAnalyzedNullability(objectInitializer, result);
-                        SetAnalyzedNullability(node, result);
+                Action<int, Symbol>? initializationCompletion = null;
+
+                if (symbol is object)
+                {
+                    if (node.Right is BoundObjectInitializerExpressionBase initializer)
+                    {
+                        initializationCompletion = visitNestedInitializer(containingSlot, containingType, symbol, initializer, delayCompletionForType);
                     }
-                    break;
-                default:
-                    Visit(node);
-                    break;
+                    else
+                    {
+                        TakeIncrementalSnapshot(node.Right);
+                        initializationCompletion = visitMemberAssignment(node, containingSlot, symbol, delayCompletionForType);
+                    }
+                    // https://github.com/dotnet/roslyn/issues/35040: Should likely be setting _resultType in VisitObjectCreationInitializer
+                    // and using that value instead of reconstructing here
+                }
+
+                return setAnalyzedNullability(node, argumentResults, argumentsCompletion, initializationCompletion, delayCompletionForType);
+            }
+
+            Action<int, TypeSymbol>? setAnalyzedNullability(
+                BoundAssignmentOperator node,
+                ImmutableArray<VisitArgumentResult> argumentResults,
+                ArgumentsCompletionDelegate? argumentsCompletion,
+                Action<int, Symbol>? initializationCompletion,
+                bool delayCompletionForType)
+            {
+                if (delayCompletionForType)
+                {
+                    return setAnalyzedNullabilityAsContinuation(node, argumentResults, argumentsCompletion, initializationCompletion);
+                }
+
+                Debug.Assert(argumentsCompletion is null);
+                Debug.Assert(initializationCompletion is null);
+                var objectInitializer = (BoundObjectInitializerMember)node.Left;
+
+                var result = new VisitResult(objectInitializer.Type, NullableAnnotation.NotAnnotated, NullableFlowState.NotNull);
+                SetAnalyzedNullability(objectInitializer, result);
+                SetAnalyzedNullability(node, result);
+                return null;
+            }
+
+            Action<int, TypeSymbol>? setAnalyzedNullabilityAsContinuation(
+                BoundAssignmentOperator node,
+                ImmutableArray<VisitArgumentResult> argumentResults,
+                ArgumentsCompletionDelegate? argumentsCompletion,
+                Action<int, Symbol>? initializationCompletion)
+            {
+                return (int containingSlot, TypeSymbol containingType) =>
+                {
+                    Symbol? symbol = getTargetMember(containingType, (BoundObjectInitializerMember)node.Left);
+
+                    Debug.Assert(initializationCompletion is null || symbol is not null);
+
+                    argumentsCompletion?.Invoke(argumentResults, ((PropertySymbol?)symbol)?.Parameters ?? default, null);
+                    initializationCompletion?.Invoke(containingSlot, symbol!);
+
+                    var result = setAnalyzedNullability(node, argumentResults, argumentsCompletion: null, initializationCompletion: null, delayCompletionForType: false);
+                    Debug.Assert(result is null);
+                };
+            }
+
+            static Symbol? getTargetMember(TypeSymbol containingType, BoundObjectInitializerMember objectInitializer)
+            {
+                var symbol = objectInitializer.MemberSymbol;
+
+                if (symbol != null)
+                {
+                    Debug.Assert(TypeSymbol.Equals(objectInitializer.Type, symbol.GetTypeOrReturnType().Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes));
+                    symbol = AsMemberOfType(containingType, symbol);
+                }
+
+                return symbol;
+            }
+
+            int getOrCreateSlot(int containingSlot, Symbol symbol)
+            {
+                return (containingSlot < 0 || !IsSlotMember(containingSlot, symbol)) ? -1 : GetOrCreateSlot(symbol, containingSlot);
+            }
+
+            Action<int, Symbol>? visitNestedInitializer(int containingSlot, TypeSymbol containingType, Symbol symbol, BoundObjectInitializerExpressionBase initializer, bool delayCompletionForType)
+            {
+                int slot = getOrCreateSlot(containingSlot, symbol);
+                Debug.Assert(!delayCompletionForType || slot == -1);
+
+                Action<int, TypeSymbol>? nestedCompletion = VisitObjectCreationInitializer(slot, symbol.GetTypeOrReturnType().Type, initializer, delayCompletionForType);
+
+                return completeNestedInitializerAnalysis(symbol, initializer, slot, nestedCompletion, delayCompletionForType);
+            }
+
+            Action<int, Symbol>? completeNestedInitializerAnalysis(
+                Symbol symbol, BoundObjectInitializerExpressionBase initializer, int slot, Action<int, TypeSymbol>? nestedCompletion,
+                bool delayCompletionForType)
+            {
+                if (delayCompletionForType)
+                {
+                    return completeNestedInitializerAnalysisAsContinuation(initializer, nestedCompletion);
+                }
+
+                Debug.Assert(nestedCompletion is null);
+
+                if (slot >= 0 && !initializer.Initializers.IsEmpty)
+                {
+                    if (!initializer.Type.IsValueType && State[slot].MayBeNull())
+                    {
+                        ReportDiagnostic(ErrorCode.WRN_NullReferenceInitializer, initializer.Syntax, symbol);
+                    }
+                }
+
+                return null;
+            }
+
+            Action<int, Symbol>? completeNestedInitializerAnalysisAsContinuation(BoundObjectInitializerExpressionBase initializer, Action<int, TypeSymbol>? nestedCompletion)
+            {
+                return (int containingSlot, Symbol symbol) =>
+                {
+                    int slot = getOrCreateSlot(containingSlot, symbol);
+                    completeNestedInitializerAnalysis(symbol, initializer, slot, nestedCompletion: null, delayCompletionForType: false);
+                    nestedCompletion?.Invoke(slot, symbol.GetTypeOrReturnType().Type);
+                };
+            }
+
+            Action<int, Symbol>? visitMemberAssignment(BoundAssignmentOperator node, int containingSlot, Symbol symbol, bool delayCompletionForType, Func<TypeWithAnnotations, TypeWithState>? conversionCompletion = null)
+            {
+                Debug.Assert(!delayCompletionForType || conversionCompletion is null);
+
+                if (!delayCompletionForType && conversionCompletion is null)
+                {
+                    TakeIncrementalSnapshot(node.Right);
+                }
+
+                Debug.Assert(symbol.GetTypeOrReturnType().HasType);
+
+                var type = ApplyLValueAnnotations(symbol.GetTypeOrReturnType(), GetObjectInitializerMemberLValueAnnotations(symbol));
+
+                (TypeWithState resultType, conversionCompletion) =
+                    conversionCompletion is not null ?
+                        (conversionCompletion(type), null) :
+                        VisitOptionalImplicitConversion(node.Right, type, useLegacyWarnings: false, trackMembers: true, AssignmentKind.Assignment, delayCompletionForType);
+
+                if (delayCompletionForType)
+                {
+                    Debug.Assert(conversionCompletion is not null);
+                    return visitMemberAssignmentAsContinuation(node, conversionCompletion);
+                }
+
+                Debug.Assert(conversionCompletion is null);
+
+                int slot = getOrCreateSlot(containingSlot, symbol);
+                TrackNullableStateForAssignment(node.Right, type, slot, resultType, MakeSlot(node.Right));
+
+                return null;
+            }
+
+            Action<int, Symbol>? visitMemberAssignmentAsContinuation(BoundAssignmentOperator node, Func<TypeWithAnnotations, TypeWithState> conversionCompletion)
+            {
+                return (int containingSlot, Symbol symbol) =>
+                {
+                    var result = visitMemberAssignment(node, containingSlot, symbol, delayCompletionForType: false, conversionCompletion);
+                    Debug.Assert(result is null);
+                };
             }
         }
 
+        [Obsolete("Use VisitCollectionElementInitializer(BoundCollectionElementInitializer node, TypeSymbol containingType, bool delayCompletionForType) instead.", true)]
         private new void VisitCollectionElementInitializer(BoundCollectionElementInitializer node)
         {
+            throw ExceptionUtilities.Unreachable;
+        }
+
+        private Action<int, TypeSymbol>? VisitCollectionElementInitializer(BoundCollectionElementInitializer node, TypeSymbol containingType, bool delayCompletionForType)
+        {
+            ImmutableArray<VisitArgumentResult> argumentResults = default;
+            MethodSymbol addMethod = addMethodAsMemberOfContainingType(node, containingType, ref argumentResults);
+
             // Note: we analyze even omitted calls
-            (var reinferredMethod, _, _) = VisitArguments(
-                node,
-                node.Arguments,
-                refKindsOpt: default,
-                node.AddMethod,
-                node.ArgsToParamsOpt,
-                node.DefaultArguments,
-                node.Expanded,
-                node.InvokedAsExtensionMethod);
+            (MethodSymbol? reinferredMethod,
+             argumentResults,
+             _,
+             ArgumentsCompletionDelegate? visitArgumentsCompletion) =
+                VisitArguments(
+                    node,
+                    node.Arguments,
+                    refKindsOpt: default,
+                    addMethod.Parameters,
+                    node.ArgsToParamsOpt,
+                    node.DefaultArguments,
+                    node.Expanded,
+                    node.InvokedAsExtensionMethod,
+                    addMethod,
+                    delayCompletionForTargetMember: delayCompletionForType);
 
-            Debug.Assert(reinferredMethod is object);
-            if (node.ImplicitReceiverOpt != null)
+#if DEBUG
+            if (node.InvokedAsExtensionMethod)
             {
-                Debug.Assert(node.ImplicitReceiverOpt.Kind == BoundKind.ObjectOrCollectionValuePlaceholder);
-                SetAnalyzedNullability(node.ImplicitReceiverOpt, new VisitResult(node.ImplicitReceiverOpt.Type, NullableAnnotation.NotAnnotated, NullableFlowState.NotNull));
+                VisitArgumentResult receiverResult = argumentResults[0];
+                Debug.Assert(TypeSymbol.Equals(containingType, receiverResult.VisitResult.RValueType.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes));
+                Debug.Assert(TypeSymbol.Equals(containingType, receiverResult.LValueType.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes));
+            }
+#endif 
+
+            return setUpdatedSymbol(node, containingType, reinferredMethod, argumentResults, visitArgumentsCompletion, delayCompletionForType);
+
+            Action<int, TypeSymbol>? setUpdatedSymbol(
+                BoundCollectionElementInitializer node,
+                TypeSymbol containingType,
+                MethodSymbol? reinferredMethod,
+                ImmutableArray<VisitArgumentResult> argumentResults,
+                ArgumentsCompletionDelegate? visitArgumentsCompletion,
+                bool delayCompletionForType)
+            {
+                if (delayCompletionForType)
+                {
+                    Debug.Assert(visitArgumentsCompletion is not null);
+                    return setUpdatedSymbolAsContinuation(node, argumentResults, visitArgumentsCompletion);
+                }
+
+                Debug.Assert(visitArgumentsCompletion is null);
+                Debug.Assert(reinferredMethod is object);
+                if (node.ImplicitReceiverOpt != null)
+                {
+                    Debug.Assert(node.ImplicitReceiverOpt.Kind == BoundKind.ObjectOrCollectionValuePlaceholder);
+                    SetAnalyzedNullability(node.ImplicitReceiverOpt, new VisitResult(node.ImplicitReceiverOpt.Type, NullableAnnotation.NotAnnotated, NullableFlowState.NotNull));
+                }
+                SetUnknownResultNullability(node);
+                SetUpdatedSymbol(node, node.AddMethod, reinferredMethod);
+
+                return null;
+            }
+
+            Action<int, TypeSymbol>? setUpdatedSymbolAsContinuation(
+                BoundCollectionElementInitializer node,
+                ImmutableArray<VisitArgumentResult> argumentResults,
+                ArgumentsCompletionDelegate visitArgumentsCompletion)
+            {
+                return (int containingSlot, TypeSymbol containingType) =>
+                {
+                    MethodSymbol addMethod = addMethodAsMemberOfContainingType(node, containingType, ref argumentResults);
+
+                    setUpdatedSymbol(
+                        node, containingType, visitArgumentsCompletion.Invoke(argumentResults, addMethod.Parameters, addMethod).method,
+                        argumentResults, visitArgumentsCompletion: null, delayCompletionForType: false);
+                };
+            }
+
+            static MethodSymbol addMethodAsMemberOfContainingType(BoundCollectionElementInitializer node, TypeSymbol containingType, ref ImmutableArray<VisitArgumentResult> argumentResults)
+            {
+                var method = node.AddMethod;
+
+                if (node.InvokedAsExtensionMethod)
+                {
+                    if (!argumentResults.IsDefault)
+                    {
+                        VisitArgumentResult receiverResult = argumentResults[0];
+                        Debug.Assert(TypeSymbol.Equals(containingType, receiverResult.VisitResult.RValueType.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes));
+                        Debug.Assert(TypeSymbol.Equals(containingType, receiverResult.LValueType.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes));
+
+                        var builder = ArrayBuilder<VisitArgumentResult>.GetInstance(argumentResults.Length);
+                        builder.Add(
+                            new VisitArgumentResult(
+                                new VisitResult(
+                                    TypeWithState.Create(containingType, receiverResult.RValueType.State), receiverResult.LValueType.WithType(containingType)),
+                                receiverResult.StateForLambda));
+
+                        builder.AddRange(argumentResults, 1, argumentResults.Length - 1);
+                        argumentResults = builder.ToImmutableAndFree();
+                    }
+                }
+                else
+                {
+                    method = (MethodSymbol)AsMemberOfType(containingType, method);
+                }
+
+                return method;
             }
-            SetUnknownResultNullability(node);
-            SetUpdatedSymbol(node, node.AddMethod, reinferredMethod);
         }
 
         private void SetNotNullResult(BoundExpression node)
@@ -3539,7 +3913,11 @@ private int GetOrCreatePlaceholderSlot(object identifier, TypeWithAnnotations ty
                     SnapshotWalkerThroughConversionGroup(expression, expressionNoConversion);
                     var resultType = VisitRvalueWithState(expressionNoConversion);
                     resultTypes.Add(resultType);
-                    placeholderBuilder.Add(CreatePlaceholderIfNecessary(expressionNoConversion, resultType.ToTypeWithAnnotations(compilation)));
+
+                    if (!IsTargetTypedExpression(expressionNoConversion))
+                    {
+                        placeholderBuilder.Add(CreatePlaceholderIfNecessary(expressionNoConversion, resultType.ToTypeWithAnnotations(compilation)));
+                    }
                 }
 
                 var placeholders = placeholderBuilder.ToImmutableAndFree();
@@ -3599,6 +3977,14 @@ private int GetOrCreatePlaceholderSlot(object identifier, TypeWithAnnotations ty
             return null;
         }
 
+        private static bool IsTargetTypedExpression(BoundExpression node)
+        {
+            return node is BoundConditionalOperator { WasTargetTyped: true } or
+                           BoundConvertedSwitchExpression { WasTargetTyped: true } or
+                           BoundObjectCreationExpressionBase { WasTargetTyped: true } or
+                           BoundDelegateCreationExpression { WasTargetTyped: true };
+        }
+
         /// <summary>
         /// Applies analysis similar to <see cref="VisitArrayCreation"/>.
         /// The expressions returned from a lambda are not converted though, so we'll have to classify fresh conversions.
@@ -3963,12 +4349,9 @@ private void ReinferBinaryOperatorAndSetResult(
                 bool isLifted = binary.OperatorKind.IsLifted();
                 TypeWithState leftUnderlyingType = GetNullableUnderlyingTypeIfNecessary(isLifted, leftType);
                 TypeWithState rightUnderlyingType = GetNullableUnderlyingTypeIfNecessary(isLifted, rightType);
-                TypeSymbol? asMemberOfType = getTypeIfContainingType(methodContainer, leftUnderlyingType.Type) ??
-                    getTypeIfContainingType(methodContainer, rightUnderlyingType.Type);
-                if (asMemberOfType is object)
-                {
-                    method = (MethodSymbol)AsMemberOfType(asMemberOfType, method);
-                }
+                TypeSymbol asMemberOfType = getTypeIfContainingType(methodContainer, leftUnderlyingType.Type, leftOperand) ??
+                    getTypeIfContainingType(methodContainer, rightUnderlyingType.Type, rightOperand) ?? methodContainer;
+                method = (MethodSymbol)AsMemberOfType(asMemberOfType, method);
 
                 // Analyze operator call properly (honoring [Disallow|Allow|Maybe|NotNull] attribute annotations) https://github.com/dotnet/roslyn/issues/32671
                 var parameters = method.Parameters;
@@ -4041,9 +4424,9 @@ void visitOperandConversion(
             var inferredResult = InferResultNullability(binary.OperatorKind, method, binary.Type, leftType, rightType);
             SetResult(binary, inferredResult, inferredResult.ToTypeWithAnnotations(compilation));
 
-            TypeSymbol? getTypeIfContainingType(TypeSymbol baseType, TypeSymbol? derivedType)
+            TypeSymbol? getTypeIfContainingType(TypeSymbol baseType, TypeSymbol? derivedType, BoundExpression operand)
             {
-                if (derivedType is null)
+                if (derivedType is null || IsTargetTypedExpression(operand))
                 {
                     return null;
                 }
@@ -4787,23 +5170,45 @@ void makeAndAdjustReceiverSlot(BoundExpression receiver)
 
             resultType ??= node.Type?.SetUnknownNullabilityForReferenceTypes();
 
-            NullableFlowState resultState;
-            if (!wasTargetTyped)
+            TypeWithAnnotations resultTypeWithAnnotations;
+
+            if (resultType is null)
             {
-                if (resultType is null)
+                if (!wasTargetTyped)
                 {
                     // This can happen when we're inferring the return type of a lambda. For this case, we don't need to do any work,
                     // the unconverted conditional operator can't contribute info. The conversion that should be on top of this
                     // can add or remove nullability, and nested nodes aren't being publicly exposed by the semantic model.
                     Debug.Assert(node is BoundUnconvertedConditionalOperator);
                     Debug.Assert(_returnTypesOpt is not null);
-                    resultState = default;
+                    SetResultType(node, TypeWithState.Create(resultType, default));
+                    return null;
                 }
-                else
-                {
-                    var resultTypeWithAnnotations = TypeWithAnnotations.Create(resultType);
 
-                    TypeWithState convertedConsequenceResult = ConvertConditionalOperandOrSwitchExpressionArmResult(
+                resultTypeWithAnnotations = default;
+            }
+            else
+            {
+                resultTypeWithAnnotations = TypeWithAnnotations.Create(resultType);
+            }
+
+
+            TypeWithState typeWithState = convertArms(
+                                                node, originalConsequence, originalAlternative, consequenceState, alternativeState, consequenceRValue, alternativeRValue,
+                                                consequence, consequenceConversion, consequenceEndReachable, alternative, alternativeConversion, alternativeEndReachable,
+                                                resultTypeWithAnnotations, wasTargetTyped);
+            SetResultType(node, typeWithState, updateAnalyzedNullability: false);
+            return null;
+
+            TypeWithState convertArms(
+                BoundExpression node, BoundExpression originalConsequence, BoundExpression originalAlternative, LocalState consequenceState, LocalState alternativeState,
+                TypeWithState consequenceRValue, TypeWithState alternativeRValue, BoundExpression consequence, Conversion consequenceConversion, bool consequenceEndReachable,
+                BoundExpression alternative, Conversion alternativeConversion, bool alternativeEndReachable, TypeWithAnnotations resultTypeWithAnnotations, bool wasTargetTyped)
+            {
+                NullableFlowState resultState;
+                if (!wasTargetTyped)
+                {
+                    TypeWithState convertedConsequenceResult = ConvertConditionalOperandOrSwitchExpressionArmResult(
                         originalConsequence,
                         consequence,
                         consequenceConversion,
@@ -4822,19 +5227,47 @@ void makeAndAdjustReceiverSlot(BoundExpression receiver)
                         alternativeEndReachable);
 
                     resultState = convertedConsequenceResult.State.Join(convertedAlternativeResult.State);
+                    var typeWithState = TypeWithState.Create(resultTypeWithAnnotations.Type, resultState);
+                    SetAnalyzedNullability(node, typeWithState);
+                    return typeWithState;
                 }
-            }
-            else
-            {
-                resultState = consequenceRValue.State.Join(alternativeRValue.State);
+                else
+                {
+                    addConvertArmsAsCompletion(
+                                  node, originalConsequence, originalAlternative, consequenceState, alternativeState,
+                                  consequenceRValue, alternativeRValue,
+                                  consequence, consequenceConversion, consequenceEndReachable,
+                                  alternative, alternativeConversion, alternativeEndReachable);
 
-                ConditionalInfoForConversion.Add(node, ImmutableArray.Create(
-                    (consequenceState, consequenceRValue, consequenceEndReachable),
-                    (alternativeState, alternativeRValue, alternativeEndReachable)));
+                    resultState = consequenceRValue.State.Join(alternativeRValue.State);
+                    return TypeWithState.Create(resultTypeWithAnnotations.Type, resultState);
+                }
             }
 
-            SetResultType(node, TypeWithState.Create(resultType, resultState));
-            return null;
+            void addConvertArmsAsCompletion(
+                BoundExpression node,
+                BoundExpression originalConsequence,
+                BoundExpression originalAlternative,
+                LocalState consequenceState,
+                LocalState alternativeState,
+                TypeWithState consequenceRValue,
+                TypeWithState alternativeRValue,
+                BoundExpression consequence,
+                Conversion consequenceConversion,
+                bool consequenceEndReachable,
+                BoundExpression alternative,
+                Conversion alternativeConversion,
+                bool alternativeEndReachable)
+            {
+                TargetTypedAnalysisCompletion[node] =
+                    (TypeWithAnnotations resultTypeWithAnnotations) =>
+                    {
+                        return convertArms(
+                                   node, originalConsequence, originalAlternative, consequenceState, alternativeState, consequenceRValue, alternativeRValue,
+                                   consequence, consequenceConversion, consequenceEndReachable, alternative, alternativeConversion, alternativeEndReachable,
+                                   resultTypeWithAnnotations, wasTargetTyped: false);
+                    };
+            }
 
             (BoundExpression, Conversion, TypeWithState) visitConditionalOperand(LocalState state, BoundExpression operand)
             {
@@ -5398,159 +5831,231 @@ private ImmutableArray<VisitArgumentResult> VisitArguments(
             bool invokedAsExtensionMethod,
             MethodSymbol? method = null)
         {
-            Debug.Assert(!arguments.IsDefault);
-            bool shouldReturnNotNull = false;
+            var result = VisitArguments(node, arguments, refKindsOpt, parametersOpt, argsToParamsOpt, defaultArguments, expanded, invokedAsExtensionMethod, method, delayCompletionForTargetMember: false);
+            Debug.Assert(result.completion is null);
+
+            return (result.method, result.results, result.returnNotNull);
+        }
 
+        private delegate (MethodSymbol? method, bool returnNotNull) ArgumentsCompletionDelegate(ImmutableArray<VisitArgumentResult> argumentResults, ImmutableArray<ParameterSymbol> parametersOpt, MethodSymbol? method);
+
+        private (MethodSymbol? method, ImmutableArray<VisitArgumentResult> results, bool returnNotNull, ArgumentsCompletionDelegate? completion)
+        VisitArguments(
+            BoundNode node,
+            ImmutableArray<BoundExpression> arguments,
+            ImmutableArray<RefKind> refKindsOpt,
+            ImmutableArray<ParameterSymbol> parametersOpt,
+            ImmutableArray<int> argsToParamsOpt,
+            BitVector defaultArguments,
+            bool expanded,
+            bool invokedAsExtensionMethod,
+            MethodSymbol? method,
+            bool delayCompletionForTargetMember)
+        {
+            Debug.Assert(!arguments.IsDefault);
             (ImmutableArray<BoundExpression> argumentsNoConversions, ImmutableArray<Conversion> conversions) = RemoveArgumentConversions(arguments, refKindsOpt);
 
             // Visit the arguments and collect results
-            ImmutableArray<VisitArgumentResult> results = VisitArgumentsEvaluate(argumentsNoConversions, refKindsOpt, parametersOpt, argsToParamsOpt, defaultArguments, expanded);
+            ImmutableArray<VisitArgumentResult> results = VisitArgumentsEvaluate(argumentsNoConversions, refKindsOpt, GetParametersAnnotations(arguments, parametersOpt, argsToParamsOpt, expanded), defaultArguments);
+
+            return visitArguments(
+                node, arguments, argumentsNoConversions, conversions, results, refKindsOpt,
+                parametersOpt, argsToParamsOpt, defaultArguments, expanded, invokedAsExtensionMethod,
+                method, delayCompletionForTargetMember);
 
-            // Re-infer method type parameters
-            if (method?.IsGenericMethod == true)
+            (MethodSymbol? method, ImmutableArray<VisitArgumentResult> results, bool returnNotNull, ArgumentsCompletionDelegate? completion)
+            visitArguments(
+                BoundNode node,
+                ImmutableArray<BoundExpression> arguments,
+                ImmutableArray<BoundExpression> argumentsNoConversions,
+                ImmutableArray<Conversion> conversions,
+                ImmutableArray<VisitArgumentResult> results,
+                ImmutableArray<RefKind> refKindsOpt,
+                ImmutableArray<ParameterSymbol> parametersOpt,
+                ImmutableArray<int> argsToParamsOpt,
+                BitVector defaultArguments,
+                bool expanded,
+                bool invokedAsExtensionMethod,
+                MethodSymbol? method,
+                bool delayCompletionForTargetMember)
             {
-                if (HasImplicitTypeArguments(node))
-                {
-                    method = InferMethodTypeArguments(method, GetArgumentsForMethodTypeInference(results, argumentsNoConversions), refKindsOpt, argsToParamsOpt, expanded);
-                    parametersOpt = method.Parameters;
-                }
-                if (ConstraintsHelper.RequiresChecking(method))
+                bool shouldReturnNotNull = false;
+
+                if (delayCompletionForTargetMember)
                 {
-                    var syntax = node.Syntax;
-                    CheckMethodConstraints(
-                        syntax switch
-                        {
-                            InvocationExpressionSyntax { Expression: var expression } => expression,
-                            ForEachStatementSyntax { Expression: var expression } => expression,
-                            _ => syntax
-                        },
-                        method);
+                    return (method, results, shouldReturnNotNull, visitArgumentsAsContinuation(
+                                                                      node, arguments, argumentsNoConversions, conversions, refKindsOpt,
+                                                                      argsToParamsOpt, defaultArguments, expanded, invokedAsExtensionMethod));
                 }
-            }
 
-            bool parameterHasNotNullIfNotNull = !IsAnalyzingAttribute && !parametersOpt.IsDefault && parametersOpt.Any(p => !p.NotNullIfParameterNotNull.IsEmpty);
-            var notNullParametersBuilder = parameterHasNotNullIfNotNull ? ArrayBuilder<ParameterSymbol>.GetInstance() : null;
-            var conversionResultsBuilder = ArrayBuilder<VisitResult>.GetInstance(results.Length);
-            if (!parametersOpt.IsDefault)
-            {
-                // Visit conversions, inbound assignments including pre-conditions
-                ImmutableHashSet<string>? returnNotNullIfParameterNotNull = IsAnalyzingAttribute ? null : method?.ReturnNotNullIfParameterNotNull;
-                for (int i = 0; i < results.Length; i++)
+                // Re-infer method type parameters
+                if (method?.IsGenericMethod == true)
                 {
-                    var argumentNoConversion = argumentsNoConversions[i];
-                    var argument = i < arguments.Length ? arguments[i] : argumentNoConversion;
-
-                    if (argument is not BoundConversion && argumentNoConversion is BoundLambda lambda)
+                    if (HasImplicitTypeArguments(node))
                     {
-                        Debug.Assert(node.HasErrors);
-                        Debug.Assert((object)argument == argumentNoConversion);
-                        // 'VisitConversion' only visits a lambda when the lambda has an AnonymousFunction conversion.
-                        // This lambda doesn't have a conversion, so we need to visit it here.
-                        VisitLambda(lambda, delegateTypeOpt: null, results[i].StateForLambda);
-                        continue;
+                        method = InferMethodTypeArguments(method, GetArgumentsForMethodTypeInference(results, argumentsNoConversions), refKindsOpt, argsToParamsOpt, expanded);
+                        parametersOpt = method.Parameters;
                     }
-
-                    (ParameterSymbol? parameter, TypeWithAnnotations parameterType, FlowAnalysisAnnotations parameterAnnotations, bool isExpandedParamsArgument) =
-                        GetCorrespondingParameter(i, parametersOpt, argsToParamsOpt, expanded);
-                    if (parameter is null)
+                    if (ConstraintsHelper.RequiresChecking(method))
                     {
-                        // If this assert fails, we are missing necessary info to visit the
-                        // conversion of a target typed conditional or switch.
-                        Debug.Assert(argumentNoConversion is not (BoundConditionalOperator { WasTargetTyped: true } or BoundConvertedSwitchExpression { WasTargetTyped: true })
-                            && _conditionalInfoForConversionOpt?.ContainsKey(argumentNoConversion) is null or false);
-
-                        // If this assert fails, it means we failed to visit a lambda for error recovery above.
-                        Debug.Assert(argumentNoConversion is not BoundLambda);
-
-                        continue;
+                        var syntax = node.Syntax;
+                        CheckMethodConstraints(
+                            syntax switch
+                            {
+                                InvocationExpressionSyntax { Expression: var expression } => expression,
+                                ForEachStatementSyntax { Expression: var expression } => expression,
+                                _ => syntax
+                            },
+                            method);
                     }
+                }
 
-                    // We disable diagnostics when:
-                    // 1. the containing call has errors (to reduce cascading diagnostics)
-                    // 2. on implicit default arguments (since that's really only an issue with the declaration)
-                    var previousDisableDiagnostics = _disableDiagnostics;
-                    _disableDiagnostics |= node.HasErrors || defaultArguments[i];
+                bool parameterHasNotNullIfNotNull = !IsAnalyzingAttribute && !parametersOpt.IsDefault && parametersOpt.Any(p => !p.NotNullIfParameterNotNull.IsEmpty);
+                var notNullParametersBuilder = parameterHasNotNullIfNotNull ? ArrayBuilder<ParameterSymbol>.GetInstance() : null;
+                var conversionResultsBuilder = ArrayBuilder<VisitResult>.GetInstance(results.Length);
+                if (!parametersOpt.IsDefault)
+                {
+                    // Visit conversions, inbound assignments including pre-conditions
+                    ImmutableHashSet<string>? returnNotNullIfParameterNotNull = IsAnalyzingAttribute ? null : method?.ReturnNotNullIfParameterNotNull;
+                    for (int i = 0; i < results.Length; i++)
+                    {
+                        var argumentNoConversion = argumentsNoConversions[i];
+                        var argument = i < arguments.Length ? arguments[i] : argumentNoConversion;
 
-                    VisitArgumentConversionAndInboundAssignmentsAndPreConditions(
-                        GetConversionIfApplicable(argument, argumentNoConversion),
-                        argumentNoConversion,
-                        conversions.IsDefault || i >= conversions.Length ? Conversion.Identity : conversions[i],
-                        GetRefKind(refKindsOpt, i),
-                        parameter,
-                        parameterType,
-                        parameterAnnotations,
-                        results[i],
-                        conversionResultsBuilder,
-                        invokedAsExtensionMethod && i == 0);
+                        if (argument is not BoundConversion && argumentNoConversion is BoundLambda lambda)
+                        {
+                            Debug.Assert(node.HasErrors);
+                            Debug.Assert((object)argument == argumentNoConversion);
+                            // 'VisitConversion' only visits a lambda when the lambda has an AnonymousFunction conversion.
+                            // This lambda doesn't have a conversion, so we need to visit it here.
+                            VisitLambda(lambda, delegateTypeOpt: null, results[i].StateForLambda);
+                            continue;
+                        }
 
-                    _disableDiagnostics = previousDisableDiagnostics;
+                        (ParameterSymbol? parameter, TypeWithAnnotations parameterType, FlowAnalysisAnnotations parameterAnnotations, bool isExpandedParamsArgument) =
+                            GetCorrespondingParameter(i, parametersOpt, argsToParamsOpt, expanded);
+                        if (parameter is null)
+                        {
+                            // If this assert fails, we are missing necessary info to visit the
+                            // conversion of a target typed construct.
+                            Debug.Assert(!IsTargetTypedExpression(argumentNoConversion) || _targetTypedAnalysisCompletionOpt?.ContainsKey(argumentNoConversion) is true);
 
-                    if (results[i].RValueType.IsNotNull || isExpandedParamsArgument)
-                    {
-                        notNullParametersBuilder?.Add(parameter);
+                            // If this assert fails, it means we failed to visit a lambda for error recovery above.
+                            Debug.Assert(argumentNoConversion is not BoundLambda);
 
-                        if (returnNotNullIfParameterNotNull?.Contains(parameter.Name) == true)
+                            continue;
+                        }
+
+                        // We disable diagnostics when:
+                        // 1. the containing call has errors (to reduce cascading diagnostics)
+                        // 2. on implicit default arguments (since that's really only an issue with the declaration)
+                        var previousDisableDiagnostics = _disableDiagnostics;
+                        _disableDiagnostics |= node.HasErrors || defaultArguments[i];
+
+                        VisitArgumentConversionAndInboundAssignmentsAndPreConditions(
+                            GetConversionIfApplicable(argument, argumentNoConversion),
+                            argumentNoConversion,
+                            conversions.IsDefault || i >= conversions.Length ? Conversion.Identity : conversions[i],
+                            GetRefKind(refKindsOpt, i),
+                            parameter,
+                            parameterType,
+                            parameterAnnotations,
+                            results[i],
+                            conversionResultsBuilder,
+                            invokedAsExtensionMethod && i == 0);
+
+                        _disableDiagnostics = previousDisableDiagnostics;
+
+                        if (results[i].RValueType.IsNotNull || isExpandedParamsArgument)
                         {
-                            shouldReturnNotNull = true;
+                            notNullParametersBuilder?.Add(parameter);
+
+                            if (returnNotNullIfParameterNotNull?.Contains(parameter.Name) == true)
+                            {
+                                shouldReturnNotNull = true;
+                            }
                         }
                     }
                 }
-            }
 
-            conversionResultsBuilder.Free();
+                conversionResultsBuilder.Free();
 
-            if (node is BoundCall { Method: { OriginalDefinition: LocalFunctionSymbol localFunction } })
-            {
-                VisitLocalFunctionUse(localFunction);
-            }
+                if (node is BoundCall { Method: { OriginalDefinition: LocalFunctionSymbol localFunction } })
+                {
+                    VisitLocalFunctionUse(localFunction);
+                }
 
-            if (!node.HasErrors && !parametersOpt.IsDefault)
-            {
-                // For CompareExchange method we need more context to determine the state of outbound assignment
-                CompareExchangeInfo compareExchangeInfo = IsCompareExchangeMethod(method) ? new CompareExchangeInfo(arguments, results, argsToParamsOpt) : default;
+                if (!node.HasErrors && !parametersOpt.IsDefault)
+                {
+                    // For CompareExchange method we need more context to determine the state of outbound assignment
+                    CompareExchangeInfo compareExchangeInfo = IsCompareExchangeMethod(method) ? new CompareExchangeInfo(arguments, results, argsToParamsOpt) : default;
 
-                // Visit outbound assignments and post-conditions
-                // Note: the state may get split in this step
-                for (int i = 0; i < arguments.Length; i++)
+                    // Visit outbound assignments and post-conditions
+                    // Note: the state may get split in this step
+                    for (int i = 0; i < arguments.Length; i++)
+                    {
+                        (ParameterSymbol? parameter, TypeWithAnnotations parameterType, FlowAnalysisAnnotations parameterAnnotations, _) =
+                            GetCorrespondingParameter(i, parametersOpt, argsToParamsOpt, expanded);
+                        if (parameter is null)
+                        {
+                            continue;
+                        }
+
+                        VisitArgumentOutboundAssignmentsAndPostConditions(
+                            arguments[i],
+                            GetRefKind(refKindsOpt, i),
+                            parameter,
+                            parameterType,
+                            parameterAnnotations,
+                            results[i],
+                            notNullParametersBuilder,
+                            (!compareExchangeInfo.IsDefault && parameter.Ordinal == 0) ? compareExchangeInfo : default);
+                    }
+                }
+                else
                 {
-                    (ParameterSymbol? parameter, TypeWithAnnotations parameterType, FlowAnalysisAnnotations parameterAnnotations, _) =
-                        GetCorrespondingParameter(i, parametersOpt, argsToParamsOpt, expanded);
-                    if (parameter is null)
+                    for (int i = 0; i < arguments.Length; i++)
                     {
-                        continue;
+                        // We can hit this case when dynamic methods are involved, or when there are errors. In either case we have no information,
+                        // so just assume that the conversions have the same nullability as the underlying result
+                        var argument = arguments[i];
+                        var result = results[i];
+                        var argumentNoConversion = argumentsNoConversions[i];
+                        TrackAnalyzedNullabilityThroughConversionGroup(TypeWithState.Create(argument.Type, result.RValueType.State), argument as BoundConversion, argumentNoConversion);
                     }
-
-                    VisitArgumentOutboundAssignmentsAndPostConditions(
-                        arguments[i],
-                        GetRefKind(refKindsOpt, i),
-                        parameter,
-                        parameterType,
-                        parameterAnnotations,
-                        results[i],
-                        notNullParametersBuilder,
-                        (!compareExchangeInfo.IsDefault && parameter.Ordinal == 0) ? compareExchangeInfo : default);
                 }
-            }
-            else
-            {
-                for (int i = 0; i < arguments.Length; i++)
+
+                if (!IsAnalyzingAttribute && method is object && (method.FlowAnalysisAnnotations & FlowAnalysisAnnotations.DoesNotReturn) == FlowAnalysisAnnotations.DoesNotReturn)
                 {
-                    // We can hit this case when dynamic methods are involved, or when there are errors. In either case we have no information,
-                    // so just assume that the conversions have the same nullability as the underlying result
-                    var argument = arguments[i];
-                    var result = results[i];
-                    var argumentNoConversion = argumentsNoConversions[i];
-                    TrackAnalyzedNullabilityThroughConversionGroup(TypeWithState.Create(argument.Type, result.RValueType.State), argument as BoundConversion, argumentNoConversion);
+                    SetUnreachable();
                 }
+
+                notNullParametersBuilder?.Free();
+                return (method, results, shouldReturnNotNull, null);
             }
 
-            if (!IsAnalyzingAttribute && method is object && (method.FlowAnalysisAnnotations & FlowAnalysisAnnotations.DoesNotReturn) == FlowAnalysisAnnotations.DoesNotReturn)
+            ArgumentsCompletionDelegate visitArgumentsAsContinuation(
+                BoundNode node,
+                ImmutableArray<BoundExpression> arguments,
+                ImmutableArray<BoundExpression> argumentsNoConversions,
+                ImmutableArray<Conversion> conversions,
+                ImmutableArray<RefKind> refKindsOpt,
+                ImmutableArray<int> argsToParamsOpt,
+                BitVector defaultArguments,
+                bool expanded,
+                bool invokedAsExtensionMethod)
             {
-                SetUnreachable();
-            }
+                return (ImmutableArray<VisitArgumentResult> results, ImmutableArray<ParameterSymbol> parametersOpt, MethodSymbol? method) =>
+                       {
+                           var result = visitArguments(
+                                           node, arguments, argumentsNoConversions, conversions, results, refKindsOpt,
+                                           parametersOpt, argsToParamsOpt, defaultArguments, expanded, invokedAsExtensionMethod,
+                                           method, delayCompletionForTargetMember: false);
+                           Debug.Assert(result.completion is null);
 
-            notNullParametersBuilder?.Free();
-            return (method, results, shouldReturnNotNull);
+                           return (result.method, result.returnNotNull);
+                       };
+            }
         }
 
         private void ApplyMemberPostConditions(BoundExpression? receiverOpt, MethodSymbol? method)
@@ -5648,37 +6153,44 @@ void markMembersAsNotNull(int receiverSlot, TypeSymbol type, string memberName,
         private ImmutableArray<VisitArgumentResult> VisitArgumentsEvaluate(
             ImmutableArray<BoundExpression> arguments,
             ImmutableArray<RefKind> refKindsOpt,
-            ImmutableArray<ParameterSymbol> parametersOpt,
-            ImmutableArray<int> argsToParamsOpt,
-            BitVector defaultArguments,
-            bool expanded)
+            ImmutableArray<FlowAnalysisAnnotations> parameterAnnotationsOpt,
+            BitVector defaultArguments)
         {
             Debug.Assert(!IsConditionalState);
             int n = arguments.Length;
-            if (n == 0 && parametersOpt.IsDefaultOrEmpty)
+            if (n == 0 && parameterAnnotationsOpt.IsDefaultOrEmpty)
             {
                 return ImmutableArray<VisitArgumentResult>.Empty;
             }
 
-            var visitedParameters = PooledHashSet<ParameterSymbol?>.GetInstance();
             var resultsBuilder = ArrayBuilder<VisitArgumentResult>.GetInstance(n);
             var previousDisableDiagnostics = _disableDiagnostics;
             for (int i = 0; i < n; i++)
             {
-                var (parameter, _, parameterAnnotations, _) = GetCorrespondingParameter(i, parametersOpt, argsToParamsOpt, expanded);
-
                 // we disable nullable warnings on default arguments
                 _disableDiagnostics = defaultArguments[i] || previousDisableDiagnostics;
-                resultsBuilder.Add(VisitArgumentEvaluate(arguments[i], GetRefKind(refKindsOpt, i), parameterAnnotations));
-                visitedParameters.Add(parameter);
+                resultsBuilder.Add(VisitArgumentEvaluate(arguments[i], GetRefKind(refKindsOpt, i), parameterAnnotationsOpt.IsDefault ? default : parameterAnnotationsOpt[i]));
             }
             _disableDiagnostics = previousDisableDiagnostics;
 
             SetInvalidResult();
-            visitedParameters.Free();
             return resultsBuilder.ToImmutableAndFree();
         }
 
+        private ImmutableArray<FlowAnalysisAnnotations> GetParametersAnnotations(ImmutableArray<BoundExpression> arguments, ImmutableArray<ParameterSymbol> parametersOpt, ImmutableArray<int> argsToParamsOpt, bool expanded)
+        {
+            ImmutableArray<FlowAnalysisAnnotations> parameterAnnotationsOpt = default;
+
+            if (!parametersOpt.IsDefault)
+            {
+                parameterAnnotationsOpt = arguments.SelectAsArray(
+                    (argument, i, arg) => GetCorrespondingParameter(i, arg.parametersOpt, arg.argsToParamsOpt, arg.expanded).Annotations,
+                    (parametersOpt, argsToParamsOpt, expanded));
+            }
+
+            return parameterAnnotationsOpt;
+        }
+
         private VisitArgumentResult VisitArgumentEvaluate(BoundExpression argument, RefKind refKind, FlowAnalysisAnnotations annotations)
         {
             Debug.Assert(!IsConditionalState);
@@ -6339,9 +6851,7 @@ BoundExpression getArgumentForMethodTypeInference(BoundExpression argument, Type
                 {
                     return argument;
                 }
-                if (argument is BoundLocal { DeclarationKind: BoundLocalDeclarationKind.WithInferredType }
-                             or BoundConditionalOperator { WasTargetTyped: true }
-                             or BoundConvertedSwitchExpression { WasTargetTyped: true })
+                if (argument is BoundLocal { DeclarationKind: BoundLocalDeclarationKind.WithInferredType } || IsTargetTypedExpression(argument))
                 {
                     // target-typed contexts don't contribute to nullability
                     return new BoundExpressionWithNullability(argument.Syntax, argument, NullableAnnotation.Oblivious, type: null);
@@ -6650,29 +7160,71 @@ private TypeWithState VisitOptionalImplicitConversion(BoundExpression expr, Type
                 return VisitRvalueWithState(expr);
             }
 
+            var (resultType, completion) = VisitOptionalImplicitConversion(expr, targetTypeOpt, useLegacyWarnings, trackMembers, assignmentKind, delayCompletionForTargetType: false);
+            Debug.Assert(completion is null);
+            return resultType;
+        }
+
+        private (TypeWithState resultType, Func<TypeWithAnnotations, TypeWithState>? completion) VisitOptionalImplicitConversion(
+            BoundExpression expr,
+            TypeWithAnnotations targetTypeOpt,
+            bool useLegacyWarnings,
+            bool trackMembers,
+            AssignmentKind assignmentKind,
+            bool delayCompletionForTargetType)
+        {
             (BoundExpression operand, Conversion conversion) = RemoveConversion(expr, includeExplicitConversions: false);
             SnapshotWalkerThroughConversionGroup(expr, operand);
             var operandType = VisitRvalueWithState(operand);
-            // If an explicit conversion was used in place of an implicit conversion, the explicit
-            // conversion was created by initial binding after reporting "error CS0266:
-            // Cannot implicitly convert type '...' to '...'. An explicit conversion exists ...".
-            // Since an error was reported, we don't need to report nested warnings as well.
-            bool reportNestedWarnings = !conversion.IsExplicit;
-            var resultType = VisitConversion(
-                GetConversionIfApplicable(expr, operand),
-                operand,
-                conversion,
-                targetTypeOpt,
-                operandType,
-                checkConversion: true,
-                fromExplicitCast: false,
-                useLegacyWarnings: useLegacyWarnings,
-                assignmentKind,
-                reportTopLevelWarnings: true,
-                reportRemainingWarnings: reportNestedWarnings,
-                trackMembers: trackMembers);
 
-            return resultType;
+            return visitConversion(expr, targetTypeOpt, useLegacyWarnings, trackMembers, assignmentKind, operand, conversion, operandType, delayCompletionForTargetType);
+
+            (TypeWithState resultType, Func<TypeWithAnnotations, TypeWithState>? completion) visitConversion(
+                BoundExpression expr,
+                TypeWithAnnotations targetTypeOpt,
+                bool useLegacyWarnings, bool trackMembers, AssignmentKind assignmentKind,
+                BoundExpression operand,
+                Conversion conversion, TypeWithState operandType,
+                bool delayCompletionForTargetType)
+            {
+                if (delayCompletionForTargetType)
+                {
+                    return (TypeWithState.Create(targetTypeOpt), visitConversionAsContinuation(expr, useLegacyWarnings, trackMembers, assignmentKind, operand, conversion, operandType));
+                }
+
+                Debug.Assert(targetTypeOpt.HasType);
+
+                // If an explicit conversion was used in place of an implicit conversion, the explicit
+                // conversion was created by initial binding after reporting "error CS0266:
+                // Cannot implicitly convert type '...' to '...'. An explicit conversion exists ...".
+                // Since an error was reported, we don't need to report nested warnings as well.
+                bool reportNestedWarnings = !conversion.IsExplicit;
+                var resultType = VisitConversion(
+                    GetConversionIfApplicable(expr, operand),
+                    operand,
+                    conversion,
+                    targetTypeOpt,
+                    operandType,
+                    checkConversion: true,
+                    fromExplicitCast: false,
+                    useLegacyWarnings: useLegacyWarnings,
+                    assignmentKind,
+                    reportTopLevelWarnings: true,
+                    reportRemainingWarnings: reportNestedWarnings,
+                    trackMembers: trackMembers);
+
+                return (resultType, null);
+            }
+
+            Func<TypeWithAnnotations, TypeWithState> visitConversionAsContinuation(BoundExpression expr, bool useLegacyWarnings, bool trackMembers, AssignmentKind assignmentKind, BoundExpression operand, Conversion conversion, TypeWithState operandType)
+            {
+                return (TypeWithAnnotations targetTypeOpt) =>
+                {
+                    var result = visitConversion(expr, targetTypeOpt, useLegacyWarnings, trackMembers, assignmentKind, operand, conversion, operandType, delayCompletionForTargetType: false);
+                    Debug.Assert(result.completion is null);
+                    return result.resultType;
+                };
+            }
         }
 
         private static bool AreNullableAndUnderlyingTypes([NotNullWhen(true)] TypeSymbol? nullableTypeOpt, [NotNullWhen(true)] TypeSymbol? underlyingTypeOpt, out TypeWithAnnotations underlyingTypeWithAnnotations)
@@ -7067,6 +7619,34 @@ private TypeWithState VisitConversion(
             Debug.Assert(!trackMembers || !IsConditionalState);
             Debug.Assert(conversionOperand != null);
 
+            if (IsTargetTypedExpression(conversionOperand))
+            {
+                if (TargetTypedAnalysisCompletion.TryGetValue(conversionOperand, out Func<TypeWithAnnotations, TypeWithState>? completion))
+                {
+                    TargetTypedAnalysisCompletion.Remove(conversionOperand);
+#if DEBUG
+                    bool save_completingTargetTypedExpression = _completingTargetTypedExpression;
+                    _completingTargetTypedExpression = true;
+#endif
+                    if (conversionOperand is BoundObjectCreationExpressionBase && targetTypeWithNullability.IsNullableType())
+                    {
+                        operandType = completion(targetTypeWithNullability.Type.GetNullableUnderlyingTypeWithAnnotations());
+                        conversion = Conversion.MakeNullableConversion(ConversionKind.ImplicitNullable, Conversion.Identity);
+                    }
+                    else
+                    {
+                        operandType = completion(targetTypeWithNullability);
+                    }
+#if DEBUG
+                    _completingTargetTypedExpression = save_completingTargetTypedExpression;
+#endif
+                }
+                else
+                {
+                    Debug.Assert(conversionOpt is null);
+                }
+            }
+
             NullableFlowState resultState = NullableFlowState.NotNull;
             bool canConvertNestedNullability = true;
             bool isSuppressed = false;
@@ -7144,8 +7724,7 @@ private TypeWithState VisitConversion(
                 case ConversionKind.ObjectCreation:
                 case ConversionKind.SwitchExpression:
                 case ConversionKind.ConditionalExpression:
-                    resultState = visitNestedTargetTypedConstructs();
-                    TrackAnalyzedNullabilityThroughConversionGroup(targetTypeWithNullability.ToTypeWithState(), conversionOpt, conversionOperand);
+                    resultState = getConversionResultState(operandType);
                     break;
 
                 case ConversionKind.ExplicitUserDefined:
@@ -7474,64 +8053,6 @@ static bool dependsOnTypeParameter(TypeParameterSymbol typeParameter1, TypeParam
                 return false;
             }
 
-            NullableFlowState visitNestedTargetTypedConstructs()
-            {
-                switch (conversionOperand)
-                {
-                    case BoundConditionalOperator { WasTargetTyped: true } conditional:
-                        {
-                            Debug.Assert(ConditionalInfoForConversion.ContainsKey(conditional));
-                            var info = ConditionalInfoForConversion[conditional];
-                            Debug.Assert(info.Length == 2);
-
-                            var consequence = conditional.Consequence;
-                            (BoundExpression consequenceOperand, Conversion consequenceConversion) = RemoveConversion(consequence, includeExplicitConversions: false);
-                            var consequenceRValue = ConvertConditionalOperandOrSwitchExpressionArmResult(consequence, consequenceOperand, consequenceConversion, targetTypeWithNullability, info[0].ResultType, info[0].State, info[0].EndReachable);
-                            var alternative = conditional.Alternative;
-                            (BoundExpression alternativeOperand, Conversion alternativeConversion) = RemoveConversion(alternative, includeExplicitConversions: false);
-                            var alternativeRValue = ConvertConditionalOperandOrSwitchExpressionArmResult(alternative, alternativeOperand, alternativeConversion, targetTypeWithNullability, info[1].ResultType, info[1].State, info[1].EndReachable);
-
-                            ConditionalInfoForConversion.Remove(conditional);
-
-                            return consequenceRValue.State.Join(alternativeRValue.State);
-                        }
-
-                    case BoundConvertedSwitchExpression { WasTargetTyped: true } @switch:
-                        {
-                            Debug.Assert(ConditionalInfoForConversion.ContainsKey(@switch));
-                            var info = ConditionalInfoForConversion[@switch];
-
-                            Debug.Assert(info.Length == @switch.SwitchArms.Length);
-
-                            var resultTypes = ArrayBuilder<TypeWithState>.GetInstance(info.Length);
-
-                            for (int i = 0; i < info.Length; i++)
-                            {
-                                var (state, armResultType, isReachable) = info[i];
-                                var arm = @switch.SwitchArms[i].Value;
-                                var (operand, conversion) = RemoveConversion(arm, includeExplicitConversions: false);
-                                resultTypes.Add(ConvertConditionalOperandOrSwitchExpressionArmResult(arm, operand, conversion, targetTypeWithNullability, armResultType, state, isReachable));
-                            }
-
-                            var resultState = BestTypeInferrer.GetNullableState(resultTypes);
-                            resultTypes.Free();
-                            ConditionalInfoForConversion.Remove(@switch);
-                            return resultState;
-                        }
-
-                    case BoundObjectCreationExpression { WasTargetTyped: true }:
-                    case BoundUnconvertedObjectCreationExpression:
-                        return NullableFlowState.NotNull;
-
-                    case BoundUnconvertedConditionalOperator:
-                    case BoundUnconvertedSwitchExpression:
-                        return operandType.State;
-
-                    default:
-                        throw ExceptionUtilities.UnexpectedValue(conversionOperand.Kind);
-                }
-            }
-
             void visitInterpolatedStringHandlerConstructor()
             {
                 var handlerData = conversionOperand.GetInterpolatedStringHandlerData(throwOnMissing: false);
@@ -7544,7 +8065,7 @@ void visitInterpolatedStringHandlerConstructor()
                 {
                     Debug.Assert(handlerData.ArgumentPlaceholders.IsEmpty
                                  || handlerData.ArgumentPlaceholders.Single().ArgumentIndex == BoundInterpolatedStringArgumentPlaceholder.TrailingConstructorValidityParameter);
-                    VisitRvalue(handlerData.Construction);
+                    visitHandlerConstruction(handlerData);
                     return;
                 }
 
@@ -7573,7 +8094,7 @@ void visitInterpolatedStringHandlerConstructor()
                     }
                 }
 
-                VisitRvalue(handlerData.Construction);
+                visitHandlerConstruction(handlerData);
 
                 if (addedPlaceholders)
                 {
@@ -7586,6 +8107,18 @@ void visitInterpolatedStringHandlerConstructor()
                     }
                 }
             }
+
+            void visitHandlerConstruction(InterpolatedStringHandlerData handlerData)
+            {
+#if DEBUG
+                bool save_completingTargetTypedExpression = _completingTargetTypedExpression;
+                _completingTargetTypedExpression = false;
+#endif
+                VisitRvalue(handlerData.Construction);
+#if DEBUG
+                _completingTargetTypedExpression = save_completingTargetTypedExpression;
+#endif 
+            }
         }
 
         private TypeWithState VisitUserDefinedConversion(
@@ -7855,58 +8388,171 @@ private TypeWithState ClassifyAndVisitConversion(
                 VisitLocalFunctionUse(localFunc);
             }
 
+            Action<NamedTypeSymbol>? analysisCompletion;
+
             var delegateType = (NamedTypeSymbol)node.Type;
             switch (node.Argument)
             {
                 case BoundMethodGroup group:
                     {
-                        VisitMethodGroup(group);
-                        var method = node.MethodOpt;
-                        if (method is object &&
-                            delegateType.DelegateInvokeMethod is { } delegateInvokeMethod)
-                        {
-                            method = CheckMethodGroupReceiverNullability(group, delegateInvokeMethod.Parameters, method, node.IsExtensionMethod);
-                            if (!group.IsSuppressed)
-                            {
-                                ReportNullabilityMismatchWithTargetDelegate(group.Syntax.Location, delegateType, delegateInvokeMethod, method, node.IsExtensionMethod);
-                            }
-                        }
-                        SetAnalyzedNullability(group, default);
+                        analysisCompletion = visitMethodGroupArgument(node, delegateType, group);
                     }
                     break;
                 case BoundLambda lambda:
                     {
-                        VisitLambda(lambda, delegateType);
-                        SetNotNullResult(lambda);
-                        if (!lambda.IsSuppressed)
-                        {
-                            ReportNullabilityMismatchWithTargetDelegate(lambda.Symbol.DiagnosticLocation, delegateType, lambda);
-                        }
+                        analysisCompletion = visitLambdaArgument(delegateType, lambda, node.WasTargetTyped);
                     }
                     break;
-                case BoundExpression arg when arg.Type is { TypeKind: TypeKind.Delegate } argType:
-                    {
-                        var argTypeWithAnnotations = TypeWithAnnotations.Create(argType, NullableAnnotation.NotAnnotated);
-                        var argState = VisitRvalueWithState(arg);
-                        ReportNullableAssignmentIfNecessary(arg, argTypeWithAnnotations, argState, useLegacyWarnings: false);
-                        if (!arg.IsSuppressed &&
-                            delegateType.DelegateInvokeMethod is { } delegateInvokeMethod &&
-                            argType.DelegateInvokeMethod() is { } argInvokeMethod)
-                        {
-                            ReportNullabilityMismatchWithTargetDelegate(arg.Syntax.Location, delegateType, delegateInvokeMethod, argInvokeMethod, invokedAsExtensionMethod: false);
-                        }
-
-                        // Delegate creation will throw an exception if the argument is null
-                        LearnFromNonNullTest(arg, ref State);
+                case BoundExpression arg when arg.Type is { TypeKind: TypeKind.Delegate }:
+                    {
+                        analysisCompletion = visitDelegateArgument(delegateType, arg, node.WasTargetTyped);
                     }
                     break;
                 default:
                     VisitRvalue(node.Argument);
+                    analysisCompletion = null;
                     break;
             }
 
-            SetNotNullResult(node);
+            TypeWithState result = setAnalyzedNullability(node, delegateType, analysisCompletion, node.WasTargetTyped);
+            SetResultType(node, result, updateAnalyzedNullability: false);
             return null;
+
+            TypeWithState setAnalyzedNullability(BoundDelegateCreationExpression node, NamedTypeSymbol delegateType, Action<NamedTypeSymbol>? analysisCompletion, bool isTargetTyped)
+            {
+                var result = TypeWithState.Create(delegateType, NullableFlowState.NotNull);
+
+                if (isTargetTyped)
+                {
+                    setAnalyzedNullabilityAsContinuation(node, analysisCompletion);
+                }
+                else
+                {
+                    Debug.Assert(analysisCompletion is null);
+                    SetAnalyzedNullability(node, result);
+                }
+
+                return result;
+            }
+
+            void setAnalyzedNullabilityAsContinuation(BoundDelegateCreationExpression node, Action<NamedTypeSymbol>? analysisCompletion)
+            {
+                TargetTypedAnalysisCompletion[node] =
+                    (TypeWithAnnotations resultTypeWithAnnotations) =>
+                    {
+                        Debug.Assert(TypeSymbol.Equals(resultTypeWithAnnotations.Type, node.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes));
+                        var delegateType = (NamedTypeSymbol)resultTypeWithAnnotations.Type;
+
+                        analysisCompletion?.Invoke(delegateType);
+
+                        return setAnalyzedNullability(node, delegateType, analysisCompletion: null, isTargetTyped: false);
+                    };
+            }
+
+            Action<NamedTypeSymbol>? visitMethodGroupArgument(BoundDelegateCreationExpression node, NamedTypeSymbol delegateType, BoundMethodGroup group)
+            {
+                VisitMethodGroup(group);
+                SetAnalyzedNullability(group, default);
+
+                return analyzeMethodGroupConversion(node, delegateType, group, node.WasTargetTyped);
+            }
+
+            Action<NamedTypeSymbol>? analyzeMethodGroupConversion(BoundDelegateCreationExpression node, NamedTypeSymbol delegateType, BoundMethodGroup group, bool isTargetTyped)
+            {
+                if (isTargetTyped)
+                {
+                    return analyzeMethodGroupConversionAsContinuation(node, group);
+                }
+
+                var method = node.MethodOpt;
+                if (method is object &&
+                    delegateType.DelegateInvokeMethod is { } delegateInvokeMethod)
+                {
+                    method = CheckMethodGroupReceiverNullability(group, delegateInvokeMethod.Parameters, method, node.IsExtensionMethod);
+                    if (!group.IsSuppressed)
+                    {
+                        ReportNullabilityMismatchWithTargetDelegate(group.Syntax.Location, delegateType, delegateInvokeMethod, method, node.IsExtensionMethod);
+                    }
+                }
+
+                return null;
+            }
+
+            Action<NamedTypeSymbol>? analyzeMethodGroupConversionAsContinuation(BoundDelegateCreationExpression node, BoundMethodGroup group)
+            {
+                return (NamedTypeSymbol delegateType) =>
+                {
+                    analyzeMethodGroupConversion(node, delegateType, group, isTargetTyped: false);
+                };
+            }
+
+            Action<NamedTypeSymbol>? visitLambdaArgument(NamedTypeSymbol delegateType, BoundLambda lambda, bool isTargetTyped)
+            {
+                SetNotNullResult(lambda);
+
+                return analyzeLambdaConversion(delegateType, lambda, isTargetTyped);
+            }
+
+            Action<NamedTypeSymbol>? analyzeLambdaConversion(NamedTypeSymbol delegateType, BoundLambda lambda, bool isTargetTyped)
+            {
+                if (isTargetTyped)
+                {
+                    return analyzeLambdaConversionAsContinuation(lambda);
+                }
+
+                VisitLambda(lambda, delegateType);
+
+                if (!lambda.IsSuppressed)
+                {
+                    ReportNullabilityMismatchWithTargetDelegate(lambda.Symbol.DiagnosticLocation, delegateType, lambda);
+                }
+
+                return null;
+            }
+
+            Action<NamedTypeSymbol> analyzeLambdaConversionAsContinuation(BoundLambda lambda)
+            {
+                return (NamedTypeSymbol delegateType) => analyzeLambdaConversion(delegateType, lambda, isTargetTyped: false);
+            }
+
+            Action<NamedTypeSymbol>? visitDelegateArgument(NamedTypeSymbol delegateType, BoundExpression arg, bool isTargetTyped)
+            {
+                Debug.Assert(arg.Type is not null);
+                TypeSymbol argType = arg.Type;
+                var argTypeWithAnnotations = TypeWithAnnotations.Create(argType, NullableAnnotation.NotAnnotated);
+                var argState = VisitRvalueWithState(arg);
+                ReportNullableAssignmentIfNecessary(arg, argTypeWithAnnotations, argState, useLegacyWarnings: false);
+
+                // Delegate creation will throw an exception if the argument is null
+                LearnFromNonNullTest(arg, ref State);
+
+                return analyzeDelegateConversion(delegateType, arg, isTargetTyped);
+            }
+
+            Action<NamedTypeSymbol>? analyzeDelegateConversion(NamedTypeSymbol delegateType, BoundExpression arg, bool isTargetTyped)
+            {
+                if (isTargetTyped)
+                {
+                    return analyzeDelegateConversionAsContinuation(arg);
+                }
+
+                Debug.Assert(arg.Type is not null);
+                TypeSymbol argType = arg.Type;
+
+                if (!arg.IsSuppressed &&
+                    delegateType.DelegateInvokeMethod is { } delegateInvokeMethod &&
+                    argType.DelegateInvokeMethod() is { } argInvokeMethod)
+                {
+                    ReportNullabilityMismatchWithTargetDelegate(arg.Syntax.Location, delegateType, delegateInvokeMethod, argInvokeMethod, invokedAsExtensionMethod: false);
+                }
+
+                return null;
+            }
+
+            Action<NamedTypeSymbol> analyzeDelegateConversionAsContinuation(BoundExpression arg)
+            {
+                return (NamedTypeSymbol delegateType) => analyzeDelegateConversion(delegateType, arg, isTargetTyped: false);
+            }
         }
 
         public override BoundNode? VisitMethodGroup(BoundMethodGroup node)
@@ -8172,6 +8818,8 @@ private void AdjustSetValue(BoundExpression left, ref TypeWithState rightState)
 
         private FlowAnalysisAnnotations GetLValueAnnotations(BoundExpression expr)
         {
+            Debug.Assert(expr is not BoundObjectInitializerMember);
+
             // Annotations are ignored when binding an attribute to avoid cycles. (Members used
             // in attributes are error scenarios, so missing warnings should not be important.)
             if (IsAnalyzingAttribute)
@@ -8183,22 +8831,34 @@ private FlowAnalysisAnnotations GetLValueAnnotations(BoundExpression expr)
             {
                 BoundPropertyAccess property => property.PropertySymbol.GetFlowAnalysisAnnotations(),
                 BoundIndexerAccess indexer => indexer.Indexer.GetFlowAnalysisAnnotations(),
-                BoundFieldAccess field => getFieldAnnotations(field.FieldSymbol),
-                BoundObjectInitializerMember { MemberSymbol: PropertySymbol prop } => prop.GetFlowAnalysisAnnotations(),
-                BoundObjectInitializerMember { MemberSymbol: FieldSymbol field } => getFieldAnnotations(field),
+                BoundFieldAccess field => GetFieldAnnotations(field.FieldSymbol),
                 BoundParameter { ParameterSymbol: ParameterSymbol parameter }
                     => ToInwardAnnotations(GetParameterAnnotations(parameter) & ~FlowAnalysisAnnotations.NotNull), // NotNull is enforced upon method exit
                 _ => FlowAnalysisAnnotations.None
             };
 
             return annotations & (FlowAnalysisAnnotations.DisallowNull | FlowAnalysisAnnotations.AllowNull);
+        }
 
-            static FlowAnalysisAnnotations getFieldAnnotations(FieldSymbol field)
+        private static FlowAnalysisAnnotations GetFieldAnnotations(FieldSymbol field)
+        {
+            return field.AssociatedSymbol is PropertySymbol property ?
+                property.GetFlowAnalysisAnnotations() :
+                field.FlowAnalysisAnnotations;
+        }
+
+        private FlowAnalysisAnnotations GetObjectInitializerMemberLValueAnnotations(Symbol memberSymbol)
+        {
+            // Annotations are ignored when binding an attribute to avoid cycles. (Members used
+            // in attributes are error scenarios, so missing warnings should not be important.)
+            if (IsAnalyzingAttribute)
             {
-                return field.AssociatedSymbol is PropertySymbol property ?
-                    property.GetFlowAnalysisAnnotations() :
-                    field.FlowAnalysisAnnotations;
+                return FlowAnalysisAnnotations.None;
             }
+
+            var annotations = memberSymbol switch { PropertySymbol prop => prop.GetFlowAnalysisAnnotations(), FieldSymbol field => GetFieldAnnotations(field), _ => FlowAnalysisAnnotations.None };
+
+            return annotations & (FlowAnalysisAnnotations.DisallowNull | FlowAnalysisAnnotations.AllowNull);
         }
 
         private static FlowAnalysisAnnotations ToInwardAnnotations(FlowAnalysisAnnotations outwardAnnotations)
@@ -8959,7 +9619,7 @@ private Symbol VisitMemberAccess(BoundExpression node, BoundExpression? receiver
         private int GetNullableOfTValueSlot(TypeSymbol containingType, int containingSlot, out Symbol? valueProperty, bool forceSlotEvenIfEmpty = false)
         {
             Debug.Assert(containingType.IsNullableType());
-            Debug.Assert(TypeSymbol.Equals(NominalSlotType(containingSlot), containingType, TypeCompareKind.ConsiderEverything2));
+            Debug.Assert(TypeSymbol.Equals(NominalSlotType(containingSlot), containingType, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes));
 
             var getValue = (MethodSymbol)compilation.GetSpecialTypeMember(SpecialMember.System_Nullable_T_get_Value);
             valueProperty = getValue?.AsMember((NamedTypeSymbol)containingType)?.AssociatedSymbol;
@@ -9679,7 +10339,7 @@ private TypeWithState InferResultNullabilityOfBinaryLogicalOperator(BoundExpress
 
         public override BoundNode? VisitArgListOperator(BoundArgListOperator node)
         {
-            VisitArgumentsEvaluate(node.Arguments, node.ArgumentRefKindsOpt, parametersOpt: default, argsToParamsOpt: default, defaultArguments: default, expanded: false);
+            VisitArgumentsEvaluate(node.Arguments, node.ArgumentRefKindsOpt, parameterAnnotationsOpt: default, defaultArguments: default);
             Debug.Assert(node.Type is null);
             SetNotNullResult(node);
             return null;
@@ -9761,7 +10421,7 @@ private TypeWithState InferResultNullabilityOfBinaryLogicalOperator(BoundExpress
                 CheckPossibleNullReceiver(receiverOpt, receiverType, checkNullableValueType: false);
             }
 
-            VisitArgumentsEvaluate(node.Arguments, node.ArgumentRefKindsOpt, parametersOpt: default, argsToParamsOpt: default, defaultArguments: default, expanded: false);
+            VisitArgumentsEvaluate(node.Arguments, node.ArgumentRefKindsOpt, parameterAnnotationsOpt: default, defaultArguments: default);
             Debug.Assert(node.Type.IsDynamic());
             Debug.Assert(node.Type.IsReferenceType);
             var result = TypeWithAnnotations.Create(node.Type, NullableAnnotation.Oblivious);
@@ -9798,10 +10458,7 @@ private TypeWithState InferResultNullabilityOfBinaryLogicalOperator(BoundExpress
 
         public override BoundNode? VisitDynamicObjectCreationExpression(BoundDynamicObjectCreationExpression node)
         {
-            Debug.Assert(!IsConditionalState);
-            var arguments = node.Arguments;
-            var argumentResults = VisitArgumentsEvaluate(arguments, node.ArgumentRefKindsOpt, parametersOpt: default, argsToParamsOpt: default, defaultArguments: default, expanded: false);
-            VisitObjectOrDynamicObjectCreation(node, arguments, argumentResults, node.InitializerExpressionOpt);
+            VisitObjectCreationExpressionBase(node);
             return null;
         }
 
@@ -9843,14 +10500,13 @@ private TypeWithState InferResultNullabilityOfBinaryLogicalOperator(BoundExpress
 
         public override BoundNode? VisitNoPiaObjectCreationExpression(BoundNoPiaObjectCreationExpression node)
         {
-            Debug.Assert(!IsConditionalState);
-            VisitObjectOrDynamicObjectCreation(node, ImmutableArray<BoundExpression>.Empty, ImmutableArray<VisitArgumentResult>.Empty, node.InitializerExpressionOpt);
+            VisitObjectCreationExpressionBase(node);
             return null;
         }
 
         public override BoundNode? VisitNewT(BoundNewT node)
         {
-            VisitObjectOrDynamicObjectCreation(node, ImmutableArray<BoundExpression>.Empty, ImmutableArray<VisitArgumentResult>.Empty, node.InitializerExpressionOpt);
+            VisitObjectCreationExpressionBase(node);
             return null;
         }
 
@@ -9881,7 +10537,7 @@ private void SetUnknownResultNullability(BoundExpression expression)
             // https://github.com/dotnet/roslyn/issues/30598: Mark receiver as not null
             // after indices have been visited, and only if the receiver has not changed.
             _ = CheckPossibleNullReceiver(receiver);
-            VisitArgumentsEvaluate(node.Arguments, node.ArgumentRefKindsOpt, parametersOpt: default, argsToParamsOpt: default, defaultArguments: default, expanded: false);
+            VisitArgumentsEvaluate(node.Arguments, node.ArgumentRefKindsOpt, parameterAnnotationsOpt: default, defaultArguments: default);
             Debug.Assert(node.Type.IsDynamic());
             var result = TypeWithAnnotations.Create(node.Type, NullableAnnotation.Oblivious);
             SetLvalueResultType(node, result);
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker_Patterns.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker_Patterns.cs
index e0b105a93391b..bf798cf0a94a6 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker_Patterns.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker_Patterns.cs
@@ -856,7 +856,7 @@ private void VisitSwitchExpressionCore(BoundSwitchExpression node, bool inferTyp
 
             foreach (var arm in node.SwitchArms)
             {
-                SetState(getStateForArm(arm));
+                SetState(getStateForArm(arm, labelStateMap));
                 // https://github.com/dotnet/roslyn/issues/35836 Is this where we want to take the snapshot?
                 TakeIncrementalSnapshot(arm);
                 VisitPatternForRewriting(arm.Pattern);
@@ -872,6 +872,8 @@ private void VisitSwitchExpressionCore(BoundSwitchExpression node, bool inferTyp
                 placeholderBuilder.Add(CreatePlaceholderIfNecessary(expression, armType.ToTypeWithAnnotations(compilation)));
             }
 
+            SetState(endState);
+
             var placeholders = placeholderBuilder.ToImmutableAndFree();
             var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;
 
@@ -881,54 +883,92 @@ private void VisitSwitchExpressionCore(BoundSwitchExpression node, bool inferTyp
 
             var inferredTypeWithAnnotations = TypeWithAnnotations.Create(inferredType);
             NullableFlowState inferredState;
+            TypeWithState resultType;
 
-            if (inferType)
+            if (inferType && inferredType is null)
             {
-                if (inferredType is null)
-                {
-                    // This can happen when we're inferring the return type of a lambda, or when there are no arms (an error case).
-                    // For this case, we don't need to do any work, as the unconverted switch expression can't contribute info, and
-                    // there is nothing that is being publicly exposed to the semantic model.
-                    Debug.Assert((node is BoundUnconvertedSwitchExpression && _returnTypesOpt is not null)
-                                 || node is BoundSwitchExpression { SwitchArms: { Length: 0 } });
-                    inferredState = default;
-                }
-                else
+                // This can happen when we're inferring the return type of a lambda, or when there are no arms (an error case).
+                // For this case, we don't need to do any work, as the unconverted switch expression can't contribute info, and
+                // there is nothing that is being publicly exposed to the semantic model.
+                Debug.Assert((node is BoundUnconvertedSwitchExpression && _returnTypesOpt is not null)
+                                || node is BoundSwitchExpression { SwitchArms: { Length: 0 } });
+                inferredState = default;
+
+                resultType = TypeWithState.Create(inferredType, inferredState);
+
+                conversions.Free();
+                resultTypes.Free();
+                expressions.Free();
+                labelStateMap.Free();
+                SetResult(node, resultType, inferredTypeWithAnnotations);
+                return;
+            }
+
+            resultType = convertArms(node, labelStateMap, conversions, resultTypes, expressions, inferredTypeWithAnnotations, isTargetTyped: !inferType);
+
+            SetResult(node, resultType, inferredTypeWithAnnotations, updateAnalyzedNullability: false);
+            return;
+
+            TypeWithState convertArms(
+                BoundSwitchExpression node,
+                PooledDictionary<LabelSymbol, (LocalState state, bool believedReachable)> labelStateMap,
+                ArrayBuilder<Conversion> conversions,
+                ArrayBuilder<TypeWithState> resultTypes,
+                ArrayBuilder<BoundExpression> expressions,
+                TypeWithAnnotations inferredTypeWithAnnotations,
+                bool isTargetTyped)
+            {
+                if (!isTargetTyped)
                 {
+                    int numSwitchArms = node.SwitchArms.Length;
                     for (int i = 0; i < numSwitchArms; i++)
                     {
                         var nodeForSyntax = expressions[i];
                         var arm = node.SwitchArms[i];
-                        var armState = getStateForArm(arm);
+                        var armState = getStateForArm(arm, labelStateMap);
                         resultTypes[i] = ConvertConditionalOperandOrSwitchExpressionArmResult(arm.Value, nodeForSyntax, conversions[i], inferredTypeWithAnnotations, resultTypes[i], armState, armState.Reachable);
                     }
-                    inferredState = BestTypeInferrer.GetNullableState(resultTypes);
                 }
-            }
-            else
-            {
-                var states = ArrayBuilder<(LocalState, TypeWithState, bool)>.GetInstance(numSwitchArms);
-                for (int i = 0; i < numSwitchArms; i++)
+
+                NullableFlowState inferredState = BestTypeInferrer.GetNullableState(resultTypes);
+
+                if (!isTargetTyped)
+                {
+                    conversions.Free();
+                    resultTypes.Free();
+                    expressions.Free();
+                    labelStateMap.Free();
+                }
+                else
                 {
-                    var nodeForSyntax = expressions[i];
-                    var armState = getStateForArm(node.SwitchArms[i]);
-                    states.Add((armState, resultTypes[i], armState.Reachable));
+                    addConvertArmsAsCompletion(node, labelStateMap, conversions, resultTypes, expressions);
                 }
 
-                ConditionalInfoForConversion.Add(node, states.ToImmutableAndFree());
-                inferredState = BestTypeInferrer.GetNullableState(resultTypes);
-            }
+                TypeWithState resultType = TypeWithState.Create(inferredTypeWithAnnotations.Type, inferredState);
+
+                if (!isTargetTyped)
+                {
+                    SetAnalyzedNullability(node, resultType);
+                }
 
-            var resultType = TypeWithState.Create(inferredType, inferredState);
+                return resultType;
+            }
 
-            conversions.Free();
-            resultTypes.Free();
-            expressions.Free();
-            labelStateMap.Free();
-            SetState(endState);
-            SetResult(node, resultType, inferredTypeWithAnnotations);
+            void addConvertArmsAsCompletion(
+                BoundSwitchExpression node,
+                PooledDictionary<LabelSymbol, (LocalState state, bool believedReachable)> labelStateMap,
+                ArrayBuilder<Conversion> conversions,
+                ArrayBuilder<TypeWithState> resultTypes,
+                ArrayBuilder<BoundExpression> expressions)
+            {
+                TargetTypedAnalysisCompletion[node] =
+                    (TypeWithAnnotations inferredTypeWithAnnotations) =>
+                    {
+                        return convertArms(node, labelStateMap, conversions, resultTypes, expressions, inferredTypeWithAnnotations, isTargetTyped: false);
+                    };
+            }
 
-            LocalState getStateForArm(BoundSwitchExpressionArm arm)
+            LocalState getStateForArm(BoundSwitchExpressionArm arm, PooledDictionary<LabelSymbol, (LocalState state, bool believedReachable)> labelStateMap)
                 => !arm.Pattern.HasErrors && labelStateMap.TryGetValue(arm.Label, out var labelState) ? labelState.state : UnreachableState();
         }
 
diff --git a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
index 1c25197106e26..27917beaaab63 100644
--- a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
+++ b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
@@ -2025,8 +2025,8 @@ public BoundNullCoalescingAssignmentOperator Update(BoundExpression leftOperand,
 
     internal sealed partial class BoundUnconvertedConditionalOperator : BoundExpression
     {
-        public BoundUnconvertedConditionalOperator(SyntaxNode syntax, BoundExpression condition, BoundExpression consequence, BoundExpression alternative, ConstantValue? constantValueOpt, ErrorCode noCommonTypeError, TypeSymbol? type, bool hasErrors = false)
-            : base(BoundKind.UnconvertedConditionalOperator, syntax, type, hasErrors || condition.HasErrors() || consequence.HasErrors() || alternative.HasErrors())
+        public BoundUnconvertedConditionalOperator(SyntaxNode syntax, BoundExpression condition, BoundExpression consequence, BoundExpression alternative, ConstantValue? constantValueOpt, ErrorCode noCommonTypeError, bool hasErrors = false)
+            : base(BoundKind.UnconvertedConditionalOperator, syntax, null, hasErrors || condition.HasErrors() || consequence.HasErrors() || alternative.HasErrors())
         {
 
             RoslynDebug.Assert(condition is object, "Field 'condition' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
@@ -2041,6 +2041,8 @@ public BoundUnconvertedConditionalOperator(SyntaxNode syntax, BoundExpression co
         }
 
 
+        public new TypeSymbol? Type => base.Type;
+
         public BoundExpression Condition { get; }
 
         public BoundExpression Consequence { get; }
@@ -2053,11 +2055,11 @@ public BoundUnconvertedConditionalOperator(SyntaxNode syntax, BoundExpression co
         [DebuggerStepThrough]
         public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitUnconvertedConditionalOperator(this);
 
-        public BoundUnconvertedConditionalOperator Update(BoundExpression condition, BoundExpression consequence, BoundExpression alternative, ConstantValue? constantValueOpt, ErrorCode noCommonTypeError, TypeSymbol? type)
+        public BoundUnconvertedConditionalOperator Update(BoundExpression condition, BoundExpression consequence, BoundExpression alternative, ConstantValue? constantValueOpt, ErrorCode noCommonTypeError)
         {
-            if (condition != this.Condition || consequence != this.Consequence || alternative != this.Alternative || constantValueOpt != this.ConstantValueOpt || noCommonTypeError != this.NoCommonTypeError || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
+            if (condition != this.Condition || consequence != this.Consequence || alternative != this.Alternative || constantValueOpt != this.ConstantValueOpt || noCommonTypeError != this.NoCommonTypeError)
             {
-                var result = new BoundUnconvertedConditionalOperator(this.Syntax, condition, consequence, alternative, constantValueOpt, noCommonTypeError, type, this.HasErrors);
+                var result = new BoundUnconvertedConditionalOperator(this.Syntax, condition, consequence, alternative, constantValueOpt, noCommonTypeError, this.HasErrors);
                 result.CopyAttributes(this);
                 return result;
             }
@@ -6297,7 +6299,29 @@ public BoundUnconvertedObjectCreationExpression Update(ImmutableArray<BoundExpre
         }
     }
 
-    internal sealed partial class BoundObjectCreationExpression : BoundExpression
+    internal abstract partial class BoundObjectCreationExpressionBase : BoundExpression
+    {
+        protected BoundObjectCreationExpressionBase(BoundKind kind, SyntaxNode syntax, TypeSymbol type, bool hasErrors)
+            : base(kind, syntax, type, hasErrors)
+        {
+
+            RoslynDebug.Assert(type is object, "Field 'type' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+
+        }
+
+        protected BoundObjectCreationExpressionBase(BoundKind kind, SyntaxNode syntax, TypeSymbol type)
+            : base(kind, syntax, type)
+        {
+
+            RoslynDebug.Assert(type is object, "Field 'type' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+
+        }
+
+
+        public new TypeSymbol Type => base.Type!;
+    }
+
+    internal sealed partial class BoundObjectCreationExpression : BoundObjectCreationExpressionBase
     {
         public BoundObjectCreationExpression(SyntaxNode syntax, MethodSymbol constructor, ImmutableArray<MethodSymbol> constructorsGroup, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, BitVector defaultArguments, ConstantValue? constantValueOpt, BoundObjectInitializerExpressionBase? initializerExpressionOpt, bool wasTargetTyped, TypeSymbol type, bool hasErrors = false)
             : base(BoundKind.ObjectCreationExpression, syntax, type, hasErrors || arguments.HasErrors() || initializerExpressionOpt.HasErrors())
@@ -6308,43 +6332,50 @@ public BoundObjectCreationExpression(SyntaxNode syntax, MethodSymbol constructor
             RoslynDebug.Assert(!arguments.IsDefault, "Field 'arguments' cannot be null (use Null=\"allow\" in BoundNodes.xml to remove this check)");
             RoslynDebug.Assert(type is object, "Field 'type' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
 
-            this.Constructor = constructor;
+            this._Constructor = constructor;
             this.ConstructorsGroup = constructorsGroup;
-            this.Arguments = arguments;
-            this.ArgumentNamesOpt = argumentNamesOpt;
-            this.ArgumentRefKindsOpt = argumentRefKindsOpt;
-            this.Expanded = expanded;
-            this.ArgsToParamsOpt = argsToParamsOpt;
-            this.DefaultArguments = defaultArguments;
+            this._Arguments = arguments;
+            this._ArgumentNamesOpt = argumentNamesOpt;
+            this._ArgumentRefKindsOpt = argumentRefKindsOpt;
+            this._Expanded = expanded;
+            this._ArgsToParamsOpt = argsToParamsOpt;
+            this._DefaultArguments = defaultArguments;
             this.ConstantValueOpt = constantValueOpt;
-            this.InitializerExpressionOpt = initializerExpressionOpt;
-            this.WasTargetTyped = wasTargetTyped;
+            this._InitializerExpressionOpt = initializerExpressionOpt;
+            this._WasTargetTyped = wasTargetTyped;
         }
 
 
-        public new TypeSymbol Type => base.Type!;
-
-        public MethodSymbol Constructor { get; }
+        private readonly MethodSymbol _Constructor;
+        public override MethodSymbol Constructor { get { return _Constructor; } }
 
         public ImmutableArray<MethodSymbol> ConstructorsGroup { get; }
 
-        public ImmutableArray<BoundExpression> Arguments { get; }
+        private readonly ImmutableArray<BoundExpression> _Arguments;
+        public override ImmutableArray<BoundExpression> Arguments { get { return _Arguments; } }
 
-        public ImmutableArray<string> ArgumentNamesOpt { get; }
+        private readonly ImmutableArray<string> _ArgumentNamesOpt;
+        public override ImmutableArray<string> ArgumentNamesOpt { get { return _ArgumentNamesOpt; } }
 
-        public ImmutableArray<RefKind> ArgumentRefKindsOpt { get; }
+        private readonly ImmutableArray<RefKind> _ArgumentRefKindsOpt;
+        public override ImmutableArray<RefKind> ArgumentRefKindsOpt { get { return _ArgumentRefKindsOpt; } }
 
-        public bool Expanded { get; }
+        private readonly bool _Expanded;
+        public override bool Expanded { get { return _Expanded; } }
 
-        public ImmutableArray<int> ArgsToParamsOpt { get; }
+        private readonly ImmutableArray<int> _ArgsToParamsOpt;
+        public override ImmutableArray<int> ArgsToParamsOpt { get { return _ArgsToParamsOpt; } }
 
-        public BitVector DefaultArguments { get; }
+        private readonly BitVector _DefaultArguments;
+        public override BitVector DefaultArguments { get { return _DefaultArguments; } }
 
         public ConstantValue? ConstantValueOpt { get; }
 
-        public BoundObjectInitializerExpressionBase? InitializerExpressionOpt { get; }
+        private readonly BoundObjectInitializerExpressionBase? _InitializerExpressionOpt;
+        public override BoundObjectInitializerExpressionBase? InitializerExpressionOpt { get { return _InitializerExpressionOpt; } }
 
-        public bool WasTargetTyped { get; }
+        private readonly bool _WasTargetTyped;
+        public override bool WasTargetTyped { get { return _WasTargetTyped; } }
         [DebuggerStepThrough]
         public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitObjectCreationExpression(this);
 
@@ -6439,9 +6470,9 @@ public BoundConvertedTupleLiteral Update(BoundTupleLiteral? sourceTuple, bool wa
         }
     }
 
-    internal sealed partial class BoundDynamicObjectCreationExpression : BoundExpression
+    internal sealed partial class BoundDynamicObjectCreationExpression : BoundObjectCreationExpressionBase
     {
-        public BoundDynamicObjectCreationExpression(SyntaxNode syntax, string name, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, BoundObjectInitializerExpressionBase? initializerExpressionOpt, ImmutableArray<MethodSymbol> applicableMethods, TypeSymbol type, bool hasErrors = false)
+        public BoundDynamicObjectCreationExpression(SyntaxNode syntax, string name, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, BoundObjectInitializerExpressionBase? initializerExpressionOpt, ImmutableArray<MethodSymbol> applicableMethods, bool wasTargetTyped, TypeSymbol type, bool hasErrors = false)
             : base(BoundKind.DynamicObjectCreationExpression, syntax, type, hasErrors || arguments.HasErrors() || initializerExpressionOpt.HasErrors())
         {
 
@@ -6451,35 +6482,41 @@ public BoundDynamicObjectCreationExpression(SyntaxNode syntax, string name, Immu
             RoslynDebug.Assert(type is object, "Field 'type' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
 
             this.Name = name;
-            this.Arguments = arguments;
-            this.ArgumentNamesOpt = argumentNamesOpt;
-            this.ArgumentRefKindsOpt = argumentRefKindsOpt;
-            this.InitializerExpressionOpt = initializerExpressionOpt;
+            this._Arguments = arguments;
+            this._ArgumentNamesOpt = argumentNamesOpt;
+            this._ArgumentRefKindsOpt = argumentRefKindsOpt;
+            this._InitializerExpressionOpt = initializerExpressionOpt;
             this.ApplicableMethods = applicableMethods;
+            this._WasTargetTyped = wasTargetTyped;
         }
 
 
-        public new TypeSymbol Type => base.Type!;
-
         public string Name { get; }
 
-        public ImmutableArray<BoundExpression> Arguments { get; }
+        private readonly ImmutableArray<BoundExpression> _Arguments;
+        public override ImmutableArray<BoundExpression> Arguments { get { return _Arguments; } }
 
-        public ImmutableArray<string> ArgumentNamesOpt { get; }
+        private readonly ImmutableArray<string> _ArgumentNamesOpt;
+        public override ImmutableArray<string> ArgumentNamesOpt { get { return _ArgumentNamesOpt; } }
 
-        public ImmutableArray<RefKind> ArgumentRefKindsOpt { get; }
+        private readonly ImmutableArray<RefKind> _ArgumentRefKindsOpt;
+        public override ImmutableArray<RefKind> ArgumentRefKindsOpt { get { return _ArgumentRefKindsOpt; } }
 
-        public BoundObjectInitializerExpressionBase? InitializerExpressionOpt { get; }
+        private readonly BoundObjectInitializerExpressionBase? _InitializerExpressionOpt;
+        public override BoundObjectInitializerExpressionBase? InitializerExpressionOpt { get { return _InitializerExpressionOpt; } }
 
         public ImmutableArray<MethodSymbol> ApplicableMethods { get; }
+
+        private readonly bool _WasTargetTyped;
+        public override bool WasTargetTyped { get { return _WasTargetTyped; } }
         [DebuggerStepThrough]
         public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitDynamicObjectCreationExpression(this);
 
-        public BoundDynamicObjectCreationExpression Update(string name, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, BoundObjectInitializerExpressionBase? initializerExpressionOpt, ImmutableArray<MethodSymbol> applicableMethods, TypeSymbol type)
+        public BoundDynamicObjectCreationExpression Update(string name, ImmutableArray<BoundExpression> arguments, ImmutableArray<string> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, BoundObjectInitializerExpressionBase? initializerExpressionOpt, ImmutableArray<MethodSymbol> applicableMethods, bool wasTargetTyped, TypeSymbol type)
         {
-            if (name != this.Name || arguments != this.Arguments || argumentNamesOpt != this.ArgumentNamesOpt || argumentRefKindsOpt != this.ArgumentRefKindsOpt || initializerExpressionOpt != this.InitializerExpressionOpt || applicableMethods != this.ApplicableMethods || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
+            if (name != this.Name || arguments != this.Arguments || argumentNamesOpt != this.ArgumentNamesOpt || argumentRefKindsOpt != this.ArgumentRefKindsOpt || initializerExpressionOpt != this.InitializerExpressionOpt || applicableMethods != this.ApplicableMethods || wasTargetTyped != this.WasTargetTyped || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
             {
-                var result = new BoundDynamicObjectCreationExpression(this.Syntax, name, arguments, argumentNamesOpt, argumentRefKindsOpt, initializerExpressionOpt, applicableMethods, type, this.HasErrors);
+                var result = new BoundDynamicObjectCreationExpression(this.Syntax, name, arguments, argumentNamesOpt, argumentRefKindsOpt, initializerExpressionOpt, applicableMethods, wasTargetTyped, type, this.HasErrors);
                 result.CopyAttributes(this);
                 return result;
             }
@@ -6487,32 +6524,35 @@ public BoundDynamicObjectCreationExpression Update(string name, ImmutableArray<B
         }
     }
 
-    internal sealed partial class BoundNoPiaObjectCreationExpression : BoundExpression
+    internal sealed partial class BoundNoPiaObjectCreationExpression : BoundObjectCreationExpressionBase
     {
-        public BoundNoPiaObjectCreationExpression(SyntaxNode syntax, string? guidString, BoundObjectInitializerExpressionBase? initializerExpressionOpt, TypeSymbol type, bool hasErrors = false)
+        public BoundNoPiaObjectCreationExpression(SyntaxNode syntax, string? guidString, BoundObjectInitializerExpressionBase? initializerExpressionOpt, bool wasTargetTyped, TypeSymbol type, bool hasErrors = false)
             : base(BoundKind.NoPiaObjectCreationExpression, syntax, type, hasErrors || initializerExpressionOpt.HasErrors())
         {
 
             RoslynDebug.Assert(type is object, "Field 'type' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
 
             this.GuidString = guidString;
-            this.InitializerExpressionOpt = initializerExpressionOpt;
+            this._InitializerExpressionOpt = initializerExpressionOpt;
+            this._WasTargetTyped = wasTargetTyped;
         }
 
 
-        public new TypeSymbol Type => base.Type!;
-
         public string? GuidString { get; }
 
-        public BoundObjectInitializerExpressionBase? InitializerExpressionOpt { get; }
+        private readonly BoundObjectInitializerExpressionBase? _InitializerExpressionOpt;
+        public override BoundObjectInitializerExpressionBase? InitializerExpressionOpt { get { return _InitializerExpressionOpt; } }
+
+        private readonly bool _WasTargetTyped;
+        public override bool WasTargetTyped { get { return _WasTargetTyped; } }
         [DebuggerStepThrough]
         public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitNoPiaObjectCreationExpression(this);
 
-        public BoundNoPiaObjectCreationExpression Update(string? guidString, BoundObjectInitializerExpressionBase? initializerExpressionOpt, TypeSymbol type)
+        public BoundNoPiaObjectCreationExpression Update(string? guidString, BoundObjectInitializerExpressionBase? initializerExpressionOpt, bool wasTargetTyped, TypeSymbol type)
         {
-            if (guidString != this.GuidString || initializerExpressionOpt != this.InitializerExpressionOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
+            if (guidString != this.GuidString || initializerExpressionOpt != this.InitializerExpressionOpt || wasTargetTyped != this.WasTargetTyped || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
             {
-                var result = new BoundNoPiaObjectCreationExpression(this.Syntax, guidString, initializerExpressionOpt, type, this.HasErrors);
+                var result = new BoundNoPiaObjectCreationExpression(this.Syntax, guidString, initializerExpressionOpt, wasTargetTyped, type, this.HasErrors);
                 result.CopyAttributes(this);
                 return result;
             }
@@ -6902,29 +6942,32 @@ public BoundAnonymousPropertyDeclaration Update(PropertySymbol property, TypeSym
         }
     }
 
-    internal sealed partial class BoundNewT : BoundExpression
+    internal sealed partial class BoundNewT : BoundObjectCreationExpressionBase
     {
-        public BoundNewT(SyntaxNode syntax, BoundObjectInitializerExpressionBase? initializerExpressionOpt, TypeSymbol type, bool hasErrors = false)
+        public BoundNewT(SyntaxNode syntax, BoundObjectInitializerExpressionBase? initializerExpressionOpt, bool wasTargetTyped, TypeSymbol type, bool hasErrors = false)
             : base(BoundKind.NewT, syntax, type, hasErrors || initializerExpressionOpt.HasErrors())
         {
 
             RoslynDebug.Assert(type is object, "Field 'type' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
 
-            this.InitializerExpressionOpt = initializerExpressionOpt;
+            this._InitializerExpressionOpt = initializerExpressionOpt;
+            this._WasTargetTyped = wasTargetTyped;
         }
 
 
-        public new TypeSymbol Type => base.Type!;
+        private readonly BoundObjectInitializerExpressionBase? _InitializerExpressionOpt;
+        public override BoundObjectInitializerExpressionBase? InitializerExpressionOpt { get { return _InitializerExpressionOpt; } }
 
-        public BoundObjectInitializerExpressionBase? InitializerExpressionOpt { get; }
+        private readonly bool _WasTargetTyped;
+        public override bool WasTargetTyped { get { return _WasTargetTyped; } }
         [DebuggerStepThrough]
         public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitNewT(this);
 
-        public BoundNewT Update(BoundObjectInitializerExpressionBase? initializerExpressionOpt, TypeSymbol type)
+        public BoundNewT Update(BoundObjectInitializerExpressionBase? initializerExpressionOpt, bool wasTargetTyped, TypeSymbol type)
         {
-            if (initializerExpressionOpt != this.InitializerExpressionOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
+            if (initializerExpressionOpt != this.InitializerExpressionOpt || wasTargetTyped != this.WasTargetTyped || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
             {
-                var result = new BoundNewT(this.Syntax, initializerExpressionOpt, type, this.HasErrors);
+                var result = new BoundNewT(this.Syntax, initializerExpressionOpt, wasTargetTyped, type, this.HasErrors);
                 result.CopyAttributes(this);
                 return result;
             }
@@ -6934,7 +6977,7 @@ public BoundNewT Update(BoundObjectInitializerExpressionBase? initializerExpress
 
     internal sealed partial class BoundDelegateCreationExpression : BoundExpression
     {
-        public BoundDelegateCreationExpression(SyntaxNode syntax, BoundExpression argument, MethodSymbol? methodOpt, bool isExtensionMethod, TypeSymbol type, bool hasErrors = false)
+        public BoundDelegateCreationExpression(SyntaxNode syntax, BoundExpression argument, MethodSymbol? methodOpt, bool isExtensionMethod, bool wasTargetTyped, TypeSymbol type, bool hasErrors = false)
             : base(BoundKind.DelegateCreationExpression, syntax, type, hasErrors || argument.HasErrors())
         {
 
@@ -6944,6 +6987,7 @@ public BoundDelegateCreationExpression(SyntaxNode syntax, BoundExpression argume
             this.Argument = argument;
             this.MethodOpt = methodOpt;
             this.IsExtensionMethod = isExtensionMethod;
+            this.WasTargetTyped = wasTargetTyped;
         }
 
 
@@ -6954,14 +6998,16 @@ public BoundDelegateCreationExpression(SyntaxNode syntax, BoundExpression argume
         public MethodSymbol? MethodOpt { get; }
 
         public bool IsExtensionMethod { get; }
+
+        public bool WasTargetTyped { get; }
         [DebuggerStepThrough]
         public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitDelegateCreationExpression(this);
 
-        public BoundDelegateCreationExpression Update(BoundExpression argument, MethodSymbol? methodOpt, bool isExtensionMethod, TypeSymbol type)
+        public BoundDelegateCreationExpression Update(BoundExpression argument, MethodSymbol? methodOpt, bool isExtensionMethod, bool wasTargetTyped, TypeSymbol type)
         {
-            if (argument != this.Argument || !Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(methodOpt, this.MethodOpt) || isExtensionMethod != this.IsExtensionMethod || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
+            if (argument != this.Argument || !Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(methodOpt, this.MethodOpt) || isExtensionMethod != this.IsExtensionMethod || wasTargetTyped != this.WasTargetTyped || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
             {
-                var result = new BoundDelegateCreationExpression(this.Syntax, argument, methodOpt, isExtensionMethod, type, this.HasErrors);
+                var result = new BoundDelegateCreationExpression(this.Syntax, argument, methodOpt, isExtensionMethod, wasTargetTyped, type, this.HasErrors);
                 result.CopyAttributes(this);
                 return result;
             }
@@ -10872,7 +10918,7 @@ internal abstract partial class BoundTreeRewriter : BoundTreeVisitor
             BoundExpression consequence = (BoundExpression)this.Visit(node.Consequence);
             BoundExpression alternative = (BoundExpression)this.Visit(node.Alternative);
             TypeSymbol? type = this.VisitType(node.Type);
-            return node.Update(condition, consequence, alternative, node.ConstantValueOpt, node.NoCommonTypeError, type);
+            return node.Update(condition, consequence, alternative, node.ConstantValueOpt, node.NoCommonTypeError);
         }
         public override BoundNode? VisitConditionalOperator(BoundConditionalOperator node)
         {
@@ -11533,13 +11579,13 @@ internal abstract partial class BoundTreeRewriter : BoundTreeVisitor
             ImmutableArray<BoundExpression> arguments = this.VisitList(node.Arguments);
             BoundObjectInitializerExpressionBase? initializerExpressionOpt = (BoundObjectInitializerExpressionBase?)this.Visit(node.InitializerExpressionOpt);
             TypeSymbol? type = this.VisitType(node.Type);
-            return node.Update(node.Name, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, initializerExpressionOpt, node.ApplicableMethods, type);
+            return node.Update(node.Name, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, initializerExpressionOpt, node.ApplicableMethods, node.WasTargetTyped, type);
         }
         public override BoundNode? VisitNoPiaObjectCreationExpression(BoundNoPiaObjectCreationExpression node)
         {
             BoundObjectInitializerExpressionBase? initializerExpressionOpt = (BoundObjectInitializerExpressionBase?)this.Visit(node.InitializerExpressionOpt);
             TypeSymbol? type = this.VisitType(node.Type);
-            return node.Update(node.GuidString, initializerExpressionOpt, type);
+            return node.Update(node.GuidString, initializerExpressionOpt, node.WasTargetTyped, type);
         }
         public override BoundNode? VisitObjectInitializerExpression(BoundObjectInitializerExpression node)
         {
@@ -11603,13 +11649,13 @@ internal abstract partial class BoundTreeRewriter : BoundTreeVisitor
         {
             BoundObjectInitializerExpressionBase? initializerExpressionOpt = (BoundObjectInitializerExpressionBase?)this.Visit(node.InitializerExpressionOpt);
             TypeSymbol? type = this.VisitType(node.Type);
-            return node.Update(initializerExpressionOpt, type);
+            return node.Update(initializerExpressionOpt, node.WasTargetTyped, type);
         }
         public override BoundNode? VisitDelegateCreationExpression(BoundDelegateCreationExpression node)
         {
             BoundExpression argument = (BoundExpression)this.Visit(node.Argument);
             TypeSymbol? type = this.VisitType(node.Type);
-            return node.Update(argument, node.MethodOpt, node.IsExtensionMethod, type);
+            return node.Update(argument, node.MethodOpt, node.IsExtensionMethod, node.WasTargetTyped, type);
         }
         public override BoundNode? VisitArrayCreation(BoundArrayCreation node)
         {
@@ -12552,12 +12598,12 @@ public NullabilityRewriter(ImmutableDictionary<BoundExpression, (NullabilityInfo
 
             if (_updatedNullabilities.TryGetValue(node, out (NullabilityInfo Info, TypeSymbol? Type) infoAndType))
             {
-                updatedNode = node.Update(condition, consequence, alternative, node.ConstantValueOpt, node.NoCommonTypeError, infoAndType.Type);
+                updatedNode = node.Update(condition, consequence, alternative, node.ConstantValueOpt, node.NoCommonTypeError);
                 updatedNode.TopLevelNullability = infoAndType.Info;
             }
             else
             {
-                updatedNode = node.Update(condition, consequence, alternative, node.ConstantValueOpt, node.NoCommonTypeError, node.Type);
+                updatedNode = node.Update(condition, consequence, alternative, node.ConstantValueOpt, node.NoCommonTypeError);
             }
             return updatedNode;
         }
@@ -13655,12 +13701,12 @@ public NullabilityRewriter(ImmutableDictionary<BoundExpression, (NullabilityInfo
 
             if (_updatedNullabilities.TryGetValue(node, out (NullabilityInfo Info, TypeSymbol? Type) infoAndType))
             {
-                updatedNode = node.Update(node.Name, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, initializerExpressionOpt, applicableMethods, infoAndType.Type!);
+                updatedNode = node.Update(node.Name, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, initializerExpressionOpt, applicableMethods, node.WasTargetTyped, infoAndType.Type!);
                 updatedNode.TopLevelNullability = infoAndType.Info;
             }
             else
             {
-                updatedNode = node.Update(node.Name, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, initializerExpressionOpt, applicableMethods, node.Type);
+                updatedNode = node.Update(node.Name, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, initializerExpressionOpt, applicableMethods, node.WasTargetTyped, node.Type);
             }
             return updatedNode;
         }
@@ -13672,12 +13718,12 @@ public NullabilityRewriter(ImmutableDictionary<BoundExpression, (NullabilityInfo
 
             if (_updatedNullabilities.TryGetValue(node, out (NullabilityInfo Info, TypeSymbol? Type) infoAndType))
             {
-                updatedNode = node.Update(node.GuidString, initializerExpressionOpt, infoAndType.Type!);
+                updatedNode = node.Update(node.GuidString, initializerExpressionOpt, node.WasTargetTyped, infoAndType.Type!);
                 updatedNode.TopLevelNullability = infoAndType.Info;
             }
             else
             {
-                updatedNode = node.Update(node.GuidString, initializerExpressionOpt, node.Type);
+                updatedNode = node.Update(node.GuidString, initializerExpressionOpt, node.WasTargetTyped, node.Type);
             }
             return updatedNode;
         }
@@ -13847,12 +13893,12 @@ public NullabilityRewriter(ImmutableDictionary<BoundExpression, (NullabilityInfo
 
             if (_updatedNullabilities.TryGetValue(node, out (NullabilityInfo Info, TypeSymbol? Type) infoAndType))
             {
-                updatedNode = node.Update(initializerExpressionOpt, infoAndType.Type!);
+                updatedNode = node.Update(initializerExpressionOpt, node.WasTargetTyped, infoAndType.Type!);
                 updatedNode.TopLevelNullability = infoAndType.Info;
             }
             else
             {
-                updatedNode = node.Update(initializerExpressionOpt, node.Type);
+                updatedNode = node.Update(initializerExpressionOpt, node.WasTargetTyped, node.Type);
             }
             return updatedNode;
         }
@@ -13865,12 +13911,12 @@ public NullabilityRewriter(ImmutableDictionary<BoundExpression, (NullabilityInfo
 
             if (_updatedNullabilities.TryGetValue(node, out (NullabilityInfo Info, TypeSymbol? Type) infoAndType))
             {
-                updatedNode = node.Update(argument, methodOpt, node.IsExtensionMethod, infoAndType.Type!);
+                updatedNode = node.Update(argument, methodOpt, node.IsExtensionMethod, node.WasTargetTyped, infoAndType.Type!);
                 updatedNode.TopLevelNullability = infoAndType.Info;
             }
             else
             {
-                updatedNode = node.Update(argument, methodOpt, node.IsExtensionMethod, node.Type);
+                updatedNode = node.Update(argument, methodOpt, node.IsExtensionMethod, node.WasTargetTyped, node.Type);
             }
             return updatedNode;
         }
@@ -15925,6 +15971,7 @@ private BoundTreeDumperNodeProducer()
             new TreeDumperNode("argumentRefKindsOpt", node.ArgumentRefKindsOpt, null),
             new TreeDumperNode("initializerExpressionOpt", null, new TreeDumperNode[] { Visit(node.InitializerExpressionOpt, null) }),
             new TreeDumperNode("applicableMethods", node.ApplicableMethods, null),
+            new TreeDumperNode("wasTargetTyped", node.WasTargetTyped, null),
             new TreeDumperNode("type", node.Type, null),
             new TreeDumperNode("isSuppressed", node.IsSuppressed, null),
             new TreeDumperNode("hasErrors", node.HasErrors, null)
@@ -15934,6 +15981,7 @@ private BoundTreeDumperNodeProducer()
         {
             new TreeDumperNode("guidString", node.GuidString, null),
             new TreeDumperNode("initializerExpressionOpt", null, new TreeDumperNode[] { Visit(node.InitializerExpressionOpt, null) }),
+            new TreeDumperNode("wasTargetTyped", node.WasTargetTyped, null),
             new TreeDumperNode("type", node.Type, null),
             new TreeDumperNode("isSuppressed", node.IsSuppressed, null),
             new TreeDumperNode("hasErrors", node.HasErrors, null)
@@ -16035,6 +16083,7 @@ private BoundTreeDumperNodeProducer()
         public override TreeDumperNode VisitNewT(BoundNewT node, object? arg) => new TreeDumperNode("newT", null, new TreeDumperNode[]
         {
             new TreeDumperNode("initializerExpressionOpt", null, new TreeDumperNode[] { Visit(node.InitializerExpressionOpt, null) }),
+            new TreeDumperNode("wasTargetTyped", node.WasTargetTyped, null),
             new TreeDumperNode("type", node.Type, null),
             new TreeDumperNode("isSuppressed", node.IsSuppressed, null),
             new TreeDumperNode("hasErrors", node.HasErrors, null)
@@ -16045,6 +16094,7 @@ private BoundTreeDumperNodeProducer()
             new TreeDumperNode("argument", null, new TreeDumperNode[] { Visit(node.Argument, null) }),
             new TreeDumperNode("methodOpt", node.MethodOpt, null),
             new TreeDumperNode("isExtensionMethod", node.IsExtensionMethod, null),
+            new TreeDumperNode("wasTargetTyped", node.WasTargetTyped, null),
             new TreeDumperNode("type", node.Type, null),
             new TreeDumperNode("isSuppressed", node.IsSuppressed, null),
             new TreeDumperNode("hasErrors", node.HasErrors, null)
diff --git a/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/ClosureConversion.cs b/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/ClosureConversion.cs
index 9b79354cafa3b..12d57dc046f65 100644
--- a/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/ClosureConversion.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/ClosureConversion.cs
@@ -1309,6 +1309,7 @@ public override BoundNode VisitDelegateCreationExpression(BoundDelegateCreationE
                     receiver,
                     method,
                     node.IsExtensionMethod,
+                    node.WasTargetTyped,
                     VisitType(node.Type));
             }
             return base.VisitDelegateCreationExpression(node);
@@ -1606,6 +1607,7 @@ private BoundNode RewriteLambdaConversion(BoundLambda node)
                 receiver,
                 referencedMethod,
                 isExtensionMethod: false,
+                wasTargetTyped: false,
                 type: type);
 
             // if the block containing the lambda is not the innermost block,
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
index 8bf9121b538ec..e1d2ce2eb3d0d 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
@@ -31,10 +31,29 @@ public override BoundNode VisitConversion(BoundConversion node)
 
                     InterpolationHandlerResult interpolationResult = RewriteToInterpolatedStringHandlerPattern(data, parts, node.Operand.Syntax);
                     return interpolationResult.WithFinalResult(interpolationResult.HandlerTemp);
-                case ConversionKind.SwitchExpression or ConversionKind.ConditionalExpression:
-                    // Skip through target-typed conditionals and switches
-                    Debug.Assert(node.Operand is BoundConditionalOperator { WasTargetTyped: true } or BoundConvertedSwitchExpression { WasTargetTyped: true });
+                case ConversionKind.SwitchExpression:
+                    // Skip through target-typed switches
+                    Debug.Assert(node.Operand is BoundConvertedSwitchExpression { WasTargetTyped: true });
                     return Visit(node.Operand)!;
+                case ConversionKind.ConditionalExpression:
+                    // Skip through target-typed conditionals
+                    Debug.Assert(node.Operand is BoundConditionalOperator { WasTargetTyped: true });
+                    return Visit(node.Operand)!;
+                case ConversionKind.ObjectCreation:
+                    // Skip through target-typed new
+                    Debug.Assert(node.Operand is not null);
+                    var objectCreation = VisitExpression(node.Operand);
+
+                    if (node.Type.IsNullableType())
+                    {
+                        Debug.Assert(node.Operand is BoundObjectCreationExpressionBase { WasTargetTyped: true });
+                        return ConvertToNullable(node.Syntax, node.Type, objectCreation);
+                    }
+
+                    Debug.Assert(node.Operand is BoundObjectCreationExpressionBase { WasTargetTyped: true } or
+                                                 BoundDelegateCreationExpression { WasTargetTyped: true });
+
+                    return objectCreation;
             }
 
             var rewrittenType = VisitType(node.Type);
@@ -407,7 +426,7 @@ private BoundExpression MakeConversionNodeCore(
                         Debug.Assert(receiver is { });
                         _factory.Syntax = oldSyntax;
                         return new BoundDelegateCreationExpression(syntax, argument: receiver, methodOpt: method,
-                                                                   isExtensionMethod: oldNodeOpt.IsExtensionMethod, type: rewrittenType);
+                                                                   isExtensionMethod: oldNodeOpt.IsExtensionMethod, wasTargetTyped: false, type: rewrittenType);
                     }
                 default:
                     break;
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_DelegateCreationExpression.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_DelegateCreationExpression.cs
index de93a6632a1a2..4b5b66a245b6f 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_DelegateCreationExpression.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_DelegateCreationExpression.cs
@@ -20,7 +20,7 @@ public override BoundNode VisitDelegateCreationExpression(BoundDelegateCreationE
                 // Creates a delegate whose instance is the delegate that is returned by the call-site and the method is Invoke.
                 var loweredReceiver = _dynamicFactory.MakeDynamicConversion(loweredArgument, isExplicit: false, isArrayIndex: false, isChecked: false, resultType: node.Type).ToExpression();
 
-                return new BoundDelegateCreationExpression(node.Syntax, loweredReceiver, methodOpt: null, isExtensionMethod: false, type: node.Type);
+                return new BoundDelegateCreationExpression(node.Syntax, loweredReceiver, methodOpt: null, isExtensionMethod: false, node.WasTargetTyped, type: node.Type);
             }
 
             if (node.Argument.Kind == BoundKind.MethodGroup)
@@ -32,7 +32,7 @@ public override BoundNode VisitDelegateCreationExpression(BoundDelegateCreationE
                 _factory.Syntax = (mg.ReceiverOpt ?? mg).Syntax;
                 var receiver = (!method.RequiresInstanceReceiver && !node.IsExtensionMethod && !method.IsAbstract) ? _factory.Type(method.ContainingType) : VisitExpression(mg.ReceiverOpt)!;
                 _factory.Syntax = oldSyntax;
-                return node.Update(receiver, method, node.IsExtensionMethod, node.Type);
+                return node.Update(receiver, method, node.IsExtensionMethod, node.WasTargetTyped, node.Type);
             }
 
             return base.VisitDelegateCreationExpression(node)!;
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Event.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Event.cs
index a7a0ece2c831c..1f92b4e24f4c3 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Event.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Event.cs
@@ -97,6 +97,7 @@ private BoundExpression RewriteWindowsRuntimeEventAssignmentOperator(SyntaxNode
                 argument: delegateCreationArgument,
                 methodOpt: eventSymbol.RemoveMethod,
                 isExtensionMethod: false,
+                wasTargetTyped: false,
                 type: actionType);
 
             BoundExpression? clearCall = null;
@@ -134,6 +135,7 @@ private BoundExpression RewriteWindowsRuntimeEventAssignmentOperator(SyntaxNode
                     argument: delegateCreationArgument,
                     methodOpt: eventSymbol.AddMethod,
                     isExtensionMethod: false,
+                    wasTargetTyped: false,
                     type: func2Type);
 
                 helper = WellKnownMember.System_Runtime_InteropServices_WindowsRuntime_WindowsRuntimeMarshal__AddEventHandler_T;
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Index.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Index.cs
index 37964e34a8a06..a7025041027e3 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Index.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Index.cs
@@ -42,13 +42,8 @@ public override BoundNode VisitFromEndIndexExpression(BoundFromEndIndexExpressio
             BoundExpression boundOperandGetValueOrDefault = MakeOptimizedGetValueOrDefault(operand.Syntax, operand);
             BoundExpression indexCreation = new BoundObjectCreationExpression(node.Syntax, node.MethodOpt, boundOperandGetValueOrDefault, fromEnd);
 
-            if (!TryGetNullableMethod(node.Syntax, node.Type, SpecialMember.System_Nullable_T__ctor, out MethodSymbol nullableCtor))
-            {
-                return BadExpression(node.Syntax, node.Type, operand);
-            }
-
             // new Nullable(new Index(operand, fromEnd: true))
-            BoundExpression consequence = new BoundObjectCreationExpression(node.Syntax, nullableCtor, indexCreation);
+            BoundExpression consequence = ConvertToNullable(node.Syntax, node.Type, indexCreation);
 
             // default
             BoundExpression alternative = new BoundDefaultExpression(node.Syntax, node.Type);
@@ -70,5 +65,18 @@ public override BoundNode VisitFromEndIndexExpression(BoundFromEndIndexExpressio
                 value: conditionalExpression,
                 type: node.Type);
         }
+
+        private BoundExpression ConvertToNullable(SyntaxNode syntax, TypeSymbol targetNullableType, BoundExpression underlyingValue)
+        {
+            Debug.Assert(targetNullableType.IsNullableType());
+            Debug.Assert(TypeSymbol.Equals(targetNullableType.GetNullableUnderlyingType(), underlyingValue.Type, TypeCompareKind.AllIgnoreOptions));
+
+            if (!TryGetNullableMethod(syntax, targetNullableType, SpecialMember.System_Nullable_T__ctor, out MethodSymbol nullableCtor))
+            {
+                return BadExpression(syntax, targetNullableType, underlyingValue);
+            }
+
+            return new BoundObjectCreationExpression(syntax, nullableCtor, underlyingValue);
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs
index a251533a662c9..7ad82ed7612bf 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs
@@ -291,7 +291,7 @@ public override BoundNode VisitNewT(BoundNewT node)
         {
             if (_inExpressionLambda)
             {
-                return node.Update(MakeObjectCreationInitializerForExpressionTree(node.InitializerExpressionOpt), node.Type);
+                return node.Update(MakeObjectCreationInitializerForExpressionTree(node.InitializerExpressionOpt), node.WasTargetTyped, node.Type);
             }
 
             var rewrittenNewT = MakeNewT(node.Syntax, (TypeParameterSymbol)node.Type);
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Range.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Range.cs
index c7e1b1e8b8aab..f455170cd3921 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Range.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Range.cs
@@ -43,12 +43,7 @@ public override BoundNode VisitRangeExpression(BoundRangeExpression node)
 
                 if (node.Type.IsNullableType())
                 {
-                    if (!TryGetNullableMethod(node.Syntax, node.Type, SpecialMember.System_Nullable_T__ctor, out MethodSymbol nullableCtor))
-                    {
-                        return BadExpression(node.Syntax, node.Type, node);
-                    }
-
-                    return new BoundObjectCreationExpression(node.Syntax, nullableCtor, rangeCreation);
+                    return ConvertToNullable(node.Syntax, node.Type, rangeCreation);
                 }
 
                 return rangeCreation;
diff --git a/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs
index 7baa20538ccd5..764a96902242f 100644
--- a/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs
@@ -552,7 +552,7 @@ public override BoundNode VisitDelegateCreationExpression(BoundDelegateCreationE
             }
             method = VisitMethodSymbol(method);
             TypeSymbol type = this.VisitType(node.Type);
-            return node.Update(rewrittenArgument, method, node.IsExtensionMethod, type);
+            return node.Update(rewrittenArgument, method, node.IsExtensionMethod, node.WasTargetTyped, type);
         }
 
         public override BoundNode VisitFunctionPointerLoad(BoundFunctionPointerLoad node)
diff --git a/src/Compilers/CSharp/Portable/Lowering/SpillSequenceSpiller.cs b/src/Compilers/CSharp/Portable/Lowering/SpillSequenceSpiller.cs
index 92f7efb15d7d9..c235cf371059b 100644
--- a/src/Compilers/CSharp/Portable/Lowering/SpillSequenceSpiller.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/SpillSequenceSpiller.cs
@@ -968,7 +968,7 @@ public override BoundNode VisitDelegateCreationExpression(BoundDelegateCreationE
         {
             BoundSpillSequenceBuilder builder = null;
             var argument = VisitExpression(ref builder, node.Argument);
-            return UpdateExpression(builder, node.Update(argument, node.MethodOpt, node.IsExtensionMethod, node.Type));
+            return UpdateExpression(builder, node.Update(argument, node.MethodOpt, node.IsExtensionMethod, node.WasTargetTyped, node.Type));
         }
 
         public override BoundNode VisitFieldAccess(BoundFieldAccess node)
diff --git a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt
index e002a91e8bd99..b5c745565d45f 100644
--- a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt
+++ b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt
@@ -3,6 +3,7 @@ abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.ColonTok
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.Expression.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax!
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.File.get -> Microsoft.CodeAnalysis.SyntaxToken
 abstract Microsoft.CodeAnalysis.CSharp.Syntax.LineOrSpanDirectiveTriviaSyntax.LineKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken
+Microsoft.CodeAnalysis.CSharp.Conversion.IsObjectCreation.get -> bool
 Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp10 = 1000 -> Microsoft.CodeAnalysis.CSharp.LanguageVersion
 Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax.WithColonToken(Microsoft.CodeAnalysis.SyntaxToken colonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax!
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs b/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs
index d68437362abfb..32672fd8b9a71 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs
@@ -636,7 +636,8 @@ internal static bool ReportDefaultParameterErrors(
 
                 hasErrors = true;
             }
-            else if (conversion.IsNullable && !defaultExpression.Type.IsNullableType() &&
+            else if (((conversion.IsNullable && !defaultExpression.Type.IsNullableType()) ||
+                      (conversion.IsObjectCreation && convertedExpression.Type.IsNullableType())) &&
                 !(parameterType.GetNullableUnderlyingType().IsEnumType() || parameterType.GetNullableUnderlyingType().IsIntrinsicType()))
             {
                 // We can do:
@@ -653,7 +654,7 @@ internal static bool ReportDefaultParameterErrors(
                 // error CS1770: 
                 // A value of type '{0}' cannot be used as default parameter for nullable parameter '{1}' because '{0}' is not a simple type
                 diagnostics.Add(ErrorCode.ERR_NoConversionForNubDefaultParam, parameterSyntax.Identifier.GetLocation(),
-                    defaultExpression.Type, parameterSyntax.Identifier.ValueText);
+                    (defaultExpression.IsImplicitObjectCreation() ? convertedExpression.Type.StrippedType() : defaultExpression.Type), parameterSyntax.Identifier.ValueText);
 
                 hasErrors = true;
             }
@@ -708,18 +709,20 @@ private static bool IsValidDefaultValue(BoundExpression expression)
             {
                 return true;
             }
-            while (true)
+
+            switch (expression.Kind)
             {
-                switch (expression.Kind)
-                {
-                    case BoundKind.DefaultLiteral:
-                    case BoundKind.DefaultExpression:
-                        return true;
-                    case BoundKind.ObjectCreationExpression:
-                        return IsValidDefaultValue((BoundObjectCreationExpression)expression);
-                    default:
-                        return false;
-                }
+                case BoundKind.DefaultLiteral:
+                case BoundKind.DefaultExpression:
+                    return true;
+                case BoundKind.ObjectCreationExpression:
+                    return IsValidDefaultValue((BoundObjectCreationExpression)expression);
+                case BoundKind.Conversion:
+                    var conversion = (BoundConversion)expression;
+                    return conversion is { Conversion.IsObjectCreation: true, Operand: BoundObjectCreationExpression { WasTargetTyped: true } operand } &&
+                           IsValidDefaultValue(operand);
+                default:
+                    return false;
             }
         }
 
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IObjectCreationExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IObjectCreationExpression.cs
index a5381332e247c..9addd99965d97 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IObjectCreationExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IObjectCreationExpression.cs
@@ -48,105 +48,117 @@ void M()
     IVariableDeclarationOperation (1 declarators) (OperationKind.VariableDeclaration, Type: null) (Syntax: 'C x1 = new(3, 4)')
       Declarators:
           IVariableDeclaratorOperation (Symbol: C x1) (OperationKind.VariableDeclarator, Type: null) (Syntax: 'x1 = new(3, 4)')
-            Initializer: 
+            Initializer:
               IVariableInitializerOperation (OperationKind.VariableInitializer, Type: null) (Syntax: '= new(3, 4)')
-                IObjectCreationOperation (Constructor: C..ctor(System.Byte i, System.Int64 j)) (OperationKind.ObjectCreation, Type: C) (Syntax: 'new(3, 4)')
-                  Arguments(2):
-                      IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: i) (OperationKind.Argument, Type: null) (Syntax: '3')
-                        IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Byte, Constant: 3, IsImplicit) (Syntax: '3')
-                          Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
-                          Operand: 
-                            ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 3) (Syntax: '3')
-                        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)
-                      IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: j) (OperationKind.Argument, Type: null) (Syntax: '4')
-                        IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Int64, Constant: 4, IsImplicit) (Syntax: '4')
-                          Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: True, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
-                          Operand: 
-                            ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 4) (Syntax: '4')
-                        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)
-                  Initializer: 
-                    null
-      Initializer: 
+                IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: C, IsImplicit) (Syntax: 'new(3, 4)')
+                  Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                  Operand:
+                    IObjectCreationOperation (Constructor: C..ctor(System.Byte i, System.Int64 j)) (OperationKind.ObjectCreation, Type: C) (Syntax: 'new(3, 4)')
+                      Arguments(2):
+                          IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: i) (OperationKind.Argument, Type: null) (Syntax: '3')
+                            IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Byte, Constant: 3, IsImplicit) (Syntax: '3')
+                              Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                              Operand:
+                                ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 3) (Syntax: '3')
+                            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)
+                          IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: j) (OperationKind.Argument, Type: null) (Syntax: '4')
+                            IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Int64, Constant: 4, IsImplicit) (Syntax: '4')
+                              Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: True, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                              Operand:
+                                ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 4) (Syntax: '4')
+                            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)
+                      Initializer:
+                        null
+      Initializer:
         null
   IVariableDeclarationGroupOperation (1 declarations) (OperationKind.VariableDeclarationGroup, Type: null) (Syntax: 'C x2 = new(j: 3, i: 4);')
     IVariableDeclarationOperation (1 declarators) (OperationKind.VariableDeclaration, Type: null) (Syntax: 'C x2 = new(j: 3, i: 4)')
       Declarators:
           IVariableDeclaratorOperation (Symbol: C x2) (OperationKind.VariableDeclarator, Type: null) (Syntax: 'x2 = new(j: 3, i: 4)')
-            Initializer: 
+            Initializer:
               IVariableInitializerOperation (OperationKind.VariableInitializer, Type: null) (Syntax: '= new(j: 3, i: 4)')
-                IObjectCreationOperation (Constructor: C..ctor(System.Byte i, System.Int64 j)) (OperationKind.ObjectCreation, Type: C) (Syntax: 'new(j: 3, i: 4)')
-                  Arguments(2):
-                      IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: j) (OperationKind.Argument, Type: null) (Syntax: 'j: 3')
-                        IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Int64, Constant: 3, IsImplicit) (Syntax: '3')
-                          Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: True, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
-                          Operand: 
-                            ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 3) (Syntax: '3')
-                        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)
-                      IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: i) (OperationKind.Argument, Type: null) (Syntax: 'i: 4')
-                        IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Byte, Constant: 4, IsImplicit) (Syntax: '4')
-                          Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
-                          Operand: 
-                            ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 4) (Syntax: '4')
-                        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)
-                  Initializer: 
-                    null
-      Initializer: 
+                IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: C, IsImplicit) (Syntax: 'new(j: 3, i: 4)')
+                  Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                  Operand:
+                    IObjectCreationOperation (Constructor: C..ctor(System.Byte i, System.Int64 j)) (OperationKind.ObjectCreation, Type: C) (Syntax: 'new(j: 3, i: 4)')
+                      Arguments(2):
+                          IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: j) (OperationKind.Argument, Type: null) (Syntax: 'j: 3')
+                            IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Int64, Constant: 3, IsImplicit) (Syntax: '3')
+                              Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: True, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                              Operand:
+                                ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 3) (Syntax: '3')
+                            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)
+                          IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: i) (OperationKind.Argument, Type: null) (Syntax: 'i: 4')
+                            IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Byte, Constant: 4, IsImplicit) (Syntax: '4')
+                              Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                              Operand:
+                                ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 4) (Syntax: '4')
+                            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)
+                      Initializer:
+                        null
+      Initializer:
         null
   IVariableDeclarationGroupOperation (1 declarations) (OperationKind.VariableDeclarationGroup, Type: null) (Syntax: 'C x3 = new(3, j: 4);')
     IVariableDeclarationOperation (1 declarators) (OperationKind.VariableDeclaration, Type: null) (Syntax: 'C x3 = new(3, j: 4)')
       Declarators:
           IVariableDeclaratorOperation (Symbol: C x3) (OperationKind.VariableDeclarator, Type: null) (Syntax: 'x3 = new(3, j: 4)')
-            Initializer: 
+            Initializer:
               IVariableInitializerOperation (OperationKind.VariableInitializer, Type: null) (Syntax: '= new(3, j: 4)')
-                IObjectCreationOperation (Constructor: C..ctor(System.Byte i, System.Int64 j)) (OperationKind.ObjectCreation, Type: C) (Syntax: 'new(3, j: 4)')
-                  Arguments(2):
-                      IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: i) (OperationKind.Argument, Type: null) (Syntax: '3')
-                        IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Byte, Constant: 3, IsImplicit) (Syntax: '3')
-                          Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
-                          Operand: 
-                            ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 3) (Syntax: '3')
-                        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)
-                      IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: j) (OperationKind.Argument, Type: null) (Syntax: 'j: 4')
-                        IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Int64, Constant: 4, IsImplicit) (Syntax: '4')
-                          Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: True, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
-                          Operand: 
-                            ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 4) (Syntax: '4')
-                        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)
-                  Initializer: 
-                    null
-      Initializer: 
+                IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: C, IsImplicit) (Syntax: 'new(3, j: 4)')
+                  Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                  Operand:
+                    IObjectCreationOperation (Constructor: C..ctor(System.Byte i, System.Int64 j)) (OperationKind.ObjectCreation, Type: C) (Syntax: 'new(3, j: 4)')
+                      Arguments(2):
+                          IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: i) (OperationKind.Argument, Type: null) (Syntax: '3')
+                            IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Byte, Constant: 3, IsImplicit) (Syntax: '3')
+                              Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                              Operand:
+                                ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 3) (Syntax: '3')
+                            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)
+                          IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: j) (OperationKind.Argument, Type: null) (Syntax: 'j: 4')
+                            IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Int64, Constant: 4, IsImplicit) (Syntax: '4')
+                              Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: True, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                              Operand:
+                                ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 4) (Syntax: '4')
+                            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)
+                      Initializer:
+                        null
+      Initializer:
         null
   IVariableDeclarationGroupOperation (1 declarations) (OperationKind.VariableDeclarationGroup, Type: null) (Syntax: 'C x4 = new(i: 3, 4);')
     IVariableDeclarationOperation (1 declarators) (OperationKind.VariableDeclaration, Type: null) (Syntax: 'C x4 = new(i: 3, 4)')
       Declarators:
           IVariableDeclaratorOperation (Symbol: C x4) (OperationKind.VariableDeclarator, Type: null) (Syntax: 'x4 = new(i: 3, 4)')
-            Initializer: 
+            Initializer:
               IVariableInitializerOperation (OperationKind.VariableInitializer, Type: null) (Syntax: '= new(i: 3, 4)')
-                IObjectCreationOperation (Constructor: C..ctor(System.Byte i, System.Int64 j)) (OperationKind.ObjectCreation, Type: C) (Syntax: 'new(i: 3, 4)')
-                  Arguments(2):
-                      IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: i) (OperationKind.Argument, Type: null) (Syntax: 'i: 3')
-                        IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Byte, Constant: 3, IsImplicit) (Syntax: '3')
-                          Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
-                          Operand: 
-                            ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 3) (Syntax: '3')
-                        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)
-                      IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: j) (OperationKind.Argument, Type: null) (Syntax: '4')
-                        IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Int64, Constant: 4, IsImplicit) (Syntax: '4')
-                          Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: True, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
-                          Operand: 
-                            ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 4) (Syntax: '4')
-                        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)
-                  Initializer: 
-                    null
-      Initializer: 
+                IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: C, IsImplicit) (Syntax: 'new(i: 3, 4)')
+                  Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                  Operand:
+                    IObjectCreationOperation (Constructor: C..ctor(System.Byte i, System.Int64 j)) (OperationKind.ObjectCreation, Type: C) (Syntax: 'new(i: 3, 4)')
+                      Arguments(2):
+                          IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: i) (OperationKind.Argument, Type: null) (Syntax: 'i: 3')
+                            IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Byte, Constant: 3, IsImplicit) (Syntax: '3')
+                              Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                              Operand:
+                                ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 3) (Syntax: '3')
+                            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)
+                          IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: j) (OperationKind.Argument, Type: null) (Syntax: '4')
+                            IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Int64, Constant: 4, IsImplicit) (Syntax: '4')
+                              Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: True, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                              Operand:
+                                ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 4) (Syntax: '4')
+                            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)
+                      Initializer:
+                        null
+      Initializer:
         null
 ";
             VerifyOperationTreeAndDiagnosticsForTest<BlockSyntax>(source, expectedOperationTree, expectedDiagnostics, parseOptions: ImplicitObjectCreationOptions);
@@ -194,150 +206,171 @@ public void M1()
     IVariableDeclarationOperation (1 declarators) (OperationKind.VariableDeclaration, Type: null) (Syntax: 'F x1 = new()')
       Declarators:
           IVariableDeclaratorOperation (Symbol: F x1) (OperationKind.VariableDeclarator, Type: null) (Syntax: 'x1 = new()')
-            Initializer: 
+            Initializer:
               IVariableInitializerOperation (OperationKind.VariableInitializer, Type: null) (Syntax: '= new()')
-                IObjectCreationOperation (Constructor: F..ctor()) (OperationKind.ObjectCreation, Type: F) (Syntax: 'new()')
-                  Arguments(0)
-                  Initializer: 
-                    null
-      Initializer: 
+                IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: F, IsImplicit) (Syntax: 'new()')
+                  Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                  Operand:
+                    IObjectCreationOperation (Constructor: F..ctor()) (OperationKind.ObjectCreation, Type: F) (Syntax: 'new()')
+                      Arguments(0)
+                      Initializer:
+                        null
+      Initializer:
         null
   IVariableDeclarationGroupOperation (1 declarations) (OperationKind.VariableDeclarationGroup, Type: null) (Syntax: 'F x2 = new( ... ield = 2 };')
     IVariableDeclarationOperation (1 declarators) (OperationKind.VariableDeclaration, Type: null) (Syntax: 'F x2 = new( ... Field = 2 }')
       Declarators:
           IVariableDeclaratorOperation (Symbol: F x2) (OperationKind.VariableDeclarator, Type: null) (Syntax: 'x2 = new() { Field = 2 }')
-            Initializer: 
+            Initializer:
               IVariableInitializerOperation (OperationKind.VariableInitializer, Type: null) (Syntax: '= new() { Field = 2 }')
-                IObjectCreationOperation (Constructor: F..ctor()) (OperationKind.ObjectCreation, Type: F) (Syntax: 'new() { Field = 2 }')
-                  Arguments(0)
-                  Initializer: 
-                    IObjectOrCollectionInitializerOperation (OperationKind.ObjectOrCollectionInitializer, Type: F) (Syntax: '{ Field = 2 }')
-                      Initializers(1):
-                          ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.Int32) (Syntax: 'Field = 2')
-                            Left: 
-                              IFieldReferenceOperation: System.Int32 F.Field (OperationKind.FieldReference, Type: System.Int32) (Syntax: 'Field')
-                                Instance Receiver: 
-                                  IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: F, IsImplicit) (Syntax: 'Field')
-                            Right: 
-                              ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 2) (Syntax: '2')
-      Initializer: 
+                IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: F, IsImplicit) (Syntax: 'new() { Field = 2 }')
+                  Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                  Operand:
+                    IObjectCreationOperation (Constructor: F..ctor()) (OperationKind.ObjectCreation, Type: F) (Syntax: 'new() { Field = 2 }')
+                      Arguments(0)
+                      Initializer:
+                        IObjectOrCollectionInitializerOperation (OperationKind.ObjectOrCollectionInitializer, Type: F) (Syntax: '{ Field = 2 }')
+                          Initializers(1):
+                              ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.Int32) (Syntax: 'Field = 2')
+                                Left:
+                                  IFieldReferenceOperation: System.Int32 F.Field (OperationKind.FieldReference, Type: System.Int32) (Syntax: 'Field')
+                                    Instance Receiver:
+                                      IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: F, IsImplicit) (Syntax: 'Field')
+                                Right:
+                                  ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 2) (Syntax: '2')
+      Initializer:
         null
   IVariableDeclarationGroupOperation (1 declarations) (OperationKind.VariableDeclarationGroup, Type: null) (Syntax: 'F x3 = new( ... ty1 = """" };')
     IVariableDeclarationOperation (1 declarators) (OperationKind.VariableDeclaration, Type: null) (Syntax: 'F x3 = new( ... rty1 = """" }')
       Declarators:
           IVariableDeclaratorOperation (Symbol: F x3) (OperationKind.VariableDeclarator, Type: null) (Syntax: 'x3 = new()  ... rty1 = """" }')
-            Initializer: 
+            Initializer:
               IVariableInitializerOperation (OperationKind.VariableInitializer, Type: null) (Syntax: '= new() { P ... rty1 = """" }')
-                IObjectCreationOperation (Constructor: F..ctor()) (OperationKind.ObjectCreation, Type: F) (Syntax: 'new() { Property1 = """" }')
-                  Arguments(0)
-                  Initializer: 
-                    IObjectOrCollectionInitializerOperation (OperationKind.ObjectOrCollectionInitializer, Type: F) (Syntax: '{ Property1 = """" }')
-                      Initializers(1):
-                          ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.String) (Syntax: 'Property1 = """"')
-                            Left: 
-                              IPropertyReferenceOperation: System.String F.Property1 { get; set; } (OperationKind.PropertyReference, Type: System.String) (Syntax: 'Property1')
-                                Instance Receiver: 
-                                  IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: F, IsImplicit) (Syntax: 'Property1')
-                            Right: 
-                              ILiteralOperation (OperationKind.Literal, Type: System.String, Constant: """") (Syntax: '""""')
-      Initializer: 
+                IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: F, IsImplicit) (Syntax: 'new() { Property1 = """" }')
+                  Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                  Operand:
+                    IObjectCreationOperation (Constructor: F..ctor()) (OperationKind.ObjectCreation, Type: F) (Syntax: 'new() { Property1 = """" }')
+                      Arguments(0)
+                      Initializer:
+                        IObjectOrCollectionInitializerOperation (OperationKind.ObjectOrCollectionInitializer, Type: F) (Syntax: '{ Property1 = """" }')
+                          Initializers(1):
+                              ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.String) (Syntax: 'Property1 = """"')
+                                Left:
+                                  IPropertyReferenceOperation: System.String F.Property1 { get; set; } (OperationKind.PropertyReference, Type: System.String) (Syntax: 'Property1')
+                                    Instance Receiver:
+                                      IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: F, IsImplicit) (Syntax: 'Property1')
+                                Right:
+                                  ILiteralOperation (OperationKind.Literal, Type: System.String, Constant: """") (Syntax: '""""')
+      Initializer:
         null
   IVariableDeclarationGroupOperation (1 declarations) (OperationKind.VariableDeclarationGroup, Type: null) (Syntax: 'F x4 = new( ... ield = 2 };')
     IVariableDeclarationOperation (1 declarators) (OperationKind.VariableDeclaration, Type: null) (Syntax: 'F x4 = new( ... Field = 2 }')
       Declarators:
           IVariableDeclaratorOperation (Symbol: F x4) (OperationKind.VariableDeclarator, Type: null) (Syntax: 'x4 = new()  ... Field = 2 }')
-            Initializer: 
+            Initializer:
               IVariableInitializerOperation (OperationKind.VariableInitializer, Type: null) (Syntax: '= new() { P ... Field = 2 }')
-                IObjectCreationOperation (Constructor: F..ctor()) (OperationKind.ObjectCreation, Type: F) (Syntax: 'new() { Pro ... Field = 2 }')
-                  Arguments(0)
-                  Initializer: 
-                    IObjectOrCollectionInitializerOperation (OperationKind.ObjectOrCollectionInitializer, Type: F) (Syntax: '{ Property1 ... Field = 2 }')
-                      Initializers(2):
-                          ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.String) (Syntax: 'Property1 = """"')
-                            Left: 
-                              IPropertyReferenceOperation: System.String F.Property1 { get; set; } (OperationKind.PropertyReference, Type: System.String) (Syntax: 'Property1')
-                                Instance Receiver: 
-                                  IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: F, IsImplicit) (Syntax: 'Property1')
-                            Right: 
-                              ILiteralOperation (OperationKind.Literal, Type: System.String, Constant: """") (Syntax: '""""')
-                          ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.Int32) (Syntax: 'Field = 2')
-                            Left: 
-                              IFieldReferenceOperation: System.Int32 F.Field (OperationKind.FieldReference, Type: System.Int32) (Syntax: 'Field')
-                                Instance Receiver: 
-                                  IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: F, IsImplicit) (Syntax: 'Field')
-                            Right: 
-                              ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 2) (Syntax: '2')
-      Initializer: 
+                IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: F, IsImplicit) (Syntax: 'new() { Pro ... Field = 2 }')
+                  Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                  Operand:
+                    IObjectCreationOperation (Constructor: F..ctor()) (OperationKind.ObjectCreation, Type: F) (Syntax: 'new() { Pro ... Field = 2 }')
+                      Arguments(0)
+                      Initializer:
+                        IObjectOrCollectionInitializerOperation (OperationKind.ObjectOrCollectionInitializer, Type: F) (Syntax: '{ Property1 ... Field = 2 }')
+                          Initializers(2):
+                              ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.String) (Syntax: 'Property1 = """"')
+                                Left:
+                                  IPropertyReferenceOperation: System.String F.Property1 { get; set; } (OperationKind.PropertyReference, Type: System.String) (Syntax: 'Property1')
+                                    Instance Receiver:
+                                      IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: F, IsImplicit) (Syntax: 'Property1')
+                                Right:
+                                  ILiteralOperation (OperationKind.Literal, Type: System.String, Constant: """") (Syntax: '""""')
+                              ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.Int32) (Syntax: 'Field = 2')
+                                Left:
+                                  IFieldReferenceOperation: System.Int32 F.Field (OperationKind.FieldReference, Type: System.Int32) (Syntax: 'Field')
+                                    Instance Receiver:
+                                      IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: F, IsImplicit) (Syntax: 'Field')
+                                Right:
+                                  ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 2) (Syntax: '2')
+      Initializer:
         null
   IVariableDeclarationGroupOperation (1 declarations) (OperationKind.VariableDeclarationGroup, Type: null) (Syntax: 'F x5 = new( ... = true } };')
     IVariableDeclarationOperation (1 declarators) (OperationKind.VariableDeclaration, Type: null) (Syntax: 'F x5 = new( ...  = true } }')
       Declarators:
           IVariableDeclaratorOperation (Symbol: F x5) (OperationKind.VariableDeclarator, Type: null) (Syntax: 'x5 = new()  ...  = true } }')
-            Initializer: 
+            Initializer:
               IVariableInitializerOperation (OperationKind.VariableInitializer, Type: null) (Syntax: '= new() { P ...  = true } }')
-                IObjectCreationOperation (Constructor: F..ctor()) (OperationKind.ObjectCreation, Type: F) (Syntax: 'new() { Pro ...  = true } }')
-                  Arguments(0)
-                  Initializer: 
-                    IObjectOrCollectionInitializerOperation (OperationKind.ObjectOrCollectionInitializer, Type: F) (Syntax: '{ Property2 ...  = true } }')
-                      Initializers(1):
-                          ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: B) (Syntax: 'Property2 = ... ld = true }')
-                            Left: 
-                              IPropertyReferenceOperation: B F.Property2 { get; set; } (OperationKind.PropertyReference, Type: B) (Syntax: 'Property2')
-                                Instance Receiver: 
-                                  IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: F, IsImplicit) (Syntax: 'Property2')
-                            Right: 
-                              IObjectCreationOperation (Constructor: B..ctor()) (OperationKind.ObjectCreation, Type: B) (Syntax: 'new B { Field = true }')
-                                Arguments(0)
-                                Initializer: 
-                                  IObjectOrCollectionInitializerOperation (OperationKind.ObjectOrCollectionInitializer, Type: B) (Syntax: '{ Field = true }')
-                                    Initializers(1):
-                                        ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.Boolean) (Syntax: 'Field = true')
-                                          Left: 
-                                            IFieldReferenceOperation: System.Boolean B.Field (OperationKind.FieldReference, Type: System.Boolean) (Syntax: 'Field')
-                                              Instance Receiver: 
-                                                IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: B, IsImplicit) (Syntax: 'Field')
-                                          Right: 
-                                            ILiteralOperation (OperationKind.Literal, Type: System.Boolean, Constant: True) (Syntax: 'true')
-      Initializer: 
+                IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: F, IsImplicit) (Syntax: 'new() { Pro ...  = true } }')
+                  Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                  Operand:
+                    IObjectCreationOperation (Constructor: F..ctor()) (OperationKind.ObjectCreation, Type: F) (Syntax: 'new() { Pro ...  = true } }')
+                      Arguments(0)
+                      Initializer:
+                        IObjectOrCollectionInitializerOperation (OperationKind.ObjectOrCollectionInitializer, Type: F) (Syntax: '{ Property2 ...  = true } }')
+                          Initializers(1):
+                              ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: B) (Syntax: 'Property2 = ... ld = true }')
+                                Left:
+                                  IPropertyReferenceOperation: B F.Property2 { get; set; } (OperationKind.PropertyReference, Type: B) (Syntax: 'Property2')
+                                    Instance Receiver:
+                                      IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: F, IsImplicit) (Syntax: 'Property2')
+                                Right:
+                                  IObjectCreationOperation (Constructor: B..ctor()) (OperationKind.ObjectCreation, Type: B) (Syntax: 'new B { Field = true }')
+                                    Arguments(0)
+                                    Initializer:
+                                      IObjectOrCollectionInitializerOperation (OperationKind.ObjectOrCollectionInitializer, Type: B) (Syntax: '{ Field = true }')
+                                        Initializers(1):
+                                            ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.Boolean) (Syntax: 'Field = true')
+                                              Left:
+                                                IFieldReferenceOperation: System.Boolean B.Field (OperationKind.FieldReference, Type: System.Boolean) (Syntax: 'Field')
+                                                  Instance Receiver:
+                                                    IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: B, IsImplicit) (Syntax: 'Field')
+                                              Right:
+                                                ILiteralOperation (OperationKind.Literal, Type: System.Boolean, Constant: True) (Syntax: 'true')
+      Initializer:
         null
   IVariableDeclarationGroupOperation (1 declarations) (OperationKind.VariableDeclarationGroup, Type: null, IsInvalid) (Syntax: 'F e1 = new( ... rty2 = 1 };')
     IVariableDeclarationOperation (1 declarators) (OperationKind.VariableDeclaration, Type: null, IsInvalid) (Syntax: 'F e1 = new( ... erty2 = 1 }')
       Declarators:
           IVariableDeclaratorOperation (Symbol: F e1) (OperationKind.VariableDeclarator, Type: null, IsInvalid) (Syntax: 'e1 = new()  ... erty2 = 1 }')
-            Initializer: 
+            Initializer:
               IVariableInitializerOperation (OperationKind.VariableInitializer, Type: null, IsInvalid) (Syntax: '= new() { P ... erty2 = 1 }')
-                IObjectCreationOperation (Constructor: F..ctor()) (OperationKind.ObjectCreation, Type: F, IsInvalid) (Syntax: 'new() { Property2 = 1 }')
-                  Arguments(0)
-                  Initializer: 
-                    IObjectOrCollectionInitializerOperation (OperationKind.ObjectOrCollectionInitializer, Type: F, IsInvalid) (Syntax: '{ Property2 = 1 }')
-                      Initializers(1):
-                          ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: B, IsInvalid) (Syntax: 'Property2 = 1')
-                            Left: 
-                              IPropertyReferenceOperation: B F.Property2 { get; set; } (OperationKind.PropertyReference, Type: B) (Syntax: 'Property2')
-                                Instance Receiver: 
-                                  IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: F, IsImplicit) (Syntax: 'Property2')
-                            Right: 
-                              IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: B, IsInvalid, IsImplicit) (Syntax: '1')
-                                Conversion: CommonConversion (Exists: False, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
-                                Operand: 
-                                  ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 1, IsInvalid) (Syntax: '1')
-      Initializer: 
+                IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: F, IsInvalid, IsImplicit) (Syntax: 'new() { Property2 = 1 }')
+                  Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                  Operand:
+                    IObjectCreationOperation (Constructor: F..ctor()) (OperationKind.ObjectCreation, Type: F, IsInvalid) (Syntax: 'new() { Property2 = 1 }')
+                      Arguments(0)
+                      Initializer:
+                        IObjectOrCollectionInitializerOperation (OperationKind.ObjectOrCollectionInitializer, Type: F, IsInvalid) (Syntax: '{ Property2 = 1 }')
+                          Initializers(1):
+                              ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: B, IsInvalid) (Syntax: 'Property2 = 1')
+                                Left:
+                                  IPropertyReferenceOperation: B F.Property2 { get; set; } (OperationKind.PropertyReference, Type: B) (Syntax: 'Property2')
+                                    Instance Receiver:
+                                      IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: F, IsImplicit) (Syntax: 'Property2')
+                                Right:
+                                  IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: B, IsInvalid, IsImplicit) (Syntax: '1')
+                                    Conversion: CommonConversion (Exists: False, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                                    Operand:
+                                      ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 1, IsInvalid) (Syntax: '1')
+      Initializer:
         null
   IVariableDeclarationGroupOperation (1 declarations) (OperationKind.VariableDeclarationGroup, Type: null, IsInvalid) (Syntax: 'F e2 = new() { """" };')
     IVariableDeclarationOperation (1 declarators) (OperationKind.VariableDeclaration, Type: null, IsInvalid) (Syntax: 'F e2 = new() { """" }')
       Declarators:
           IVariableDeclaratorOperation (Symbol: F e2) (OperationKind.VariableDeclarator, Type: null, IsInvalid) (Syntax: 'e2 = new() { """" }')
-            Initializer: 
+            Initializer:
               IVariableInitializerOperation (OperationKind.VariableInitializer, Type: null, IsInvalid) (Syntax: '= new() { """" }')
-                IObjectCreationOperation (Constructor: F..ctor()) (OperationKind.ObjectCreation, Type: F, IsInvalid) (Syntax: 'new() { """" }')
-                  Arguments(0)
-                  Initializer: 
-                    IObjectOrCollectionInitializerOperation (OperationKind.ObjectOrCollectionInitializer, Type: F, IsInvalid) (Syntax: '{ """" }')
-                      Initializers(1):
-                          IInvalidOperation (OperationKind.Invalid, Type: ?, IsInvalid, IsImplicit) (Syntax: '""""')
-                            Children(1):
-                                ILiteralOperation (OperationKind.Literal, Type: System.String, Constant: """", IsInvalid) (Syntax: '""""')
-      Initializer: 
+                IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: F, IsInvalid, IsImplicit) (Syntax: 'new() { """" }')
+                  Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                  Operand:
+                    IObjectCreationOperation (Constructor: F..ctor()) (OperationKind.ObjectCreation, Type: F, IsInvalid) (Syntax: 'new() { """" }')
+                      Arguments(0)
+                      Initializer:
+                        IObjectOrCollectionInitializerOperation (OperationKind.ObjectOrCollectionInitializer, Type: F, IsInvalid) (Syntax: '{ """" }')
+                          Initializers(1):
+                              IInvalidOperation (OperationKind.Invalid, Type: ?, IsInvalid, IsImplicit) (Syntax: '""""')
+                                Children(1):
+                                    ILiteralOperation (OperationKind.Literal, Type: System.String, Constant: """", IsInvalid) (Syntax: '""""')
+      Initializer:
         null
 ";
             var expectedDiagnostics = new DiagnosticDescription[] {
@@ -362,13 +395,17 @@ public void M1()
         Predecessors: [B0]
         Statements (1)
             ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: F, IsImplicit) (Syntax: 'x1 = new()')
-              Left: 
+              Left:
                 ILocalReferenceOperation: x1 (IsDeclaration: True) (OperationKind.LocalReference, Type: F, IsImplicit) (Syntax: 'x1 = new()')
-              Right: 
-                IObjectCreationOperation (Constructor: F..ctor()) (OperationKind.ObjectCreation, Type: F) (Syntax: 'new()')
-                  Arguments(0)
-                  Initializer: 
-                    null
+              Right:
+                IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: F, IsImplicit) (Syntax: 'new()')
+                  Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                    (ObjectCreation)
+                  Operand:
+                    IObjectCreationOperation (Constructor: F..ctor()) (OperationKind.ObjectCreation, Type: F) (Syntax: 'new()')
+                      Arguments(0)
+                      Initializer:
+                        null
         Next (Regular) Block[B2]
             Entering: {R2}
     .locals {R2}
@@ -378,23 +415,27 @@ public void M1()
             Predecessors: [B1]
             Statements (3)
                 IFlowCaptureOperation: 0 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: 'new() { Field = 2 }')
-                  Value: 
+                  Value:
                     IObjectCreationOperation (Constructor: F..ctor()) (OperationKind.ObjectCreation, Type: F) (Syntax: 'new() { Field = 2 }')
                       Arguments(0)
-                      Initializer: 
+                      Initializer:
                         null
                 ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.Int32) (Syntax: 'Field = 2')
-                  Left: 
+                  Left:
                     IFieldReferenceOperation: System.Int32 F.Field (OperationKind.FieldReference, Type: System.Int32) (Syntax: 'Field')
-                      Instance Receiver: 
+                      Instance Receiver:
                         IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: F, IsImplicit) (Syntax: 'new() { Field = 2 }')
-                  Right: 
+                  Right:
                     ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 2) (Syntax: '2')
                 ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: F, IsImplicit) (Syntax: 'x2 = new() { Field = 2 }')
-                  Left: 
+                  Left:
                     ILocalReferenceOperation: x2 (IsDeclaration: True) (OperationKind.LocalReference, Type: F, IsImplicit) (Syntax: 'x2 = new() { Field = 2 }')
-                  Right: 
-                    IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: F, IsImplicit) (Syntax: 'new() { Field = 2 }')
+                  Right:
+                    IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: F, IsImplicit) (Syntax: 'new() { Field = 2 }')
+                      Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                        (ObjectCreation)
+                      Operand:
+                        IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: F, IsImplicit) (Syntax: 'new() { Field = 2 }')
             Next (Regular) Block[B3]
                 Leaving: {R2}
                 Entering: {R3}
@@ -406,23 +447,27 @@ public void M1()
             Predecessors: [B2]
             Statements (3)
                 IFlowCaptureOperation: 1 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: 'new() { Property1 = """" }')
-                  Value: 
+                  Value:
                     IObjectCreationOperation (Constructor: F..ctor()) (OperationKind.ObjectCreation, Type: F) (Syntax: 'new() { Property1 = """" }')
                       Arguments(0)
-                      Initializer: 
+                      Initializer:
                         null
                 ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.String) (Syntax: 'Property1 = """"')
-                  Left: 
+                  Left:
                     IPropertyReferenceOperation: System.String F.Property1 { get; set; } (OperationKind.PropertyReference, Type: System.String) (Syntax: 'Property1')
-                      Instance Receiver: 
+                      Instance Receiver:
                         IFlowCaptureReferenceOperation: 1 (OperationKind.FlowCaptureReference, Type: F, IsImplicit) (Syntax: 'new() { Property1 = """" }')
-                  Right: 
+                  Right:
                     ILiteralOperation (OperationKind.Literal, Type: System.String, Constant: """") (Syntax: '""""')
                 ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: F, IsImplicit) (Syntax: 'x3 = new()  ... rty1 = """" }')
-                  Left: 
+                  Left:
                     ILocalReferenceOperation: x3 (IsDeclaration: True) (OperationKind.LocalReference, Type: F, IsImplicit) (Syntax: 'x3 = new()  ... rty1 = """" }')
-                  Right: 
-                    IFlowCaptureReferenceOperation: 1 (OperationKind.FlowCaptureReference, Type: F, IsImplicit) (Syntax: 'new() { Property1 = """" }')
+                  Right:
+                    IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: F, IsImplicit) (Syntax: 'new() { Property1 = """" }')
+                      Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                        (ObjectCreation)
+                      Operand:
+                        IFlowCaptureReferenceOperation: 1 (OperationKind.FlowCaptureReference, Type: F, IsImplicit) (Syntax: 'new() { Property1 = """" }')
             Next (Regular) Block[B4]
                 Leaving: {R3}
                 Entering: {R4}
@@ -434,30 +479,34 @@ public void M1()
             Predecessors: [B3]
             Statements (4)
                 IFlowCaptureOperation: 2 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: 'new() { Pro ... Field = 2 }')
-                  Value: 
+                  Value:
                     IObjectCreationOperation (Constructor: F..ctor()) (OperationKind.ObjectCreation, Type: F) (Syntax: 'new() { Pro ... Field = 2 }')
                       Arguments(0)
-                      Initializer: 
+                      Initializer:
                         null
                 ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.String) (Syntax: 'Property1 = """"')
-                  Left: 
+                  Left:
                     IPropertyReferenceOperation: System.String F.Property1 { get; set; } (OperationKind.PropertyReference, Type: System.String) (Syntax: 'Property1')
-                      Instance Receiver: 
+                      Instance Receiver:
                         IFlowCaptureReferenceOperation: 2 (OperationKind.FlowCaptureReference, Type: F, IsImplicit) (Syntax: 'new() { Pro ... Field = 2 }')
-                  Right: 
+                  Right:
                     ILiteralOperation (OperationKind.Literal, Type: System.String, Constant: """") (Syntax: '""""')
                 ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.Int32) (Syntax: 'Field = 2')
-                  Left: 
+                  Left:
                     IFieldReferenceOperation: System.Int32 F.Field (OperationKind.FieldReference, Type: System.Int32) (Syntax: 'Field')
-                      Instance Receiver: 
+                      Instance Receiver:
                         IFlowCaptureReferenceOperation: 2 (OperationKind.FlowCaptureReference, Type: F, IsImplicit) (Syntax: 'new() { Pro ... Field = 2 }')
-                  Right: 
+                  Right:
                     ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 2) (Syntax: '2')
                 ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: F, IsImplicit) (Syntax: 'x4 = new()  ... Field = 2 }')
-                  Left: 
+                  Left:
                     ILocalReferenceOperation: x4 (IsDeclaration: True) (OperationKind.LocalReference, Type: F, IsImplicit) (Syntax: 'x4 = new()  ... Field = 2 }')
-                  Right: 
-                    IFlowCaptureReferenceOperation: 2 (OperationKind.FlowCaptureReference, Type: F, IsImplicit) (Syntax: 'new() { Pro ... Field = 2 }')
+                  Right:
+                    IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: F, IsImplicit) (Syntax: 'new() { Pro ... Field = 2 }')
+                      Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                        (ObjectCreation)
+                      Operand:
+                        IFlowCaptureReferenceOperation: 2 (OperationKind.FlowCaptureReference, Type: F, IsImplicit) (Syntax: 'new() { Pro ... Field = 2 }')
             Next (Regular) Block[B5]
                 Leaving: {R4}
                 Entering: {R5}
@@ -469,10 +518,10 @@ public void M1()
             Predecessors: [B4]
             Statements (1)
                 IFlowCaptureOperation: 3 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: 'new() { Pro ...  = true } }')
-                  Value: 
+                  Value:
                     IObjectCreationOperation (Constructor: F..ctor()) (OperationKind.ObjectCreation, Type: F) (Syntax: 'new() { Pro ...  = true } }')
                       Arguments(0)
-                      Initializer: 
+                      Initializer:
                         null
             Next (Regular) Block[B6]
                 Entering: {R6}
@@ -483,24 +532,24 @@ public void M1()
                 Predecessors: [B5]
                 Statements (3)
                     IFlowCaptureOperation: 4 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: 'new B { Field = true }')
-                      Value: 
+                      Value:
                         IObjectCreationOperation (Constructor: B..ctor()) (OperationKind.ObjectCreation, Type: B) (Syntax: 'new B { Field = true }')
                           Arguments(0)
-                          Initializer: 
+                          Initializer:
                             null
                     ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.Boolean) (Syntax: 'Field = true')
-                      Left: 
+                      Left:
                         IFieldReferenceOperation: System.Boolean B.Field (OperationKind.FieldReference, Type: System.Boolean) (Syntax: 'Field')
-                          Instance Receiver: 
+                          Instance Receiver:
                             IFlowCaptureReferenceOperation: 4 (OperationKind.FlowCaptureReference, Type: B, IsImplicit) (Syntax: 'new B { Field = true }')
-                      Right: 
+                      Right:
                         ILiteralOperation (OperationKind.Literal, Type: System.Boolean, Constant: True) (Syntax: 'true')
                     ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: B) (Syntax: 'Property2 = ... ld = true }')
-                      Left: 
+                      Left:
                         IPropertyReferenceOperation: B F.Property2 { get; set; } (OperationKind.PropertyReference, Type: B) (Syntax: 'Property2')
-                          Instance Receiver: 
+                          Instance Receiver:
                             IFlowCaptureReferenceOperation: 3 (OperationKind.FlowCaptureReference, Type: F, IsImplicit) (Syntax: 'new() { Pro ...  = true } }')
-                      Right: 
+                      Right:
                         IFlowCaptureReferenceOperation: 4 (OperationKind.FlowCaptureReference, Type: B, IsImplicit) (Syntax: 'new B { Field = true }')
                 Next (Regular) Block[B7]
                     Leaving: {R6}
@@ -509,10 +558,14 @@ public void M1()
             Predecessors: [B6]
             Statements (1)
                 ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: F, IsImplicit) (Syntax: 'x5 = new()  ...  = true } }')
-                  Left: 
+                  Left:
                     ILocalReferenceOperation: x5 (IsDeclaration: True) (OperationKind.LocalReference, Type: F, IsImplicit) (Syntax: 'x5 = new()  ...  = true } }')
-                  Right: 
-                    IFlowCaptureReferenceOperation: 3 (OperationKind.FlowCaptureReference, Type: F, IsImplicit) (Syntax: 'new() { Pro ...  = true } }')
+                  Right:
+                    IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: F, IsImplicit) (Syntax: 'new() { Pro ...  = true } }')
+                      Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                        (ObjectCreation)
+                      Operand:
+                        IFlowCaptureReferenceOperation: 3 (OperationKind.FlowCaptureReference, Type: F, IsImplicit) (Syntax: 'new() { Pro ...  = true } }')
             Next (Regular) Block[B8]
                 Leaving: {R5}
                 Entering: {R7}
@@ -524,27 +577,31 @@ public void M1()
             Predecessors: [B7]
             Statements (3)
                 IFlowCaptureOperation: 5 (OperationKind.FlowCapture, Type: null, IsInvalid, IsImplicit) (Syntax: 'new() { Property2 = 1 }')
-                  Value: 
+                  Value:
                     IObjectCreationOperation (Constructor: F..ctor()) (OperationKind.ObjectCreation, Type: F, IsInvalid) (Syntax: 'new() { Property2 = 1 }')
                       Arguments(0)
-                      Initializer: 
+                      Initializer:
                         null
                 ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: B, IsInvalid) (Syntax: 'Property2 = 1')
-                  Left: 
+                  Left:
                     IPropertyReferenceOperation: B F.Property2 { get; set; } (OperationKind.PropertyReference, Type: B) (Syntax: 'Property2')
-                      Instance Receiver: 
+                      Instance Receiver:
                         IFlowCaptureReferenceOperation: 5 (OperationKind.FlowCaptureReference, Type: F, IsInvalid, IsImplicit) (Syntax: 'new() { Property2 = 1 }')
-                  Right: 
+                  Right:
                     IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: B, IsInvalid, IsImplicit) (Syntax: '1')
                       Conversion: CommonConversion (Exists: False, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
                         (NoConversion)
-                      Operand: 
+                      Operand:
                         ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 1, IsInvalid) (Syntax: '1')
                 ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: F, IsInvalid, IsImplicit) (Syntax: 'e1 = new()  ... erty2 = 1 }')
-                  Left: 
+                  Left:
                     ILocalReferenceOperation: e1 (IsDeclaration: True) (OperationKind.LocalReference, Type: F, IsInvalid, IsImplicit) (Syntax: 'e1 = new()  ... erty2 = 1 }')
-                  Right: 
-                    IFlowCaptureReferenceOperation: 5 (OperationKind.FlowCaptureReference, Type: F, IsInvalid, IsImplicit) (Syntax: 'new() { Property2 = 1 }')
+                  Right:
+                    IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: F, IsInvalid, IsImplicit) (Syntax: 'new() { Property2 = 1 }')
+                      Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                        (ObjectCreation)
+                      Operand:
+                        IFlowCaptureReferenceOperation: 5 (OperationKind.FlowCaptureReference, Type: F, IsInvalid, IsImplicit) (Syntax: 'new() { Property2 = 1 }')
             Next (Regular) Block[B9]
                 Leaving: {R7}
                 Entering: {R8}
@@ -556,19 +613,23 @@ public void M1()
             Predecessors: [B8]
             Statements (3)
                 IFlowCaptureOperation: 6 (OperationKind.FlowCapture, Type: null, IsInvalid, IsImplicit) (Syntax: 'new() { """" }')
-                  Value: 
+                  Value:
                     IObjectCreationOperation (Constructor: F..ctor()) (OperationKind.ObjectCreation, Type: F, IsInvalid) (Syntax: 'new() { """" }')
                       Arguments(0)
-                      Initializer: 
+                      Initializer:
                         null
                 IInvalidOperation (OperationKind.Invalid, Type: ?, IsInvalid, IsImplicit) (Syntax: '""""')
                   Children(1):
                       ILiteralOperation (OperationKind.Literal, Type: System.String, Constant: """", IsInvalid) (Syntax: '""""')
                 ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: F, IsInvalid, IsImplicit) (Syntax: 'e2 = new() { """" }')
-                  Left: 
+                  Left:
                     ILocalReferenceOperation: e2 (IsDeclaration: True) (OperationKind.LocalReference, Type: F, IsInvalid, IsImplicit) (Syntax: 'e2 = new() { """" }')
-                  Right: 
-                    IFlowCaptureReferenceOperation: 6 (OperationKind.FlowCaptureReference, Type: F, IsInvalid, IsImplicit) (Syntax: 'new() { """" }')
+                  Right:
+                    IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: F, IsInvalid, IsImplicit) (Syntax: 'new() { """" }')
+                      Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                        (ObjectCreation)
+                      Operand:
+                        IFlowCaptureReferenceOperation: 6 (OperationKind.FlowCaptureReference, Type: F, IsInvalid, IsImplicit) (Syntax: 'new() { """" }')
             Next (Regular) Block[B10]
                 Leaving: {R8} {R1}
     }
@@ -660,26 +721,26 @@ public void M1(int x)
             string expectedOperationTree = @"
 IObjectCreationOperation (Constructor: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>..ctor()) (OperationKind.ObjectCreation, Type: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>) (Syntax: 'new() { ... }')
   Arguments(0)
-  Initializer: 
+  Initializer:
     IObjectOrCollectionInitializerOperation (OperationKind.ObjectOrCollectionInitializer, Type: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>) (Syntax: '{ ... }')
       Initializers(2):
           IInvocationOperation ( void System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>.Add(System.Collections.Generic.List<System.Int32> item)) (OperationKind.Invocation, Type: System.Void, IsImplicit) (Syntax: 'new[] { x, y }.ToList()')
-            Instance Receiver: 
+            Instance Receiver:
               IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>, IsImplicit) (Syntax: 'new() { ... }')
             Arguments(1):
                 IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: item) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: 'new[] { x, y }.ToList()')
                   IInvocationOperation (System.Collections.Generic.List<System.Int32> System.Linq.Enumerable.ToList<System.Int32>(this System.Collections.Generic.IEnumerable<System.Int32> source)) (OperationKind.Invocation, Type: System.Collections.Generic.List<System.Int32>) (Syntax: 'new[] { x, y }.ToList()')
-                    Instance Receiver: 
+                    Instance Receiver:
                       null
                     Arguments(1):
                         IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: source) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: 'new[] { x, y }')
                           IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Collections.Generic.IEnumerable<System.Int32>, IsImplicit) (Syntax: 'new[] { x, y }')
                             Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: True, IsUserDefined: False) (MethodSymbol: null)
-                            Operand: 
+                            Operand:
                               IArrayCreationOperation (OperationKind.ArrayCreation, Type: System.Int32[]) (Syntax: 'new[] { x, y }')
                                 Dimension Sizes(1):
                                     ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 2, IsImplicit) (Syntax: 'new[] { x, y }')
-                                Initializer: 
+                                Initializer:
                                   IArrayInitializerOperation (2 elements) (OperationKind.ArrayInitializer, Type: null) (Syntax: '{ x, y }')
                                     Element Values(2):
                                         IParameterReferenceOperation: x (OperationKind.ParameterReference, Type: System.Int32) (Syntax: 'x')
@@ -689,25 +750,28 @@ Element Values(2):
                   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)
           IInvocationOperation ( void System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>.Add(System.Collections.Generic.List<System.Int32> item)) (OperationKind.Invocation, Type: System.Void, IsImplicit) (Syntax: 'new() { field }')
-            Instance Receiver: 
+            Instance Receiver:
               IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>, IsImplicit) (Syntax: 'new() { ... }')
             Arguments(1):
                 IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: item) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: 'new() { field }')
-                  IObjectCreationOperation (Constructor: System.Collections.Generic.List<System.Int32>..ctor()) (OperationKind.ObjectCreation, Type: System.Collections.Generic.List<System.Int32>) (Syntax: 'new() { field }')
-                    Arguments(0)
-                    Initializer: 
-                      IObjectOrCollectionInitializerOperation (OperationKind.ObjectOrCollectionInitializer, Type: System.Collections.Generic.List<System.Int32>) (Syntax: '{ field }')
-                        Initializers(1):
-                            IInvocationOperation ( void System.Collections.Generic.List<System.Int32>.Add(System.Int32 item)) (OperationKind.Invocation, Type: System.Void, IsImplicit) (Syntax: 'field')
-                              Instance Receiver: 
-                                IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: System.Collections.Generic.List<System.Int32>, IsImplicit) (Syntax: 'new() { field }')
-                              Arguments(1):
-                                  IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: item) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: 'field')
-                                    IFieldReferenceOperation: System.Int32 C.field (OperationKind.FieldReference, Type: System.Int32) (Syntax: 'field')
-                                      Instance Receiver: 
-                                        IInstanceReferenceOperation (ReferenceKind: ContainingTypeInstance) (OperationKind.InstanceReference, Type: C, IsImplicit) (Syntax: 'field')
-                                    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)
+                  IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Collections.Generic.List<System.Int32>, IsImplicit) (Syntax: 'new() { field }')
+                    Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                    Operand:
+                      IObjectCreationOperation (Constructor: System.Collections.Generic.List<System.Int32>..ctor()) (OperationKind.ObjectCreation, Type: System.Collections.Generic.List<System.Int32>) (Syntax: 'new() { field }')
+                        Arguments(0)
+                        Initializer:
+                          IObjectOrCollectionInitializerOperation (OperationKind.ObjectOrCollectionInitializer, Type: System.Collections.Generic.List<System.Int32>) (Syntax: '{ field }')
+                            Initializers(1):
+                                IInvocationOperation ( void System.Collections.Generic.List<System.Int32>.Add(System.Int32 item)) (OperationKind.Invocation, Type: System.Void, IsImplicit) (Syntax: 'field')
+                                  Instance Receiver:
+                                    IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: System.Collections.Generic.List<System.Int32>, IsImplicit) (Syntax: 'new() { field }')
+                                  Arguments(1):
+                                      IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: item) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: 'field')
+                                        IFieldReferenceOperation: System.Int32 C.field (OperationKind.FieldReference, Type: System.Int32) (Syntax: 'field')
+                                          Instance Receiver:
+                                            IInstanceReferenceOperation (ReferenceKind: ContainingTypeInstance) (OperationKind.InstanceReference, Type: C, IsImplicit) (Syntax: 'field')
+                                        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)
                   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)
 ";
@@ -721,7 +785,6 @@ Element Values(2):
     Statements (0)
     Next (Regular) Block[B1]
         Entering: {R1}
-
 .locals {R1}
 {
     Locals: [System.Int32 y] [System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>> x1]
@@ -729,14 +792,12 @@ Element Values(2):
         Predecessors: [B0]
         Statements (1)
             ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.Int32, IsImplicit) (Syntax: 'y = 0')
-              Left: 
+              Left:
                 ILocalReferenceOperation: y (IsDeclaration: True) (OperationKind.LocalReference, Type: System.Int32, IsImplicit) (Syntax: 'y = 0')
-              Right: 
+              Right:
                 ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 0) (Syntax: '0')
-
         Next (Regular) Block[B2]
             Entering: {R2}
-
     .locals {R2}
     {
         CaptureIds: [0]
@@ -744,30 +805,29 @@ Element Values(2):
             Predecessors: [B1]
             Statements (2)
                 IFlowCaptureOperation: 0 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: 'new() { ... }')
-                  Value: 
+                  Value:
                     IObjectCreationOperation (Constructor: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>..ctor()) (OperationKind.ObjectCreation, Type: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>) (Syntax: 'new() { ... }')
                       Arguments(0)
-                      Initializer: 
+                      Initializer:
                         null
-
                 IInvocationOperation ( void System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>.Add(System.Collections.Generic.List<System.Int32> item)) (OperationKind.Invocation, Type: System.Void, IsImplicit) (Syntax: 'new[] { x, y }.ToList()')
-                  Instance Receiver: 
+                  Instance Receiver:
                     IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>, IsImplicit) (Syntax: 'new() { ... }')
                   Arguments(1):
                       IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: item) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: 'new[] { x, y }.ToList()')
                         IInvocationOperation (System.Collections.Generic.List<System.Int32> System.Linq.Enumerable.ToList<System.Int32>(this System.Collections.Generic.IEnumerable<System.Int32> source)) (OperationKind.Invocation, Type: System.Collections.Generic.List<System.Int32>) (Syntax: 'new[] { x, y }.ToList()')
-                          Instance Receiver: 
+                          Instance Receiver:
                             null
                           Arguments(1):
                               IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: source) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: 'new[] { x, y }')
                                 IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Collections.Generic.IEnumerable<System.Int32>, IsImplicit) (Syntax: 'new[] { x, y }')
                                   Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: True, IsUserDefined: False) (MethodSymbol: null)
                                     (ImplicitReference)
-                                  Operand: 
+                                  Operand:
                                     IArrayCreationOperation (OperationKind.ArrayCreation, Type: System.Int32[]) (Syntax: 'new[] { x, y }')
                                       Dimension Sizes(1):
                                           ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 2, IsImplicit) (Syntax: 'new[] { x, y }')
-                                      Initializer: 
+                                      Initializer:
                                         IArrayInitializerOperation (2 elements) (OperationKind.ArrayInitializer, Type: null) (Syntax: '{ x, y }')
                                           Element Values(2):
                                               IParameterReferenceOperation: x (OperationKind.ParameterReference, Type: System.Int32) (Syntax: 'x')
@@ -776,10 +836,8 @@ Element Values(2):
                                 OutConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
                         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[B3]
                 Entering: {R3}
-
         .locals {R3}
         {
             CaptureIds: [1]
@@ -787,50 +845,52 @@ Element Values(2):
                 Predecessors: [B2]
                 Statements (3)
                     IFlowCaptureOperation: 1 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: 'new() { field }')
-                      Value: 
+                      Value:
                         IObjectCreationOperation (Constructor: System.Collections.Generic.List<System.Int32>..ctor()) (OperationKind.ObjectCreation, Type: System.Collections.Generic.List<System.Int32>) (Syntax: 'new() { field }')
                           Arguments(0)
-                          Initializer: 
+                          Initializer:
                             null
-
                     IInvocationOperation ( void System.Collections.Generic.List<System.Int32>.Add(System.Int32 item)) (OperationKind.Invocation, Type: System.Void, IsImplicit) (Syntax: 'field')
-                      Instance Receiver: 
+                      Instance Receiver:
                         IFlowCaptureReferenceOperation: 1 (OperationKind.FlowCaptureReference, Type: System.Collections.Generic.List<System.Int32>, IsImplicit) (Syntax: 'new() { field }')
                       Arguments(1):
                           IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: item) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: 'field')
                             IFieldReferenceOperation: System.Int32 C.field (OperationKind.FieldReference, Type: System.Int32) (Syntax: 'field')
-                              Instance Receiver: 
+                              Instance Receiver:
                                 IInstanceReferenceOperation (ReferenceKind: ContainingTypeInstance) (OperationKind.InstanceReference, Type: C, IsImplicit) (Syntax: 'field')
                             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)
-
                     IInvocationOperation ( void System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>.Add(System.Collections.Generic.List<System.Int32> item)) (OperationKind.Invocation, Type: System.Void, IsImplicit) (Syntax: 'new() { field }')
-                      Instance Receiver: 
+                      Instance Receiver:
                         IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>, IsImplicit) (Syntax: 'new() { ... }')
                       Arguments(1):
                           IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: item) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: 'new() { field }')
-                            IFlowCaptureReferenceOperation: 1 (OperationKind.FlowCaptureReference, Type: System.Collections.Generic.List<System.Int32>, IsImplicit) (Syntax: 'new() { field }')
+                            IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Collections.Generic.List<System.Int32>, IsImplicit) (Syntax: 'new() { field }')
+                              Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                                (ObjectCreation)
+                              Operand:
+                                IFlowCaptureReferenceOperation: 1 (OperationKind.FlowCaptureReference, Type: System.Collections.Generic.List<System.Int32>, IsImplicit) (Syntax: 'new() { field }')
                             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[B4]
                     Leaving: {R3}
         }
-
         Block[B4] - Block
             Predecessors: [B3]
             Statements (1)
                 ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>, IsImplicit) (Syntax: 'x1 = /*<bin ... }')
-                  Left: 
+                  Left:
                     ILocalReferenceOperation: x1 (IsDeclaration: True) (OperationKind.LocalReference, Type: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>, IsImplicit) (Syntax: 'x1 = /*<bin ... }')
-                  Right: 
-                    IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>, IsImplicit) (Syntax: 'new() { ... }')
-
+                  Right:
+                    IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>, IsImplicit) (Syntax: 'new() { ... }')
+                      Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                        (ObjectCreation)
+                      Operand:
+                        IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>, IsImplicit) (Syntax: 'new() { ... }')
             Next (Regular) Block[B5]
                 Leaving: {R2} {R1}
     }
 }
-
 Block[B5] - Exit
     Predecessors: [B4]
     Statements (0)
@@ -1013,7 +1073,6 @@ static void Main()
     Statements (0)
     Next (Regular) Block[B1]
         Entering: {R1}
-
 .locals {R1}
 {
     Locals: [C a]
@@ -1022,15 +1081,13 @@ static void Main()
         Predecessors: [B0]
         Statements (1)
             IFlowCaptureOperation: 0 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: 'new() { a = ... [1] = 2 } }')
-              Value: 
+              Value:
                 IObjectCreationOperation (Constructor: C..ctor()) (OperationKind.ObjectCreation, Type: C) (Syntax: 'new() { a = ... [1] = 2 } }')
                   Arguments(0)
-                  Initializer: 
+                  Initializer:
                     null
-
         Next (Regular) Block[B2]
             Entering: {R2}
-
     .locals {R2}
     {
         CaptureIds: [1]
@@ -1038,21 +1095,19 @@ static void Main()
             Predecessors: [B1]
             Statements (2)
                 IFlowCaptureOperation: 1 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: '0')
-                  Value: 
+                  Value:
                     ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 0) (Syntax: '0')
-
                 ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.Int32) (Syntax: '[0] = 1')
-                  Left: 
+                  Left:
                     IArrayElementReferenceOperation (OperationKind.ArrayElementReference, Type: System.Int32) (Syntax: '[0]')
-                      Array reference: 
+                      Array reference:
                         IFieldReferenceOperation: System.Int32[] C.a (OperationKind.FieldReference, Type: System.Int32[]) (Syntax: 'a')
-                          Instance Receiver: 
+                          Instance Receiver:
                             IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: C, IsImplicit) (Syntax: 'new() { a = ... [1] = 2 } }')
                       Indices(1):
                           IFlowCaptureReferenceOperation: 1 (OperationKind.FlowCaptureReference, Type: System.Int32, Constant: 0, IsImplicit) (Syntax: '0')
-                  Right: 
+                  Right:
                     ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 1) (Syntax: '1')
-
             Next (Regular) Block[B3]
                 Leaving: {R2}
                 Entering: {R3}
@@ -1064,38 +1119,37 @@ static void Main()
             Predecessors: [B2]
             Statements (2)
                 IFlowCaptureOperation: 2 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: '1')
-                  Value: 
+                  Value:
                     ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 1) (Syntax: '1')
-
                 ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.Int32) (Syntax: '[1] = 2')
-                  Left: 
+                  Left:
                     IArrayElementReferenceOperation (OperationKind.ArrayElementReference, Type: System.Int32) (Syntax: '[1]')
-                      Array reference: 
+                      Array reference:
                         IFieldReferenceOperation: System.Int32[] C.a (OperationKind.FieldReference, Type: System.Int32[]) (Syntax: 'a')
-                          Instance Receiver: 
+                          Instance Receiver:
                             IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: C, IsImplicit) (Syntax: 'new() { a = ... [1] = 2 } }')
                       Indices(1):
                           IFlowCaptureReferenceOperation: 2 (OperationKind.FlowCaptureReference, Type: System.Int32, Constant: 1, IsImplicit) (Syntax: '1')
-                  Right: 
+                  Right:
                     ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 2) (Syntax: '2')
-
             Next (Regular) Block[B4]
                 Leaving: {R3}
     }
-
     Block[B4] - Block
         Predecessors: [B3]
         Statements (1)
             ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: C, IsImplicit) (Syntax: 'a = /*<bind ... [1] = 2 } }')
-              Left: 
+              Left:
                 ILocalReferenceOperation: a (IsDeclaration: True) (OperationKind.LocalReference, Type: C, IsImplicit) (Syntax: 'a = /*<bind ... [1] = 2 } }')
-              Right: 
-                IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: C, IsImplicit) (Syntax: 'new() { a = ... [1] = 2 } }')
-
+              Right:
+                IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: C, IsImplicit) (Syntax: 'new() { a = ... [1] = 2 } }')
+                  Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                    (ObjectCreation)
+                  Operand:
+                    IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: C, IsImplicit) (Syntax: 'new() { a = ... [1] = 2 } }')
         Next (Regular) Block[B5]
             Leaving: {R1}
 }
-
 Block[B5] - Exit
     Predecessors: [B4]
     Statements (0)
@@ -1245,7 +1299,6 @@ public void M1()
     Statements (0)
     Next (Regular) Block[B1]
         Entering: {R1}
-
 .locals {R1}
 {
     Locals: [C x1]
@@ -1254,15 +1307,13 @@ public void M1()
         Predecessors: [B0]
         Statements (1)
             IFlowCaptureOperation: 0 (OperationKind.FlowCapture, Type: null, IsInvalid, IsImplicit) (Syntax: 'new(){ Miss ... t>() { 1 }}')
-              Value: 
+              Value:
                 IObjectCreationOperation (Constructor: C..ctor()) (OperationKind.ObjectCreation, Type: C, IsInvalid) (Syntax: 'new(){ Miss ... t>() { 1 }}')
                   Arguments(0)
-                  Initializer: 
+                  Initializer:
                     null
-
         Next (Regular) Block[B2]
             Entering: {R2}
-
     .locals {R2}
     {
         CaptureIds: [1] [2]
@@ -1270,52 +1321,49 @@ public void M1()
             Predecessors: [B1]
             Statements (4)
                 IFlowCaptureOperation: 1 (OperationKind.FlowCapture, Type: null, IsInvalid, IsImplicit) (Syntax: 'MissingField')
-                  Value: 
+                  Value:
                     IInvalidOperation (OperationKind.Invalid, Type: ?, IsInvalid, IsImplicit) (Syntax: 'MissingField')
                       Children(1):
                           IOperation:  (OperationKind.None, Type: null, IsInvalid) (Syntax: 'MissingField')
                             Children(1):
                                 IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: C, IsInvalid, IsImplicit) (Syntax: 'new(){ Miss ... t>() { 1 }}')
-
                 IFlowCaptureOperation: 2 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: 'new List<int>() { 1 }')
-                  Value: 
+                  Value:
                     IObjectCreationOperation (Constructor: System.Collections.Generic.List<System.Int32>..ctor()) (OperationKind.ObjectCreation, Type: System.Collections.Generic.List<System.Int32>) (Syntax: 'new List<int>() { 1 }')
                       Arguments(0)
-                      Initializer: 
+                      Initializer:
                         null
-
                 IInvocationOperation ( void System.Collections.Generic.List<System.Int32>.Add(System.Int32 item)) (OperationKind.Invocation, Type: System.Void, IsImplicit) (Syntax: '1')
-                  Instance Receiver: 
+                  Instance Receiver:
                     IFlowCaptureReferenceOperation: 2 (OperationKind.FlowCaptureReference, Type: System.Collections.Generic.List<System.Int32>, IsImplicit) (Syntax: 'new List<int>() { 1 }')
                   Arguments(1):
                       IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: item) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: '1')
                         ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 1) (Syntax: '1')
                         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)
-
                 ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: ?, IsInvalid) (Syntax: 'MissingFiel ... nt>() { 1 }')
-                  Left: 
+                  Left:
                     IFlowCaptureReferenceOperation: 1 (OperationKind.FlowCaptureReference, Type: ?, IsInvalid, IsImplicit) (Syntax: 'MissingField')
-                  Right: 
+                  Right:
                     IFlowCaptureReferenceOperation: 2 (OperationKind.FlowCaptureReference, Type: System.Collections.Generic.List<System.Int32>, IsImplicit) (Syntax: 'new List<int>() { 1 }')
-
             Next (Regular) Block[B3]
                 Leaving: {R2}
     }
-
     Block[B3] - Block
         Predecessors: [B2]
         Statements (1)
             ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: C, IsInvalid, IsImplicit) (Syntax: 'x1 = /*<bin ... t>() { 1 }}')
-              Left: 
+              Left:
                 ILocalReferenceOperation: x1 (IsDeclaration: True) (OperationKind.LocalReference, Type: C, IsInvalid, IsImplicit) (Syntax: 'x1 = /*<bin ... t>() { 1 }}')
-              Right: 
-                IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: C, IsInvalid, IsImplicit) (Syntax: 'new(){ Miss ... t>() { 1 }}')
-
+              Right:
+                IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: C, IsInvalid, IsImplicit) (Syntax: 'new(){ Miss ... t>() { 1 }}')
+                  Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                    (ObjectCreation)
+                  Operand:
+                    IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: C, IsInvalid, IsImplicit) (Syntax: 'new(){ Miss ... t>() { 1 }}')
         Next (Regular) Block[B4]
             Leaving: {R1}
 }
-
 Block[B4] - Exit
     Predecessors: [B3]
     Statements (0)
@@ -1529,7 +1577,6 @@ Type Arguments(0)
     Statements (0)
     Next (Regular) Block[B1]
         Entering: {R1}
-
 .locals {R1}
 {
     Locals: [dynamic x] [A _]
@@ -1537,18 +1584,16 @@ Type Arguments(0)
         Predecessors: [B0]
         Statements (1)
             ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: dynamic, IsImplicit) (Syntax: 'x = 1')
-              Left: 
+              Left:
                 ILocalReferenceOperation: x (IsDeclaration: True) (OperationKind.LocalReference, Type: dynamic, IsImplicit) (Syntax: 'x = 1')
-              Right: 
+              Right:
                 IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: dynamic, IsImplicit) (Syntax: '1')
                   Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
                     (Boxing)
-                  Operand: 
+                  Operand:
                     ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 1) (Syntax: '1')
-
         Next (Regular) Block[B2]
             Entering: {R2}
-
     .locals {R2}
     {
         CaptureIds: [0]
@@ -1556,15 +1601,13 @@ Type Arguments(0)
             Predecessors: [B1]
             Statements (1)
                 IFlowCaptureOperation: 0 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: 'new() {/*<b ... </bind>*/ }')
-                  Value: 
+                  Value:
                     IObjectCreationOperation (Constructor: A..ctor()) (OperationKind.ObjectCreation, Type: A) (Syntax: 'new() {/*<b ... </bind>*/ }')
                       Arguments(0)
-                      Initializer: 
+                      Initializer:
                         null
-
             Next (Regular) Block[B3]
                 Entering: {R3}
-
         .locals {R3}
         {
             CaptureIds: [1] [2]
@@ -1572,20 +1615,18 @@ Type Arguments(0)
                 Predecessors: [B2]
                 Statements (5)
                     IFlowCaptureOperation: 1 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: 'x')
-                      Value: 
+                      Value:
                         ILocalReferenceOperation: x (OperationKind.LocalReference, Type: dynamic) (Syntax: 'x')
-
                     IFlowCaptureOperation: 2 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: 'x')
-                      Value: 
+                      Value:
                         ILocalReferenceOperation: x (OperationKind.LocalReference, Type: dynamic) (Syntax: 'x')
-
                     ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: dynamic) (Syntax: 'X = 1')
-                      Left: 
+                      Left:
                         IDynamicMemberReferenceOperation (Member Name: ""X"", Containing Type: dynamic) (OperationKind.DynamicMemberReference, Type: dynamic) (Syntax: 'X')
                           Type Arguments(0)
-                          Instance Receiver: 
+                          Instance Receiver:
                             IDynamicIndexerAccessOperation (OperationKind.DynamicIndexerAccess, Type: dynamic) (Syntax: '[y: x, x: x]')
-                              Expression: 
+                              Expression:
                                 IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: A, IsImplicit) (Syntax: 'new() {/*<b ... </bind>*/ }')
                               Arguments(2):
                                   IFlowCaptureReferenceOperation: 1 (OperationKind.FlowCaptureReference, Type: dynamic, IsImplicit) (Syntax: 'x')
@@ -1594,16 +1635,15 @@ Type Arguments(0)
                                 ""y""
                                 ""x""
                               ArgumentRefKinds(0)
-                      Right: 
+                      Right:
                         ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 1) (Syntax: '1')
-
                     ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: dynamic) (Syntax: 'Y = 1')
-                      Left: 
+                      Left:
                         IDynamicMemberReferenceOperation (Member Name: ""Y"", Containing Type: dynamic) (OperationKind.DynamicMemberReference, Type: dynamic) (Syntax: 'Y')
                           Type Arguments(0)
-                          Instance Receiver: 
+                          Instance Receiver:
                             IDynamicIndexerAccessOperation (OperationKind.DynamicIndexerAccess, Type: dynamic) (Syntax: '[y: x, x: x]')
-                              Expression: 
+                              Expression:
                                 IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: A, IsImplicit) (Syntax: 'new() {/*<b ... </bind>*/ }')
                               Arguments(2):
                                   IFlowCaptureReferenceOperation: 1 (OperationKind.FlowCaptureReference, Type: dynamic, IsImplicit) (Syntax: 'x')
@@ -1612,16 +1652,15 @@ Type Arguments(0)
                                 ""y""
                                 ""x""
                               ArgumentRefKinds(0)
-                      Right: 
+                      Right:
                         ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 1) (Syntax: '1')
-
                     ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: dynamic) (Syntax: 'Z = 1')
-                      Left: 
+                      Left:
                         IDynamicMemberReferenceOperation (Member Name: ""Z"", Containing Type: dynamic) (OperationKind.DynamicMemberReference, Type: dynamic) (Syntax: 'Z')
                           Type Arguments(0)
-                          Instance Receiver: 
+                          Instance Receiver:
                             IDynamicIndexerAccessOperation (OperationKind.DynamicIndexerAccess, Type: dynamic) (Syntax: '[y: x, x: x]')
-                              Expression: 
+                              Expression:
                                 IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: A, IsImplicit) (Syntax: 'new() {/*<b ... </bind>*/ }')
                               Arguments(2):
                                   IFlowCaptureReferenceOperation: 1 (OperationKind.FlowCaptureReference, Type: dynamic, IsImplicit) (Syntax: 'x')
@@ -1630,31 +1669,31 @@ Type Arguments(0)
                                 ""y""
                                 ""x""
                               ArgumentRefKinds(0)
-                      Right: 
+                      Right:
                         ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 1) (Syntax: '1')
-
                 Next (Regular) Block[B4]
                     Leaving: {R3}
         }
-
         Block[B4] - Block
             Predecessors: [B3]
             Statements (1)
                 ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: A, IsImplicit) (Syntax: '_ = new() { ... </bind>*/ }')
-                  Left: 
+                  Left:
                     ILocalReferenceOperation: _ (IsDeclaration: True) (OperationKind.LocalReference, Type: A, IsImplicit) (Syntax: '_ = new() { ... </bind>*/ }')
-                  Right: 
-                    IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: A, IsImplicit) (Syntax: 'new() {/*<b ... </bind>*/ }')
-
+                  Right:
+                    IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: A, IsImplicit) (Syntax: 'new() {/*<b ... </bind>*/ }')
+                      Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                        (ObjectCreation)
+                      Operand:
+                        IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: A, IsImplicit) (Syntax: 'new() {/*<b ... </bind>*/ }')
             Next (Regular) Block[B5]
                 Leaving: {R2} {R1}
     }
 }
-
 Block[B5] - Exit
     Predecessors: [B4]
     Statements (0)
-            ");
+");
         }
 
         [CompilerTrait(CompilerFeature.IOperation)]
@@ -2240,7 +2279,6 @@ class C2
     Statements (0)
     Next (Regular) Block[B1]
         Entering: {R1}
-
 .locals {R1}
 {
     CaptureIds: [0] [1]
@@ -2248,19 +2286,16 @@ class C2
         Predecessors: [B0]
         Statements (2)
             IFlowCaptureOperation: 0 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: 'c1')
-              Value: 
+              Value:
                 IParameterReferenceOperation: c1 (OperationKind.ParameterReference, Type: C1) (Syntax: 'c1')
-
             IFlowCaptureOperation: 1 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: 'new() /*<bi ... { A = 1 } }')
-              Value: 
+              Value:
                 IObjectCreationOperation (Constructor: C1..ctor()) (OperationKind.ObjectCreation, Type: C1) (Syntax: 'new() /*<bi ... { A = 1 } }')
                   Arguments(0)
-                  Initializer: 
+                  Initializer:
                     null
-
         Next (Regular) Block[B2]
             Entering: {R2}
-
     .locals {R2}
     {
         CaptureIds: [2]
@@ -2268,43 +2303,42 @@ class C2
             Predecessors: [B1]
             Statements (2)
                 IFlowCaptureOperation: 2 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: '1')
-                  Value: 
+                  Value:
                     ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 1) (Syntax: '1')
-
                 ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.Int32) (Syntax: 'A = 1')
-                  Left: 
+                  Left:
                     IPropertyReferenceOperation: System.Int32 C2.A { get; set; } (OperationKind.PropertyReference, Type: System.Int32) (Syntax: 'A')
-                      Instance Receiver: 
+                      Instance Receiver:
                         IPropertyReferenceOperation: C2 C1.this[System.Int32 i] { get; } (OperationKind.PropertyReference, Type: C2) (Syntax: '[1]')
-                          Instance Receiver: 
+                          Instance Receiver:
                             IFlowCaptureReferenceOperation: 1 (OperationKind.FlowCaptureReference, Type: C1, IsImplicit) (Syntax: 'new() /*<bi ... { A = 1 } }')
                           Arguments(1):
                               IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: i) (OperationKind.Argument, Type: null) (Syntax: '1')
                                 IFlowCaptureReferenceOperation: 2 (OperationKind.FlowCaptureReference, Type: System.Int32, Constant: 1, IsImplicit) (Syntax: '1')
                                 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)
-                  Right: 
+                  Right:
                     ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 1) (Syntax: '1')
-
             Next (Regular) Block[B3]
                 Leaving: {R2}
     }
-
     Block[B3] - Block
         Predecessors: [B2]
         Statements (1)
             IExpressionStatementOperation (OperationKind.ExpressionStatement, Type: null) (Syntax: 'c1 = new()  ... *</bind>*/;')
-              Expression: 
+              Expression:
                 ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: C1) (Syntax: 'c1 = new()  ... { A = 1 } }')
-                  Left: 
+                  Left:
                     IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: C1, IsImplicit) (Syntax: 'c1')
-                  Right: 
-                    IFlowCaptureReferenceOperation: 1 (OperationKind.FlowCaptureReference, Type: C1, IsImplicit) (Syntax: 'new() /*<bi ... { A = 1 } }')
-
+                  Right:
+                    IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: C1, IsImplicit) (Syntax: 'new() /*<bi ... { A = 1 } }')
+                      Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                        (ObjectCreation)
+                      Operand:
+                        IFlowCaptureReferenceOperation: 1 (OperationKind.FlowCaptureReference, Type: C1, IsImplicit) (Syntax: 'new() /*<bi ... { A = 1 } }')
         Next (Regular) Block[B4]
             Leaving: {R1}
 }
-
 Block[B4] - Exit
     Predecessors: [B3]
     Statements (0)
@@ -2375,13 +2409,13 @@ public void Add(int i) { }
         Predecessors: [B0]
         Statements (2)
             IFlowCaptureOperation: 0 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: 'c1')
-              Value: 
+              Value:
                 IParameterReferenceOperation: c1 (OperationKind.ParameterReference, Type: C1) (Syntax: 'c1')
             IFlowCaptureOperation: 1 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: 'new() /*<bi ... ] = { 1 } }')
-              Value: 
+              Value:
                 IObjectCreationOperation (Constructor: C1..ctor()) (OperationKind.ObjectCreation, Type: C1) (Syntax: 'new() /*<bi ... ] = { 1 } }')
                   Arguments(0)
-                  Initializer: 
+                  Initializer:
                     null
         Next (Regular) Block[B2]
             Entering: {R2}
@@ -2392,12 +2426,12 @@ public void Add(int i) { }
             Predecessors: [B1]
             Statements (2)
                 IFlowCaptureOperation: 2 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: '1')
-                  Value: 
+                  Value:
                     ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 1) (Syntax: '1')
                 IInvocationOperation ( void C2.Add(System.Int32 i)) (OperationKind.Invocation, Type: System.Void, IsImplicit) (Syntax: '1')
-                  Instance Receiver: 
+                  Instance Receiver:
                     IPropertyReferenceOperation: C2 C1.this[System.Int32 i] { get; } (OperationKind.PropertyReference, Type: C2) (Syntax: '[1]')
-                      Instance Receiver: 
+                      Instance Receiver:
                         IFlowCaptureReferenceOperation: 1 (OperationKind.FlowCaptureReference, Type: C1, IsImplicit) (Syntax: 'new() /*<bi ... ] = { 1 } }')
                       Arguments(1):
                           IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: i) (OperationKind.Argument, Type: null) (Syntax: '1')
@@ -2416,12 +2450,16 @@ public void Add(int i) { }
         Predecessors: [B2]
         Statements (1)
             IExpressionStatementOperation (OperationKind.ExpressionStatement, Type: null) (Syntax: 'c1 = new()  ... *</bind>*/;')
-              Expression: 
+              Expression:
                 ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: C1) (Syntax: 'c1 = new()  ... ] = { 1 } }')
-                  Left: 
+                  Left:
                     IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: C1, IsImplicit) (Syntax: 'c1')
-                  Right: 
-                    IFlowCaptureReferenceOperation: 1 (OperationKind.FlowCaptureReference, Type: C1, IsImplicit) (Syntax: 'new() /*<bi ... ] = { 1 } }')
+                  Right:
+                    IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: C1, IsImplicit) (Syntax: 'new() /*<bi ... ] = { 1 } }')
+                      Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                        (ObjectCreation)
+                      Operand:
+                        IFlowCaptureReferenceOperation: 1 (OperationKind.FlowCaptureReference, Type: C1, IsImplicit) (Syntax: 'new() /*<bi ... ] = { 1 } }')
         Next (Regular) Block[B4]
             Leaving: {R1}
 }
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IParameterReferenceExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IParameterReferenceExpression.cs
index 8598001ee5210..9f2172613e3b0 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IParameterReferenceExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IParameterReferenceExpression.cs
@@ -987,9 +987,9 @@ public I F(object x)
                 references: new[] { MscorlibRef, SystemRef, compilation0.EmitToImageReference(embedInteropTypes: true) });
 
             string expectedOperationTree = @"
-INoPiaObjectCreationOperation (OperationKind.None, Type: I, IsInvalid) (Syntax: 'new I(x)')
-  Initializer: 
-    null
+IInvalidOperation (OperationKind.Invalid, Type: I, IsInvalid) (Syntax: 'new I(x)')
+  Children(1):
+      IParameterReferenceOperation: x (OperationKind.ParameterReference, Type: System.Object) (Syntax: 'x')
 ";
             var expectedDiagnostics = new DiagnosticDescription[] {
                 // (6,24): error CS1729: 'I' does not contain a constructor that takes 1 arguments
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/ImplicitObjectCreationTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/ImplicitObjectCreationTests.cs
index 0364599d76c67..b328da49afa09 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/ImplicitObjectCreationTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/ImplicitObjectCreationTests.cs
@@ -55,9 +55,9 @@ public static void Main()
             var model = comp.GetSemanticModel(tree);
             var nodes = tree.GetCompilationUnitRoot().DescendantNodes().OfType<ImplicitObjectCreationExpressionSyntax>().ToArray();
 
-            assert(0, type: "C", convertedType: "C", symbol: "C..ctor()", ConversionKind.Identity);
-            assert(1, type: "S", convertedType: "S", symbol: "S..ctor()", ConversionKind.Identity);
-            assert(2, type: "S", convertedType: "S?", symbol: "S..ctor()", ConversionKind.ImplicitNullable);
+            assert(0, type: "C", convertedType: "C", symbol: "C..ctor()", ConversionKind.ObjectCreation);
+            assert(1, type: "S", convertedType: "S", symbol: "S..ctor()", ConversionKind.ObjectCreation);
+            assert(2, type: "S", convertedType: "S?", symbol: "S..ctor()", ConversionKind.ObjectCreation);
 
             void assert(int index, string type, string convertedType, string symbol, ConversionKind conversionKind)
             {
@@ -125,9 +125,9 @@ public static void Main()
             var model = comp.GetSemanticModel(tree);
             var nodes = tree.GetCompilationUnitRoot().DescendantNodes().OfType<ImplicitObjectCreationExpressionSyntax>().ToArray();
 
-            assert(0, type: "C", convertedType: "C", symbol: "C..ctor()", ConversionKind.Identity);
-            assert(1, type: "S", convertedType: "S", symbol: "S..ctor()", ConversionKind.Identity);
-            assert(2, type: "S", convertedType: "S?", symbol: "S..ctor()", ConversionKind.ImplicitNullable);
+            assert(0, type: "C", convertedType: "C", symbol: "C..ctor()", ConversionKind.ObjectCreation);
+            assert(1, type: "S", convertedType: "S", symbol: "S..ctor()", ConversionKind.ObjectCreation);
+            assert(2, type: "S", convertedType: "S?", symbol: "S..ctor()", ConversionKind.ObjectCreation);
 
             void assert(int index, string type, string convertedType, string symbol, ConversionKind conversionKind)
             {
@@ -172,9 +172,9 @@ public static void Main()
             var model = comp.GetSemanticModel(tree);
             var nodes = tree.GetCompilationUnitRoot().DescendantNodes().OfType<ImplicitObjectCreationExpressionSyntax>().ToArray();
 
-            assert(0, type: "C", convertedType: "C", symbol: "C..ctor()", ConversionKind.Identity);
-            assert(1, type: "S", convertedType: "S", symbol: "S..ctor()", ConversionKind.Identity);
-            assert(2, type: "S", convertedType: "S?", symbol: "S..ctor()", ConversionKind.ImplicitNullable);
+            assert(0, type: "C", convertedType: "C", symbol: "C..ctor()", ConversionKind.ObjectCreation);
+            assert(1, type: "S", convertedType: "S", symbol: "S..ctor()", ConversionKind.ObjectCreation);
+            assert(2, type: "S", convertedType: "S?", symbol: "S..ctor()", ConversionKind.ObjectCreation);
 
             void assert(int index, string type, string convertedType, string symbol, ConversionKind conversionKind)
             {
@@ -213,20 +213,20 @@ void M(
                 // (9,16): error CS1736: Default parameter value for 'p1' must be a compile-time constant
                 //         C p1 = new(),
                 Diagnostic(ErrorCode.ERR_DefaultValueMustBeConstant, "new()").WithArguments("p1").WithLocation(9, 16),
-                // (11,17): error CS1736: Default parameter value for 'p3' must be a compile-time constant
-                //         S? p3 = new()
-                Diagnostic(ErrorCode.ERR_DefaultValueMustBeConstant, "new()").WithArguments("p3").WithLocation(11, 17)
+                // (11,12): error CS1770: A value of type 'S' cannot be used as default parameter for nullable parameter 'p3' because 'S' is not a simple type
+                //         S? p3 = new(),
+                Diagnostic(ErrorCode.ERR_NoConversionForNubDefaultParam, "p3").WithArguments("S", "p3").WithLocation(11, 12)
                 );
 
             var tree = comp.SyntaxTrees.First();
             var model = comp.GetSemanticModel(tree);
             var nodes = tree.GetCompilationUnitRoot().DescendantNodes().OfType<ImplicitObjectCreationExpressionSyntax>().ToArray();
 
-            assert(0, type: "C", convertedType: "C", symbol: "C..ctor()", constant: null, ConversionKind.Identity);
-            assert(1, type: "S", convertedType: "S", symbol: "S..ctor()", constant: null, ConversionKind.Identity);
-            assert(2, type: "S", convertedType: "S?", symbol: "S..ctor()", constant: null, ConversionKind.ImplicitNullable);
-            assert(3, type: "System.Int32", convertedType: "System.Int32", symbol: "System.Int32..ctor()", constant: "0", ConversionKind.Identity);
-            assert(4, type: "System.Boolean", convertedType: "System.Boolean?", symbol: "System.Boolean..ctor()", constant: "False", ConversionKind.ImplicitNullable);
+            assert(0, type: "C", convertedType: "C", symbol: "C..ctor()", constant: null, ConversionKind.ObjectCreation);
+            assert(1, type: "S", convertedType: "S", symbol: "S..ctor()", constant: null, ConversionKind.ObjectCreation);
+            assert(2, type: "S", convertedType: "S?", symbol: "S..ctor()", constant: null, ConversionKind.ObjectCreation);
+            assert(3, type: "System.Int32", convertedType: "System.Int32", symbol: "System.Int32..ctor()", constant: "0", ConversionKind.ObjectCreation);
+            assert(4, type: "System.Boolean", convertedType: "System.Boolean?", symbol: "System.Boolean..ctor()", constant: "False", ConversionKind.ObjectCreation);
 
             void assert(int index, string type, string convertedType, string symbol, string constant, ConversionKind conversionKind)
             {
@@ -840,7 +840,7 @@ public static void Main()
             Assert.Equal("InterfaceType", model.GetTypeInfo(@new).Type.ToTestDisplayString());
             Assert.Equal("InterfaceType", model.GetTypeInfo(@new).ConvertedType.ToTestDisplayString());
             Assert.Equal("CoClassType..ctor()", model.GetSymbolInfo(@new).Symbol.ToTestDisplayString());
-            Assert.Equal(ConversionKind.Identity, model.GetConversion(@new).Kind);
+            Assert.Equal(ConversionKind.ObjectCreation, model.GetConversion(@new).Kind);
         }
 
         [Fact]
@@ -881,7 +881,7 @@ public static int Main()
             Assert.Equal("NonGenericInterfaceType", model.GetTypeInfo(@new).Type.ToTestDisplayString());
             Assert.Equal("NonGenericInterfaceType", model.GetTypeInfo(@new).ConvertedType.ToTestDisplayString());
             Assert.Equal("GenericCoClassType<System.Int32, System.String>..ctor(System.String x)", model.GetSymbolInfo(@new).Symbol.ToTestDisplayString());
-            Assert.Equal(ConversionKind.Identity, model.GetConversion(@new).Kind);
+            Assert.Equal(ConversionKind.ObjectCreation, model.GetConversion(@new).Kind);
         }
 
         [Fact]
@@ -1865,7 +1865,7 @@ static void Main()
             Assert.Equal("C", model.GetTypeInfo(def).ConvertedType.ToTestDisplayString());
             Assert.Equal("C..ctor()", model.GetSymbolInfo(def).Symbol.ToTestDisplayString());
             Assert.False(model.GetConstantValue(def).HasValue);
-            Assert.True(model.GetConversion(def).IsIdentity);
+            Assert.True(model.GetConversion(def).IsObjectCreation);
         }
 
         [Fact]
@@ -1895,7 +1895,7 @@ static void Main()
             Assert.Equal("S", model.GetTypeInfo(def).ConvertedType.ToTestDisplayString());
             Assert.Equal("S..ctor(System.Int32 i)", model.GetSymbolInfo(def).Symbol.ToTestDisplayString());
             Assert.False(model.GetConstantValue(def).HasValue);
-            Assert.True(model.GetConversion(def).IsIdentity);
+            Assert.True(model.GetConversion(def).IsObjectCreation);
         }
 
         [Fact]
@@ -1925,7 +1925,7 @@ static void Main()
             Assert.Equal("S?", model.GetTypeInfo(def).ConvertedType.ToTestDisplayString());
             Assert.Equal("S..ctor(System.Int32 i)", model.GetSymbolInfo(def).Symbol.ToTestDisplayString());
             Assert.False(model.GetConstantValue(def).HasValue);
-            Assert.True(model.GetConversion(def).IsNullable);
+            Assert.True(model.GetConversion(def).IsObjectCreation);
             Assert.True(model.GetConversion(def).IsImplicit);
         }
 
@@ -2086,7 +2086,7 @@ static void Main()
 
             assert(0, type: "?", convertedType: "?", ConversionKind.Identity);
             assert(1, type: "?", convertedType: "?", ConversionKind.Identity);
-            assert(2, type: "System.IDisposable", convertedType: "System.IDisposable", ConversionKind.Identity);
+            assert(2, type: "System.IDisposable", convertedType: "System.IDisposable", ConversionKind.NoConversion);
 
             void assert(int index, string type, string convertedType, ConversionKind conversionKind)
             {
@@ -2182,7 +2182,7 @@ class C
             Assert.Equal("T", model.GetTypeInfo(def).ConvertedType.ToTestDisplayString());
             Assert.Null(model.GetSymbolInfo(def).Symbol);
             Assert.False(model.GetConstantValue(def).HasValue);
-            Assert.True(model.GetConversion(def).IsIdentity);
+            Assert.True(model.GetConversion(def).IsObjectCreation);
         }
 
         [Fact]
@@ -2881,10 +2881,10 @@ static void Main()
             var model = comp.GetSemanticModel(tree);
             var nodes = tree.GetCompilationUnitRoot().DescendantNodes().OfType<ImplicitObjectCreationExpressionSyntax>().ToArray();
 
-            assert(0, type: "System.Index", convertedType: "System.Index", symbol: "System.Index..ctor()", ConversionKind.Identity);
-            assert(1, type: "System.Index", convertedType: "System.Index", symbol: "System.Index..ctor()", ConversionKind.Identity);
-            assert(2, type: "System.Index", convertedType: "System.Index", symbol: "System.Index..ctor()", ConversionKind.Identity);
-            assert(3, type: "System.Index", convertedType: "System.Index", symbol: "System.Index..ctor()", ConversionKind.Identity);
+            assert(0, type: "System.Index", convertedType: "System.Index", symbol: "System.Index..ctor()", ConversionKind.ObjectCreation);
+            assert(1, type: "System.Index", convertedType: "System.Index", symbol: "System.Index..ctor()", ConversionKind.ObjectCreation);
+            assert(2, type: "System.Index", convertedType: "System.Index", symbol: "System.Index..ctor()", ConversionKind.ObjectCreation);
+            assert(3, type: "System.Index", convertedType: "System.Index", symbol: "System.Index..ctor()", ConversionKind.ObjectCreation);
 
             void assert(int index, string type, string convertedType, string symbol, ConversionKind conversionKind)
             {
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
index 9ea714ca2560b..a2ca0b64023fd 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
@@ -53323,6 +53323,52 @@ class A { public static implicit operator C?(A a) => null; }
             comp.VerifyDiagnostics();
         }
 
+        [Fact, WorkItem(58369, "https://github.com/dotnet/roslyn/issues/58369")]
+        public void ConditionalOperator_TargetTyped_11()
+        {
+            var comp = CreateCompilation(@"
+#pragma warning disable CS0164
+class C<T>
+{
+    static void M2(bool b, string? s)
+    {
+WarnHere:   _ = C.GetCT(s) + (b ? new C1() : new C2());
+ButNotHere: _ = (b ? new C3() : new C4()) + C.GetCT(s);
+    }
+    
+    public static C<T> operator + (C<T> x, C<T> y)
+    {
+        throw null!;
+    }
+}
+
+class C
+{
+    public static C<T> GetCT<T>(T x) => new C<T>(); 
+}
+
+class C1 : C<string> {}
+class C2 : C<string> {}
+class C3 : C<string> {}
+class C4 : C<string> {}
+", options: WithNullableEnable(TestOptions.ReleaseDll));
+
+            comp.VerifyDiagnostics(
+                // (7,35): warning CS8619: Nullability of reference types in value of type 'C1' doesn't match target type 'C<string?>'.
+                // WarnHere:   _ = C.GetCT(s) + (b ? new C1() : new C2());
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C1()").WithArguments("C1", "C<string?>").WithLocation(7, 35),
+                // (7,46): warning CS8619: Nullability of reference types in value of type 'C2' doesn't match target type 'C<string?>'.
+                // WarnHere:   _ = C.GetCT(s) + (b ? new C1() : new C2());
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C2()").WithArguments("C2", "C<string?>").WithLocation(7, 46),
+                // (8,22): warning CS8619: Nullability of reference types in value of type 'C3' doesn't match target type 'C<string?>'.
+                // ButNotHere: _ = (b ? new C3() : new C4()) + C.GetCT(s);
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C3()").WithArguments("C3", "C<string?>").WithLocation(8, 22),
+                // (8,33): warning CS8619: Nullability of reference types in value of type 'C4' doesn't match target type 'C<string?>'.
+                // ButNotHere: _ = (b ? new C3() : new C4()) + C.GetCT(s);
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C4()").WithArguments("C4", "C<string?>").WithLocation(8, 33)
+                );
+        }
+
         [Fact, WorkItem(46954, "https://github.com/dotnet/roslyn/issues/46954")]
         public void ReturningValues_ConditionalOperator_WithoutType_WithNullLiterals()
         {
@@ -154076,5 +154122,1383 @@ class C { }
             var comp = CreateCompilation(source);
             comp.VerifyDiagnostics();
         }
+
+        [Fact]
+        public void ObjectCreationExpression_TargetTyped_01()
+        {
+            var comp = CreateCompilation(@"
+class C
+{
+    static void M()
+    {
+        C<string> a = new(null);
+        _ = (C<string>)new(null);
+
+        C<string> b = new() { F1 = null, F2 = ""b""};
+        b.F1.ToString();
+        b.F2.ToString();
+
+        var c = (C<string>)new() { F1 = null, F2 = ""c""};
+        c.F1.ToString();
+        c.F2.ToString();
+    }
+}
+
+class C<T>
+{
+    public C(){F1 = default!;}
+    public C(T t){F1 = t;}
+
+    public T F1;
+    public T? F2;
+}
+", options: WithNullableEnable());
+
+            comp.VerifyDiagnostics(
+                // (6,27): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         C<string> a = new(null);
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(6, 27),
+                // (7,28): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         _ = (C<string>)new(null);
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(7, 28),
+                // (9,36): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         C<string> b = new() { F1 = null, F2 = "b"};
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(9, 36),
+                // (10,9): warning CS8602: Dereference of a possibly null reference.
+                //         b.F1.ToString();
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "b.F1").WithLocation(10, 9),
+                // (13,41): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         var c = (C<string>)new() { F1 = null, F2 = "c"};
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(13, 41),
+                // (14,9): warning CS8602: Dereference of a possibly null reference.
+                //         c.F1.ToString();
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "c.F1").WithLocation(14, 9)
+                );
+        }
+
+        [Fact]
+        public void ObjectCreationExpression_TargetTyped_02()
+        {
+            var comp = CreateCompilation(@"
+class C
+{
+    static void M()
+    {
+        var a = GetC(""a"");
+        a = new(null);
+
+        var b = GetC(""b"");
+        b = new() { F1 = null, F2 = ""b""};
+        b.F1.ToString();
+        b.F2.ToString();
+    }
+
+    static C<T> GetC<T>(T t) => new C<T>(t);
+}
+
+class C<T>
+{
+    public C(){F1 = default!;}
+    public C(T t){F1 = t;}
+
+    public T F1;
+    public T? F2;
+}
+", options: WithNullableEnable());
+
+            comp.VerifyDiagnostics(
+                // (7,17): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         a = new(null);
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(7, 17),
+                // (10,26): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         b = new() { F1 = null, F2 = "b"};
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(10, 26),
+                // (11,9): warning CS8602: Dereference of a possibly null reference.
+                //         b.F1.ToString();
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "b.F1").WithLocation(11, 9)
+                );
+        }
+
+        [Fact]
+        public void ObjectCreationExpression_TargetTyped_03()
+        {
+            var comp = CreateCompilation(@"
+class C
+{
+    static void M()
+    {
+        var s = ""s"";
+        s = null;
+
+        var a = GetC1(""a"");
+        a = new(GetC2(s));
+
+        var b = GetC1(""b"");
+        b = new() { F1 = GetC2(s), F2 = GetC2(""b"")};
+        b.F1.F3.ToString();
+        b.F2.F3.ToString();
+
+        var c = GetC1(s);
+        c = new() { F1 = GetC2(""c1""), F2 = GetC2(""c2"")};
+
+        var d = new C1<string?>() { F1 = new C2<string>(""d1""), F2 = new C2<string>(""d2"")};
+
+        var e = new C1<string>() { F1 = GetC2(s), F2 = GetC2(""e"")};
+        e.F1.F3.ToString();
+        e.F2.F3.ToString();
+    }
+
+    static C1<T> GetC1<T>(T t) => new C1<T>(new(t));
+    static C2<T> GetC2<T>(T t) => new C2<T>(t);
+}
+
+class C1<T>
+{
+    public C1(){}
+    public C1(C2<T> t){}
+
+    public C2<T>? F1;
+    public C2<T?>? F2;
+}
+
+class C2<T>
+{
+    public C2(T t){F3 = t;}
+    public T F3;
+}
+", options: WithNullableEnable());
+
+            comp.VerifyDiagnostics(
+                // (10,17): warning CS8620: Argument of type 'C2<string?>' cannot be used for parameter 't' of type 'C2<string>' in 'C1<string>.C1(C2<string> t)' due to differences in the nullability of reference types.
+                //         a = new(GetC2(s));
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, "GetC2(s)").WithArguments("C2<string?>", "C2<string>", "t", "C1<string>.C1(C2<string> t)").WithLocation(10, 17),
+                // (13,26): warning CS8619: Nullability of reference types in value of type 'C2<string?>' doesn't match target type 'C2<string>'.
+                //         b = new() { F1 = GetC2(s), F2 = GetC2("b")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "GetC2(s)").WithArguments("C2<string?>", "C2<string>").WithLocation(13, 26),
+                // (13,41): warning CS8619: Nullability of reference types in value of type 'C2<string>' doesn't match target type 'C2<string?>'.
+                //         b = new() { F1 = GetC2(s), F2 = GetC2("b")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, @"GetC2(""b"")").WithArguments("C2<string>", "C2<string?>").WithLocation(13, 41),
+                // (15,9): warning CS8602: Dereference of a possibly null reference.
+                //         b.F2.F3.ToString();
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "b.F2.F3").WithLocation(15, 9),
+                // (18,26): warning CS8619: Nullability of reference types in value of type 'C2<string>' doesn't match target type 'C2<string?>'.
+                //         c = new() { F1 = GetC2("c1"), F2 = GetC2("c2")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, @"GetC2(""c1"")").WithArguments("C2<string>", "C2<string?>").WithLocation(18, 26),
+                // (18,44): warning CS8619: Nullability of reference types in value of type 'C2<string>' doesn't match target type 'C2<string?>'.
+                //         c = new() { F1 = GetC2("c1"), F2 = GetC2("c2")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, @"GetC2(""c2"")").WithArguments("C2<string>", "C2<string?>").WithLocation(18, 44),
+                // (20,42): warning CS8619: Nullability of reference types in value of type 'C2<string>' doesn't match target type 'C2<string?>'.
+                //         var d = new C1<string?>() { F1 = new C2<string>("d1"), F2 = new C2<string>("d2")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, @"new C2<string>(""d1"")").WithArguments("C2<string>", "C2<string?>").WithLocation(20, 42),
+                // (20,69): warning CS8619: Nullability of reference types in value of type 'C2<string>' doesn't match target type 'C2<string?>'.
+                //         var d = new C1<string?>() { F1 = new C2<string>("d1"), F2 = new C2<string>("d2")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, @"new C2<string>(""d2"")").WithArguments("C2<string>", "C2<string?>").WithLocation(20, 69),
+                // (22,41): warning CS8619: Nullability of reference types in value of type 'C2<string?>' doesn't match target type 'C2<string>'.
+                //         var e = new C1<string>() { F1 = GetC2(s), F2 = GetC2("e")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "GetC2(s)").WithArguments("C2<string?>", "C2<string>").WithLocation(22, 41),
+                // (22,56): warning CS8619: Nullability of reference types in value of type 'C2<string>' doesn't match target type 'C2<string?>'.
+                //         var e = new C1<string>() { F1 = GetC2(s), F2 = GetC2("e")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, @"GetC2(""e"")").WithArguments("C2<string>", "C2<string?>").WithLocation(22, 56),
+                // (24,9): warning CS8602: Dereference of a possibly null reference.
+                //         e.F2.F3.ToString();
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "e.F2.F3").WithLocation(24, 9)
+                );
+        }
+
+        [Fact]
+        public void ObjectCreationExpression_TargetTyped_04()
+        {
+            var comp = CreateCompilation(@"
+class C
+{
+    static void M()
+    {
+        var b = GetC(""b"");
+        b = new() { null, ""b""};
+
+        var c = new C<string>() { null, ""c""};
+        C<string> d = new() { null, ""d""};
+    }
+
+    static C<T> GetC<T>(T t) => new C<T>(t);
+}
+
+class C<T> : System.Collections.IEnumerable
+{
+    public C(){}
+    public C(T t){}
+    public void Add(T t){}
+
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => throw null!;
+}
+", options: WithNullableEnable());
+
+            comp.VerifyDiagnostics(
+                // (7,21): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         b = new() { null, "b"};
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(7, 21),
+                // (9,35): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         var c = new C<string>() { null, "c"};
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(9, 35),
+                // (10,31): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         C<string> d = new() { null, "d"};
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(10, 31)
+                );
+        }
+
+        [Fact]
+        public void ObjectCreationExpression_TargetTyped_05()
+        {
+            var comp = CreateCompilation(@"
+class C
+{
+    static void M()
+    {
+        var s = ""s"";
+        s = null;
+
+        var b1 = GetC1(""b1"");
+        b1 = new() { GetC2(s), GetC2(""b1"")};
+
+        var b2 = new C1<string>() { GetC2(s), GetC2(""b2"")};
+
+        var c1 = GetC1(s);
+        c1 = new() { GetC2(s), GetC2(""c1"")};
+
+        var c2 = new C1<string?>() { GetC2(s), GetC2(""c2"")};
+    }
+
+    static C1<T> GetC1<T>(T t) => new C1<T>(new(t));
+    static C2<T> GetC2<T>(T t) => new C2<T>(t);
+}
+
+class C1<T> : System.Collections.IEnumerable
+{
+    public C1(){}
+    public C1(C2<T> t){}
+
+    public void Add(C2<T> t){}
+
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => throw null!;
+}
+
+class C2<T>
+{
+    public C2(T t){}
+}
+", options: WithNullableEnable());
+
+            comp.VerifyDiagnostics(
+                // (10,22): warning CS8620: Argument of type 'C2<string?>' cannot be used for parameter 't' of type 'C2<string>' in 'void C1<string>.Add(C2<string> t)' due to differences in the nullability of reference types.
+                //         b1 = new() { GetC2(s), GetC2("b1")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, "GetC2(s)").WithArguments("C2<string?>", "C2<string>", "t", "void C1<string>.Add(C2<string> t)").WithLocation(10, 22),
+                // (12,37): warning CS8620: Argument of type 'C2<string?>' cannot be used for parameter 't' of type 'C2<string>' in 'void C1<string>.Add(C2<string> t)' due to differences in the nullability of reference types.
+                //         var b2 = new C1<string>() { GetC2(s), GetC2("b2")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, "GetC2(s)").WithArguments("C2<string?>", "C2<string>", "t", "void C1<string>.Add(C2<string> t)").WithLocation(12, 37),
+                // (15,32): warning CS8620: Argument of type 'C2<string>' cannot be used for parameter 't' of type 'C2<string?>' in 'void C1<string?>.Add(C2<string?> t)' due to differences in the nullability of reference types.
+                //         c1 = new() { GetC2(s), GetC2("c1")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, @"GetC2(""c1"")").WithArguments("C2<string>", "C2<string?>", "t", "void C1<string?>.Add(C2<string?> t)").WithLocation(15, 32),
+                // (17,48): warning CS8620: Argument of type 'C2<string>' cannot be used for parameter 't' of type 'C2<string?>' in 'void C1<string?>.Add(C2<string?> t)' due to differences in the nullability of reference types.
+                //         var c2 = new C1<string?>() { GetC2(s), GetC2("c2")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, @"GetC2(""c2"")").WithArguments("C2<string>", "C2<string?>", "t", "void C1<string?>.Add(C2<string?> t)").WithLocation(17, 48)
+                );
+        }
+
+        [Fact]
+        public void ObjectCreationExpression_TargetTyped_06()
+        {
+            var comp = CreateCompilation(@"
+static class C
+{
+    static void M()
+    {
+        var s = ""s"";
+        s = null;
+
+        var b1 = GetC1(""b1"");
+        b1 = new() { GetC2(s), GetC2(""b1"")};
+
+        var b2 = new C1<string>() { GetC2(s), GetC2(""b2"")};
+
+        var c1 = GetC1(s);
+        c1 = new() { GetC2(s), GetC2(""c1"")};
+
+        var c2 = new C1<string?>() { GetC2(s), GetC2(""c2"")};
+    }
+
+    static C1<T> GetC1<T>(T t) => new C1<T>(new(t));
+    static C2<T> GetC2<T>(T t) => new C2<T>(t);
+
+    static void Add<T>(this C1<T> c, C2<T> t){}
+}
+
+class C1<T> : System.Collections.IEnumerable
+{
+    public C1(){}
+    public C1(C2<T> t){}
+
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => throw null!;
+}
+
+class C2<T>
+{
+    public C2(T t){}
+}
+", options: WithNullableEnable());
+
+            comp.VerifyDiagnostics(
+                // (10,22): warning CS8620: Argument of type 'C2<string?>' cannot be used for parameter 't' of type 'C2<string>' in 'void C.Add<string>(C1<string> c, C2<string> t)' due to differences in the nullability of reference types.
+                //         b1 = new() { GetC2(s), GetC2("b1")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, "GetC2(s)").WithArguments("C2<string?>", "C2<string>", "t", "void C.Add<string>(C1<string> c, C2<string> t)").WithLocation(10, 22),
+                // (12,37): warning CS8620: Argument of type 'C2<string?>' cannot be used for parameter 't' of type 'C2<string>' in 'void C.Add<string>(C1<string> c, C2<string> t)' due to differences in the nullability of reference types.
+                //         var b2 = new C1<string>() { GetC2(s), GetC2("b2")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, "GetC2(s)").WithArguments("C2<string?>", "C2<string>", "t", "void C.Add<string>(C1<string> c, C2<string> t)").WithLocation(12, 37),
+                // (15,14): warning CS8620: Argument of type 'C1<string?>' cannot be used for parameter 'c' of type 'C1<string>' in 'void C.Add<string>(C1<string> c, C2<string> t)' due to differences in the nullability of reference types.
+                //         c1 = new() { GetC2(s), GetC2("c1")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, @"new() { GetC2(s), GetC2(""c1"")}").WithArguments("C1<string?>", "C1<string>", "c", "void C.Add<string>(C1<string> c, C2<string> t)").WithLocation(15, 14),
+                // (17,22): warning CS8620: Argument of type 'C1<string?>' cannot be used for parameter 'c' of type 'C1<string>' in 'void C.Add<string>(C1<string> c, C2<string> t)' due to differences in the nullability of reference types.
+                //         var c2 = new C1<string?>() { GetC2(s), GetC2("c2")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, "C1<string?>").WithArguments("C1<string?>", "C1<string>", "c", "void C.Add<string>(C1<string> c, C2<string> t)").WithLocation(17, 22)
+                );
+        }
+
+        [Fact]
+        public void ObjectCreationExpression_TargetTyped_07()
+        {
+            var comp = CreateCompilation(@"
+class C
+{
+    static void M()
+    {
+        C<string>? a = new(null);
+        _ = (C<string>?)new(null);
+
+        C<string>? b = new() { F1 = null, F2 = ""b""};
+        b.Value.F1.ToString();
+        b.Value.F2.ToString();
+
+        var c = (C<string>?)new() { F1 = null, F2 = ""c""};
+        c.Value.F1.ToString();
+        c.Value.F2.ToString();
+    }
+}
+
+struct C<T>
+{
+    public C(){F1 = default!; F2 = default;}
+    public C(T t){F1 = t; F2 = default;}
+
+    public T F1;
+    public T? F2;
+}
+", options: WithNullableEnable());
+
+            comp.VerifyDiagnostics(
+                // (6,28): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         C<string>? a = new(null);
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(6, 28),
+                // (7,29): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         _ = (C<string>?)new(null);
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(7, 29),
+                // (9,37): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         C<string>? b = new() { F1 = null, F2 = "b"};
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(9, 37),
+                // (10,9): warning CS8602: Dereference of a possibly null reference.
+                //         b.Value.F1.ToString();
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "b.Value.F1").WithLocation(10, 9),
+                // (13,42): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         var c = (C<string>?)new() { F1 = null, F2 = "c"};
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(13, 42),
+                // (14,9): warning CS8602: Dereference of a possibly null reference.
+                //         c.Value.F1.ToString();
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "c.Value.F1").WithLocation(14, 9)
+                );
+        }
+
+        [Fact]
+        public void ObjectCreationExpression_TargetTyped_08()
+        {
+            var comp = CreateCompilation(@"
+class C
+{
+    static void M()
+    {
+        var a = GetC(""a"");
+        a = new(null);
+
+        var b = GetC(""b"");
+        b = new() { F1 = null, F2 = ""b""};
+        b.Value.F1.ToString();
+        b.Value.F2.ToString();
+    }
+
+    static C<T>? GetC<T>(T t) => new C<T>(t);
+}
+
+struct C<T>
+{
+    public C(){F1 = default!; F2 = default;}
+    public C(T t){F1 = t; F2 = default;}
+
+    public T F1;
+    public T? F2;
+}
+", options: WithNullableEnable());
+
+            comp.VerifyDiagnostics(
+                // (7,17): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         a = new(null);
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(7, 17),
+                // (10,26): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         b = new() { F1 = null, F2 = "b"};
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(10, 26),
+                // (11,9): warning CS8602: Dereference of a possibly null reference.
+                //         b.Value.F1.ToString();
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "b.Value.F1").WithLocation(11, 9)
+                );
+        }
+
+        [Fact]
+        public void ObjectCreationExpression_TargetTyped_09()
+        {
+            var comp = CreateCompilation(@"
+class C
+{
+    static void M()
+    {
+        var s = ""s"";
+        s = null;
+
+        var a = GetC1(""a"");
+        a = new(GetC2(s));
+
+        var b = GetC1(""b"");
+        b = new() { F1 = GetC2(s), F2 = GetC2(""b"")};
+        b.Value.F1.F3.ToString();
+        b.Value.F2.F3.ToString();
+
+        var c = GetC1(s);
+        c = new() { F1 = GetC2(""c1""), F2 = GetC2(""c2"")};
+
+        var d = new C1<string?>?(new C1<string?>() { F1 = new C2<string>(""d1""), F2 = new C2<string>(""d2"")});
+
+        var e = new C1<string>?(new C1<string>() { F1 = GetC2(s), F2 = GetC2(""e"")});
+        e.Value.F1.F3.ToString();
+        e.Value.F2.F3.ToString();
+    }
+
+    static C1<T>? GetC1<T>(T t) => new C1<T>(new(t));
+    static C2<T> GetC2<T>(T t) => new C2<T>(t);
+}
+
+struct C1<T>
+{
+    public C1(){this = default;}
+    public C1(C2<T> t){this = default;}
+
+    public C2<T>? F1;
+    public C2<T?>? F2;
+}
+
+class C2<T>
+{
+    public C2(T t){F3 = t;}
+    public T F3;
+}
+", options: WithNullableEnable());
+
+            comp.VerifyDiagnostics(
+                // (10,17): warning CS8620: Argument of type 'C2<string?>' cannot be used for parameter 't' of type 'C2<string>' in 'C1<string>.C1(C2<string> t)' due to differences in the nullability of reference types.
+                //         a = new(GetC2(s));
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, "GetC2(s)").WithArguments("C2<string?>", "C2<string>", "t", "C1<string>.C1(C2<string> t)").WithLocation(10, 17),
+                // (13,26): warning CS8619: Nullability of reference types in value of type 'C2<string?>' doesn't match target type 'C2<string>'.
+                //         b = new() { F1 = GetC2(s), F2 = GetC2("b")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "GetC2(s)").WithArguments("C2<string?>", "C2<string>").WithLocation(13, 26),
+                // (13,41): warning CS8619: Nullability of reference types in value of type 'C2<string>' doesn't match target type 'C2<string?>'.
+                //         b = new() { F1 = GetC2(s), F2 = GetC2("b")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, @"GetC2(""b"")").WithArguments("C2<string>", "C2<string?>").WithLocation(13, 41),
+                // (15,9): warning CS8602: Dereference of a possibly null reference.
+                //         b.Value.F2.F3.ToString();
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "b.Value.F2.F3").WithLocation(15, 9),
+                // (18,26): warning CS8619: Nullability of reference types in value of type 'C2<string>' doesn't match target type 'C2<string?>'.
+                //         c = new() { F1 = GetC2("c1"), F2 = GetC2("c2")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, @"GetC2(""c1"")").WithArguments("C2<string>", "C2<string?>").WithLocation(18, 26),
+                // (18,44): warning CS8619: Nullability of reference types in value of type 'C2<string>' doesn't match target type 'C2<string?>'.
+                //         c = new() { F1 = GetC2("c1"), F2 = GetC2("c2")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, @"GetC2(""c2"")").WithArguments("C2<string>", "C2<string?>").WithLocation(18, 44),
+                // (20,59): warning CS8619: Nullability of reference types in value of type 'C2<string>' doesn't match target type 'C2<string?>'.
+                //         var d = new C1<string?>?(new C1<string?>() { F1 = new C2<string>("d1"), F2 = new C2<string>("d2")});
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, @"new C2<string>(""d1"")").WithArguments("C2<string>", "C2<string?>").WithLocation(20, 59),
+                // (20,86): warning CS8619: Nullability of reference types in value of type 'C2<string>' doesn't match target type 'C2<string?>'.
+                //         var d = new C1<string?>?(new C1<string?>() { F1 = new C2<string>("d1"), F2 = new C2<string>("d2")});
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, @"new C2<string>(""d2"")").WithArguments("C2<string>", "C2<string?>").WithLocation(20, 86),
+                // (22,57): warning CS8619: Nullability of reference types in value of type 'C2<string?>' doesn't match target type 'C2<string>'.
+                //         var e = new C1<string>?(new C1<string>() { F1 = GetC2(s), F2 = GetC2("e")});
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "GetC2(s)").WithArguments("C2<string?>", "C2<string>").WithLocation(22, 57),
+                // (22,72): warning CS8619: Nullability of reference types in value of type 'C2<string>' doesn't match target type 'C2<string?>'.
+                //         var e = new C1<string>?(new C1<string>() { F1 = GetC2(s), F2 = GetC2("e")});
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, @"GetC2(""e"")").WithArguments("C2<string>", "C2<string?>").WithLocation(22, 72),
+                // (24,9): warning CS8602: Dereference of a possibly null reference.
+                //         e.Value.F2.F3.ToString();
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "e.Value.F2.F3").WithLocation(24, 9)
+                );
+        }
+
+        [Fact]
+        public void ObjectCreationExpression_TargetTyped_10()
+        {
+            var comp = CreateCompilation(@"
+class C
+{
+    static void M()
+    {
+        var b = GetC(""b"");
+        b = new() { null, ""b""};
+
+        var c = new C<string>?(new C<string>() { null, ""c""});
+        C<string>? d = new() { null, ""d""};
+    }
+
+    static C<T>? GetC<T>(T t) => new C<T>(t);
+}
+
+struct C<T> : System.Collections.IEnumerable
+{
+    public C(){}
+    public C(T t){}
+    public void Add(T t){}
+
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => throw null!;
+}
+", options: WithNullableEnable());
+
+            comp.VerifyDiagnostics(
+                // (7,21): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         b = new() { null, "b"};
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(7, 21),
+                // (9,50): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         var c = new C<string>?(new C<string>() { null, "c"});
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(9, 50),
+                // (10,32): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         C<string>? d = new() { null, "d"};
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(10, 32)
+                );
+        }
+
+        [Fact]
+        public void ObjectCreationExpression_TargetTyped_11()
+        {
+            var comp = CreateCompilation(@"
+class C
+{
+    static void M()
+    {
+        var s = ""s"";
+        s = null;
+
+        var b1 = GetC1(""b1"");
+        b1 = new() { GetC2(s), GetC2(""b1"")};
+
+        var b2 = new C1<string>?(new C1<string>() { GetC2(s), GetC2(""b2"")});
+
+        var c1 = GetC1(s);
+        c1 = new() { GetC2(s), GetC2(""c1"")};
+
+        var c2 = new C1<string?>?(new C1<string?>() { GetC2(s), GetC2(""c2"")});
+    }
+
+    static C1<T>? GetC1<T>(T t) => new C1<T>(new(t));
+    static C2<T> GetC2<T>(T t) => new C2<T>(t);
+}
+
+struct C1<T> : System.Collections.IEnumerable
+{
+    public C1(){}
+    public C1(C2<T> t){}
+
+    public void Add(C2<T> t){}
+
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => throw null!;
+}
+
+class C2<T>
+{
+    public C2(T t){}
+}
+", options: WithNullableEnable());
+
+            comp.VerifyDiagnostics(
+                // (10,22): warning CS8620: Argument of type 'C2<string?>' cannot be used for parameter 't' of type 'C2<string>' in 'void C1<string>.Add(C2<string> t)' due to differences in the nullability of reference types.
+                //         b1 = new() { GetC2(s), GetC2("b1")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, "GetC2(s)").WithArguments("C2<string?>", "C2<string>", "t", "void C1<string>.Add(C2<string> t)").WithLocation(10, 22),
+                // (12,53): warning CS8620: Argument of type 'C2<string?>' cannot be used for parameter 't' of type 'C2<string>' in 'void C1<string>.Add(C2<string> t)' due to differences in the nullability of reference types.
+                //         var b2 = new C1<string>?(new C1<string>() { GetC2(s), GetC2("b2")});
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, "GetC2(s)").WithArguments("C2<string?>", "C2<string>", "t", "void C1<string>.Add(C2<string> t)").WithLocation(12, 53),
+                // (15,32): warning CS8620: Argument of type 'C2<string>' cannot be used for parameter 't' of type 'C2<string?>' in 'void C1<string?>.Add(C2<string?> t)' due to differences in the nullability of reference types.
+                //         c1 = new() { GetC2(s), GetC2("c1")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, @"GetC2(""c1"")").WithArguments("C2<string>", "C2<string?>", "t", "void C1<string?>.Add(C2<string?> t)").WithLocation(15, 32),
+                // (17,65): warning CS8620: Argument of type 'C2<string>' cannot be used for parameter 't' of type 'C2<string?>' in 'void C1<string?>.Add(C2<string?> t)' due to differences in the nullability of reference types.
+                //         var c2 = new C1<string?>?(new C1<string?>() { GetC2(s), GetC2("c2")});
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, @"GetC2(""c2"")").WithArguments("C2<string>", "C2<string?>", "t", "void C1<string?>.Add(C2<string?> t)").WithLocation(17, 65)
+                );
+        }
+
+        [Fact]
+        public void ObjectCreationExpression_TargetTyped_12()
+        {
+            var comp = CreateCompilation(@"
+static class C
+{
+    static void M()
+    {
+        var s = ""s"";
+        s = null;
+
+        var b1 = GetC1(""b1"");
+        b1 = new() { GetC2(s), GetC2(""b1"")};
+
+        var b2 = new C1<string>?(new C1<string>() { GetC2(s), GetC2(""b2"")});
+
+        var c1 = GetC1(s);
+        c1 = new() { GetC2(s), GetC2(""c1"")};
+
+        var c2 = new C1<string?>?(new C1<string?>() { GetC2(s), GetC2(""c2"")});
+    }
+
+    static C1<T>? GetC1<T>(T t) => new C1<T>(new(t));
+    static C2<T> GetC2<T>(T t) => new C2<T>(t);
+
+    static void Add<T>(this C1<T> c, C2<T> t){}
+}
+
+struct C1<T> : System.Collections.IEnumerable
+{
+    public C1(){}
+    public C1(C2<T> t){}
+
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => throw null!;
+}
+
+class C2<T>
+{
+    public C2(T t){}
+}
+", options: WithNullableEnable());
+
+            comp.VerifyDiagnostics(
+                // (10,22): warning CS8620: Argument of type 'C2<string?>' cannot be used for parameter 't' of type 'C2<string>' in 'void C.Add<string>(C1<string> c, C2<string> t)' due to differences in the nullability of reference types.
+                //         b1 = new() { GetC2(s), GetC2("b1")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, "GetC2(s)").WithArguments("C2<string?>", "C2<string>", "t", "void C.Add<string>(C1<string> c, C2<string> t)").WithLocation(10, 22),
+                // (12,53): warning CS8620: Argument of type 'C2<string?>' cannot be used for parameter 't' of type 'C2<string>' in 'void C.Add<string>(C1<string> c, C2<string> t)' due to differences in the nullability of reference types.
+                //         var b2 = new C1<string>?(new C1<string>() { GetC2(s), GetC2("b2")});
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, "GetC2(s)").WithArguments("C2<string?>", "C2<string>", "t", "void C.Add<string>(C1<string> c, C2<string> t)").WithLocation(12, 53),
+                // (15,14): warning CS8620: Argument of type 'C1<string?>' cannot be used for parameter 'c' of type 'C1<string>' in 'void C.Add<string>(C1<string> c, C2<string> t)' due to differences in the nullability of reference types.
+                //         c1 = new() { GetC2(s), GetC2("c1")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, @"new() { GetC2(s), GetC2(""c1"")}").WithArguments("C1<string?>", "C1<string>", "c", "void C.Add<string>(C1<string> c, C2<string> t)").WithLocation(15, 14),
+                // (17,39): warning CS8620: Argument of type 'C1<string?>' cannot be used for parameter 'c' of type 'C1<string>' in 'void C.Add<string>(C1<string> c, C2<string> t)' due to differences in the nullability of reference types.
+                //         var c2 = new C1<string?>?(new C1<string?>() { GetC2(s), GetC2("c2")});
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, "C1<string?>").WithArguments("C1<string?>", "C1<string>", "c", "void C.Add<string>(C1<string> c, C2<string> t)").WithLocation(17, 39)
+                );
+        }
+
+        [Fact]
+        public void ObjectCreationExpression_TargetTyped_13()
+        {
+            var comp = CreateCompilation(@"
+class C
+{
+    static void M()
+    {
+        var b = GetC(""b"");
+        b = new() { default(string), ""b""};
+
+        var c = new C<string>?(new C<string>() { default(string), ""c""});
+        C<string>? d = new() { default(string), ""d""};
+    }
+
+    static C<T>? GetC<T>(T t) => new C<T>(t);
+}
+
+struct C<T> : System.Collections.IEnumerable
+{
+    public C(){}
+    public C(T t){}
+    public void Add<U>(U u) where U : T {}
+
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => throw null!;
+}
+", options: WithNullableEnable());
+
+            comp.VerifyDiagnostics(
+                // (7,21): warning CS8631: The type 'string?' cannot be used as type parameter 'U' in the generic type or method 'C<string>.Add<U>(U)'. Nullability of type argument 'string?' doesn't match constraint type 'string'.
+                //         b = new() { default(string), "b"};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInTypeParameterConstraint, "default(string)").WithArguments("C<string>.Add<U>(U)", "string", "U", "string?").WithLocation(7, 21),
+                // (9,50): warning CS8631: The type 'string?' cannot be used as type parameter 'U' in the generic type or method 'C<string>.Add<U>(U)'. Nullability of type argument 'string?' doesn't match constraint type 'string'.
+                //         var c = new C<string>?(new C<string>() { default(string), "c"});
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInTypeParameterConstraint, "default(string)").WithArguments("C<string>.Add<U>(U)", "string", "U", "string?").WithLocation(9, 50),
+                // (10,32): warning CS8631: The type 'string?' cannot be used as type parameter 'U' in the generic type or method 'C<string>.Add<U>(U)'. Nullability of type argument 'string?' doesn't match constraint type 'string'.
+                //         C<string>? d = new() { default(string), "d"};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInTypeParameterConstraint, "default(string)").WithArguments("C<string>.Add<U>(U)", "string", "U", "string?").WithLocation(10, 32)
+                );
+        }
+
+        [Fact]
+        public void DynamicObjectCreationExpression_TargetTyped_01()
+        {
+            var comp = CreateCompilation(@"
+class C
+{
+    static void M(dynamic d)
+    {
+        C<string> a = new(null, d);
+        _ = (C<string>)new(null, d);
+
+        C<string> b = new(d) { F1 = null, F2 = ""b""};
+        b.F1.ToString();
+        b.F2.ToString();
+
+        var c = (C<string>)new(d) { F1 = null, F2 = ""c""};
+        c.F1.ToString();
+        c.F2.ToString();
+
+        _ = new C<string>(null, d);
+    }
+}
+
+class C<T>
+{
+    public C(int x){F1 = default!;}
+    public C(T t, int x){F1 = t;}
+
+    public T F1;
+    public T? F2;
+}
+", options: WithNullableEnable());
+
+            comp.VerifyDiagnostics(
+                // (9,37): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         C<string> b = new(d) { F1 = null, F2 = "b"};
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(9, 37),
+                // (10,9): warning CS8602: Dereference of a possibly null reference.
+                //         b.F1.ToString();
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "b.F1").WithLocation(10, 9),
+                // (13,42): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         var c = (C<string>)new(d) { F1 = null, F2 = "c"};
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(13, 42),
+                // (14,9): warning CS8602: Dereference of a possibly null reference.
+                //         c.F1.ToString();
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "c.F1").WithLocation(14, 9)
+                );
+        }
+
+        [Fact]
+        public void DynamicObjectCreationExpression_TargetTyped_02()
+        {
+            var comp = CreateCompilation(@"
+class C
+{
+    static void M(dynamic d)
+    {
+        var a = GetC(""a"");
+        a = new(null, d);
+
+        var b = GetC(""b"");
+        b = new(d) { F1 = null, F2 = ""b""};
+        b.F1.ToString();
+        b.F2.ToString();
+
+        _ = new C<string>(null, d);
+    }
+
+    static C<T> GetC<T>(T t) => new C<T>(t, 0);
+}
+
+class C<T>
+{
+    public C(int x){F1 = default!;}
+    public C(T t, int x){F1 = t;}
+
+    public T F1;
+    public T? F2;
+}
+", options: WithNullableEnable());
+
+            comp.VerifyDiagnostics(
+                // (10,27): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         b = new(d) { F1 = null, F2 = "b"};
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(10, 27),
+                // (11,9): warning CS8602: Dereference of a possibly null reference.
+                //         b.F1.ToString();
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "b.F1").WithLocation(11, 9)
+                );
+        }
+
+        [Fact]
+        public void DynamicObjectCreationExpression_TargetTyped_03()
+        {
+            var comp = CreateCompilation(@"
+class C
+{
+    static void M(dynamic dd)
+    {
+        var s = ""s"";
+        s = null;
+
+        var a = GetC1(""a"");
+        a = new(GetC2(s), dd);
+
+        var b = GetC1(""b"");
+        b = new(dd) { F1 = GetC2(s), F2 = GetC2(""b"")};
+        b.F1.F3.ToString();
+        b.F2.F3.ToString();
+
+        var c = GetC1(s);
+        c = new(dd) { F1 = GetC2(""c1""), F2 = GetC2(""c2"")};
+
+        var d = new C1<string?>(dd) { F1 = new C2<string>(""d1""), F2 = new C2<string>(""d2"")};
+
+        var e = new C1<string>(dd) { F1 = GetC2(s), F2 = GetC2(""e"")};
+        e.F1.F3.ToString();
+        e.F2.F3.ToString();
+
+        _ = new C1<string>(GetC2(s), dd);
+    }
+
+    static C1<T> GetC1<T>(T t) => new C1<T>(new(t), 0);
+    static C2<T> GetC2<T>(T t) => new C2<T>(t);
+}
+
+class C1<T>
+{
+    public C1(int x){}
+    public C1(C2<T> t, int x){}
+
+    public C2<T>? F1;
+    public C2<T?>? F2;
+}
+
+class C2<T>
+{
+    public C2(T t){F3 = t;}
+    public T F3;
+}
+", options: WithNullableEnable());
+
+            comp.VerifyDiagnostics(
+                // (13,28): warning CS8619: Nullability of reference types in value of type 'C2<string?>' doesn't match target type 'C2<string>'.
+                //         b = new(dd) { F1 = GetC2(s), F2 = GetC2("b")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "GetC2(s)").WithArguments("C2<string?>", "C2<string>").WithLocation(13, 28),
+                // (13,43): warning CS8619: Nullability of reference types in value of type 'C2<string>' doesn't match target type 'C2<string?>'.
+                //         b = new(dd) { F1 = GetC2(s), F2 = GetC2("b")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, @"GetC2(""b"")").WithArguments("C2<string>", "C2<string?>").WithLocation(13, 43),
+                // (15,9): warning CS8602: Dereference of a possibly null reference.
+                //         b.F2.F3.ToString();
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "b.F2.F3").WithLocation(15, 9),
+                // (18,28): warning CS8619: Nullability of reference types in value of type 'C2<string>' doesn't match target type 'C2<string?>'.
+                //         c = new(dd) { F1 = GetC2("c1"), F2 = GetC2("c2")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, @"GetC2(""c1"")").WithArguments("C2<string>", "C2<string?>").WithLocation(18, 28),
+                // (18,46): warning CS8619: Nullability of reference types in value of type 'C2<string>' doesn't match target type 'C2<string?>'.
+                //         c = new(dd) { F1 = GetC2("c1"), F2 = GetC2("c2")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, @"GetC2(""c2"")").WithArguments("C2<string>", "C2<string?>").WithLocation(18, 46),
+                // (20,44): warning CS8619: Nullability of reference types in value of type 'C2<string>' doesn't match target type 'C2<string?>'.
+                //         var d = new C1<string?>(dd) { F1 = new C2<string>("d1"), F2 = new C2<string>("d2")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, @"new C2<string>(""d1"")").WithArguments("C2<string>", "C2<string?>").WithLocation(20, 44),
+                // (20,71): warning CS8619: Nullability of reference types in value of type 'C2<string>' doesn't match target type 'C2<string?>'.
+                //         var d = new C1<string?>(dd) { F1 = new C2<string>("d1"), F2 = new C2<string>("d2")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, @"new C2<string>(""d2"")").WithArguments("C2<string>", "C2<string?>").WithLocation(20, 71),
+                // (22,43): warning CS8619: Nullability of reference types in value of type 'C2<string?>' doesn't match target type 'C2<string>'.
+                //         var e = new C1<string>(dd) { F1 = GetC2(s), F2 = GetC2("e")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "GetC2(s)").WithArguments("C2<string?>", "C2<string>").WithLocation(22, 43),
+                // (22,58): warning CS8619: Nullability of reference types in value of type 'C2<string>' doesn't match target type 'C2<string?>'.
+                //         var e = new C1<string>(dd) { F1 = GetC2(s), F2 = GetC2("e")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, @"GetC2(""e"")").WithArguments("C2<string>", "C2<string?>").WithLocation(22, 58),
+                // (24,9): warning CS8602: Dereference of a possibly null reference.
+                //         e.F2.F3.ToString();
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "e.F2.F3").WithLocation(24, 9)
+                );
+        }
+
+        [Fact]
+        public void DynamicObjectCreationExpression_TargetTyped_04()
+        {
+            var comp = CreateCompilation(@"
+class C
+{
+    static void M(dynamic dd)
+    {
+        var b = GetC(""b"");
+        b = new(dd) { null, ""b""};
+
+        var c = new C<string>(dd) { null, ""c""};
+        C<string> d = new(dd) { null, ""d""};
+    }
+
+    static C<T> GetC<T>(T t) => new C<T>(t, 0);
+}
+
+class C<T> : System.Collections.IEnumerable
+{
+    public C(int x){}
+    public C(T t, int x){}
+    public void Add(T t){}
+
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => throw null!;
+}
+", options: WithNullableEnable());
+
+            comp.VerifyDiagnostics(
+                // (7,23): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         b = new(dd) { null, "b"};
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(7, 23),
+                // (9,37): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         var c = new C<string>(dd) { null, "c"};
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(9, 37),
+                // (10,33): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         C<string> d = new(dd) { null, "d"};
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(10, 33)
+                );
+        }
+
+        [Fact]
+        public void DynamicObjectCreationExpression_TargetTyped_05()
+        {
+            var comp = CreateCompilation(@"
+class C
+{
+    static void M(dynamic dd)
+    {
+        var s = ""s"";
+        s = null;
+
+        var b1 = GetC1(""b1"");
+        b1 = new(dd) { GetC2(s), GetC2(""b1"")};
+
+        var b2 = new C1<string>(dd) { GetC2(s), GetC2(""b2"")};
+
+        var c1 = GetC1(s);
+        c1 = new(dd) { GetC2(s), GetC2(""c1"")};
+
+        var c2 = new C1<string?>(dd) { GetC2(s), GetC2(""c2"")};
+    }
+
+    static C1<T> GetC1<T>(T t) => new C1<T>(new(t), 0);
+    static C2<T> GetC2<T>(T t) => new C2<T>(t);
+}
+
+class C1<T> : System.Collections.IEnumerable
+{
+    public C1(int x){}
+    public C1(C2<T> t, int x){}
+
+    public void Add(C2<T> t){}
+
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => throw null!;
+}
+
+class C2<T>
+{
+    public C2(T t){}
+}
+", options: WithNullableEnable());
+
+            comp.VerifyDiagnostics(
+                // (10,24): warning CS8620: Argument of type 'C2<string?>' cannot be used for parameter 't' of type 'C2<string>' in 'void C1<string>.Add(C2<string> t)' due to differences in the nullability of reference types.
+                //         b1 = new(dd) { GetC2(s), GetC2("b1")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, "GetC2(s)").WithArguments("C2<string?>", "C2<string>", "t", "void C1<string>.Add(C2<string> t)").WithLocation(10, 24),
+                // (12,39): warning CS8620: Argument of type 'C2<string?>' cannot be used for parameter 't' of type 'C2<string>' in 'void C1<string>.Add(C2<string> t)' due to differences in the nullability of reference types.
+                //         var b2 = new C1<string>(dd) { GetC2(s), GetC2("b2")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, "GetC2(s)").WithArguments("C2<string?>", "C2<string>", "t", "void C1<string>.Add(C2<string> t)").WithLocation(12, 39),
+                // (15,34): warning CS8620: Argument of type 'C2<string>' cannot be used for parameter 't' of type 'C2<string?>' in 'void C1<string?>.Add(C2<string?> t)' due to differences in the nullability of reference types.
+                //         c1 = new(dd) { GetC2(s), GetC2("c1")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, @"GetC2(""c1"")").WithArguments("C2<string>", "C2<string?>", "t", "void C1<string?>.Add(C2<string?> t)").WithLocation(15, 34),
+                // (17,50): warning CS8620: Argument of type 'C2<string>' cannot be used for parameter 't' of type 'C2<string?>' in 'void C1<string?>.Add(C2<string?> t)' due to differences in the nullability of reference types.
+                //         var c2 = new C1<string?>(dd) { GetC2(s), GetC2("c2")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, @"GetC2(""c2"")").WithArguments("C2<string>", "C2<string?>", "t", "void C1<string?>.Add(C2<string?> t)").WithLocation(17, 50)
+                );
+        }
+
+        [Fact]
+        public void DynamicObjectCreationExpression_TargetTyped_06()
+        {
+            var comp = CreateCompilation(@"
+static class C
+{
+    static void M(dynamic dd)
+    {
+        var s = ""s"";
+        s = null;
+
+        var b1 = GetC1(""b1"");
+        b1 = new(dd) { GetC2(s), GetC2(""b1"")};
+
+        var b2 = new C1<string>(dd) { GetC2(s), GetC2(""b2"")};
+
+        var c1 = GetC1(s);
+        c1 = new(dd) { GetC2(s), GetC2(""c1"")};
+
+        var c2 = new C1<string?>(dd) { GetC2(s), GetC2(""c2"")};
+    }
+
+    static C1<T> GetC1<T>(T t) => new C1<T>(new(t), 0);
+    static C2<T> GetC2<T>(T t) => new C2<T>(t);
+
+    static void Add<T>(this C1<T> c, C2<T> t){}
+}
+
+class C1<T> : System.Collections.IEnumerable
+{
+    public C1(int x){}
+    public C1(C2<T> t, int x){}
+
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => throw null!;
+}
+
+class C2<T>
+{
+    public C2(T t){}
+}
+", options: WithNullableEnable());
+
+            comp.VerifyDiagnostics(
+                // (10,24): warning CS8620: Argument of type 'C2<string?>' cannot be used for parameter 't' of type 'C2<string>' in 'void C.Add<string>(C1<string> c, C2<string> t)' due to differences in the nullability of reference types.
+                //         b1 = new(dd) { GetC2(s), GetC2("b1")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, "GetC2(s)").WithArguments("C2<string?>", "C2<string>", "t", "void C.Add<string>(C1<string> c, C2<string> t)").WithLocation(10, 24),
+                // (12,39): warning CS8620: Argument of type 'C2<string?>' cannot be used for parameter 't' of type 'C2<string>' in 'void C.Add<string>(C1<string> c, C2<string> t)' due to differences in the nullability of reference types.
+                //         var b2 = new C1<string>(dd) { GetC2(s), GetC2("b2")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, "GetC2(s)").WithArguments("C2<string?>", "C2<string>", "t", "void C.Add<string>(C1<string> c, C2<string> t)").WithLocation(12, 39),
+                // (15,14): warning CS8620: Argument of type 'C1<string?>' cannot be used for parameter 'c' of type 'C1<string>' in 'void C.Add<string>(C1<string> c, C2<string> t)' due to differences in the nullability of reference types.
+                //         c1 = new(dd) { GetC2(s), GetC2("c1")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, @"new(dd) { GetC2(s), GetC2(""c1"")}").WithArguments("C1<string?>", "C1<string>", "c", "void C.Add<string>(C1<string> c, C2<string> t)").WithLocation(15, 14),
+                // (17,22): warning CS8620: Argument of type 'C1<string?>' cannot be used for parameter 'c' of type 'C1<string>' in 'void C.Add<string>(C1<string> c, C2<string> t)' due to differences in the nullability of reference types.
+                //         var c2 = new C1<string?>(dd) { GetC2(s), GetC2("c2")};
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInArgument, "C1<string?>").WithArguments("C1<string?>", "C1<string>", "c", "void C.Add<string>(C1<string> c, C2<string> t)").WithLocation(17, 22)
+                );
+        }
+
+        [Fact]
+        public void NewT_TargetTyped_01()
+        {
+            var comp = CreateCompilation(@"
+class C
+{
+    static void M<T>() where T : C<string>, new()
+    {
+        T b = new() { F1 = null, F2 = ""b""};
+        b.F1.ToString();
+        b.F2.ToString();
+
+        var c = (T)new() { F1 = null, F2 = ""c""};
+        c.F1.ToString();
+        c.F2.ToString();
+
+        var d = new T() { F1 = null, F2 = ""d""};
+        d.F1.ToString();
+        d.F2.ToString();
+    }
+}
+
+class C<T>
+{
+    public C(){F1 = default!;}
+    public C(T t){F1 = t;}
+
+    public T F1;
+    public T? F2;
+}
+", options: WithNullableEnable());
+
+            comp.VerifyDiagnostics(
+                // (6,28): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         T b = new() { F1 = null, F2 = "b"};
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(6, 28),
+                // (7,9): warning CS8602: Dereference of a possibly null reference.
+                //         b.F1.ToString();
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "b.F1").WithLocation(7, 9),
+                // (10,33): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         var c = (T)new() { F1 = null, F2 = "c"};
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(10, 33),
+                // (11,9): warning CS8602: Dereference of a possibly null reference.
+                //         c.F1.ToString();
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "c.F1").WithLocation(11, 9),
+                // (14,32): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         var d = new T() { F1 = null, F2 = "d"};
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(14, 32),
+                // (15,9): warning CS8602: Dereference of a possibly null reference.
+                //         d.F1.ToString();
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "d.F1").WithLocation(15, 9)
+                );
+        }
+
+        [Fact]
+        public void NoPiaObjectCreationExpression_TargetTyped_01()
+        {
+            string pia = @"
+using System;
+using System.Runtime.InteropServices;
+
+[assembly: ImportedFromTypeLib(""GeneralPIA.dll"")]
+[assembly: Guid(""f9c2d51d-4f44-45f0-9eda-c9d599b58257"")]
+
+[ComImport()]
+[Guid(""f9c2d51d-4f44-45f0-9eda-c9d599b58277"")]
+[CoClass(typeof(ClassITest28))]
+public interface ITest28
+{
+    ITest28 P1 {get; set;}
+    ITest28? P2 {get; set;}
+}
+
+[Guid(""f9c2d51d-4f44-45f0-9eda-c9d599b58278"")]
+public abstract class ClassITest28 //: ITest28
+{
+    public ClassITest28(int x){}
+}
+";
+
+            var piaCompilation = CreateCompilationWithMscorlib45(pia, options: WithNullableEnable(TestOptions.DebugDll));
+
+            CSharpCompilation c = CreateCompilationWithMscorlib45(
+new[] { @"
+class C
+{
+    static void Main()
+    {}
+
+    void Test2(ITest28? x2, ITest28? y2)
+    {
+        ITest28 z2 = new () { P1 = x2, P2 = y2 };
+        z2.P2.ToString();
+    }
+
+    void Test3(ITest28 x3, ITest28 y3)
+    {
+        ITest28 z32 = new () { P1 = x3, P2 = y3 };
+        z32.P2.ToString();
+    }
+}
+" }, options: WithNullableEnable(), references: new MetadataReference[] { piaCompilation.ToMetadataReference(embedInteropTypes: true) });
+
+            c.VerifyDiagnostics(
+                // (9,36): warning CS8601: Possible null reference assignment.
+                //         ITest28 z2 = new () { P1 = x2, P2 = y2 };
+                Diagnostic(ErrorCode.WRN_NullReferenceAssignment, "x2").WithLocation(9, 36),
+                // (10,9): warning CS8602: Dereference of a possibly null reference.
+                //         z2.P2.ToString();
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "z2.P2").WithLocation(10, 9)
+                );
+        }
+
+        [Fact]
+        public void NoPiaObjectCreationExpression_TargetTyped_02()
+        {
+            string pia = @"
+using System;
+using System.Runtime.InteropServices;
+
+[assembly: ImportedFromTypeLib(""GeneralPIA.dll"")]
+[assembly: Guid(""f9c2d51d-4f44-45f0-9eda-c9d599b58257"")]
+
+[ComImport()]
+[Guid(""f9c2d51d-4f44-45f0-9eda-c9d599b58277"")]
+[CoClass(typeof(ClassITest28))]
+public interface ITest28 : System.Collections.IEnumerable
+{
+    void Add(ITest28 x);
+}
+
+[Guid(""f9c2d51d-4f44-45f0-9eda-c9d599b58278"")]
+public abstract class ClassITest28 //: ITest28
+{
+    public ClassITest28(int x){}
+}
+";
+
+            var piaCompilation = CreateCompilationWithMscorlib45(pia, options: WithNullableEnable(TestOptions.DebugDll));
+
+            CSharpCompilation c = CreateCompilationWithMscorlib45(
+new[] { @"
+class C
+{
+    static void Main()
+    {}
+
+    void Test2(ITest28? x2, ITest28 y2)
+    {
+        ITest28 z2 = new () { x2, y2 };
+    }
+}
+" }, options: WithNullableEnable(), references: new MetadataReference[] { piaCompilation.ToMetadataReference(embedInteropTypes: true) });
+
+            c.VerifyDiagnostics(
+                // (9,31): warning CS8604: Possible null reference argument for parameter 'x' in 'void ITest28.Add(ITest28 x)'.
+                //         ITest28 z2 = new () { x2, y2 };
+                Diagnostic(ErrorCode.WRN_NullReferenceArgument, "x2").WithArguments("x", "void ITest28.Add(ITest28 x)").WithLocation(9, 31)
+                );
+        }
+
+        [Fact]
+        public void NoPiaObjectCreationExpression_TargetTyped_03()
+        {
+            string pia = @"
+using System;
+using System.Runtime.InteropServices;
+
+[assembly: ImportedFromTypeLib(""GeneralPIA.dll"")]
+[assembly: Guid(""f9c2d51d-4f44-45f0-9eda-c9d599b58257"")]
+
+[ComImport()]
+[Guid(""f9c2d51d-4f44-45f0-9eda-c9d599b58277"")]
+[CoClass(typeof(ClassITest28))]
+public interface ITest28
+{
+    ITest28 P1 {get; set;}
+    ITest28? P2 {get; set;}
+}
+
+[Guid(""f9c2d51d-4f44-45f0-9eda-c9d599b58278"")]
+public abstract class ClassITest28 //: ITest28
+{
+    public ClassITest28(int x){}
+}
+";
+
+            var piaCompilation = CreateCompilationWithMscorlib45(pia, options: WithNullableEnable(TestOptions.DebugDll));
+
+            CSharpCompilation c = CreateCompilationWithMscorlib45(
+new[] { @"
+class C
+{
+    static void Main()
+    {}
+
+    void Test2(ITest28? x2, ITest28? y2)
+    {
+        ITest28 z2 = new (1) { P1 = x2, P2 = y2 };
+        z2.P2.ToString();
+    }
+}
+" }, options: WithNullableEnable(), references: new MetadataReference[] { piaCompilation.ToMetadataReference(embedInteropTypes: true) });
+
+            c.VerifyDiagnostics(
+                // (9,22): error CS1729: 'ITest28' does not contain a constructor that takes 1 arguments
+                //         ITest28 z2 = new (1) { P1 = x2, P2 = y2 };
+                Diagnostic(ErrorCode.ERR_BadCtorArgCount, "new (1) { P1 = x2, P2 = y2 }").WithArguments("ITest28", "1").WithLocation(9, 22),
+                // (10,9): warning CS8602: Dereference of a possibly null reference.
+                //         z2.P2.ToString();
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "z2.P2").WithLocation(10, 9)
+                );
+        }
+
+        /// <summary>
+        /// This is a clone of <see cref="DelegateCreation_02"/>
+        /// </summary>
+        [Fact]
+        public void DelegateCreation_02_TargetTyped()
+        {
+            CSharpCompilation c = CreateCompilation(new[] { @"
+class C
+{
+    static void Main()
+    {
+    }
+
+    CL0<string?> M1(CL0<string> x) { throw new System.Exception(); }
+    CL0<string> M2(CL0<string> x) { throw new System.Exception(); }
+    delegate CL0<string> D1(CL0<string?> x);
+
+    void Test1()
+    {
+        D1 x1 = new   (M1);
+        D1 x2 = new   (M2);
+    }
+
+    CL0<string> M3(CL0<string?> x) { throw new System.Exception(); }
+    CL0<string?> M4(CL0<string?> x) { throw new System.Exception(); }
+    delegate CL0<string?> D2(CL0<string> x);
+
+    void Test2()
+    {
+        D2 x1 = new   (M3);
+        D2 x2 = new   (M4);
+    }
+}
+
+class CL0<T>{}
+" }, options: WithNullableEnable());
+
+            c.VerifyDiagnostics(
+                // (14,24): warning CS8621: Nullability of reference types in return type of 'CL0<string?> C.M1(CL0<string> x)' doesn't match the target delegate 'C.D1' (possibly because of nullability attributes).
+                //         D1 x1 = new   (M1);
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInReturnTypeOfTargetDelegate, "M1").WithArguments("CL0<string?> C.M1(CL0<string> x)", "C.D1").WithLocation(14, 24),
+                // (15,24): warning CS8622: Nullability of reference types in type of parameter 'x' of 'CL0<string> C.M2(CL0<string> x)' doesn't match the target delegate 'C.D1' (possibly because of nullability attributes).
+                //         D1 x2 = new   (M2);
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInParameterTypeOfTargetDelegate, "M2").WithArguments("x", "CL0<string> C.M2(CL0<string> x)", "C.D1").WithLocation(15, 24),
+                // (24,24): warning CS8621: Nullability of reference types in return type of 'CL0<string> C.M3(CL0<string?> x)' doesn't match the target delegate 'C.D2' (possibly because of nullability attributes).
+                //         D2 x1 = new   (M3);
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInReturnTypeOfTargetDelegate, "M3").WithArguments("CL0<string> C.M3(CL0<string?> x)", "C.D2").WithLocation(24, 24),
+                // (25,24): warning CS8622: Nullability of reference types in type of parameter 'x' of 'CL0<string?> C.M4(CL0<string?> x)' doesn't match the target delegate 'C.D2' (possibly because of nullability attributes).
+                //         D2 x2 = new   (M4);
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInParameterTypeOfTargetDelegate, "M4").WithArguments("x", "CL0<string?> C.M4(CL0<string?> x)", "C.D2").WithLocation(25, 24)
+                );
+        }
+
+        /// <summary>
+        /// This is a clone of <see cref="DelegateCreation_04"/>
+        /// </summary>
+        [Fact]
+        public void DelegateCreation_04_TargetTyped()
+        {
+            var source =
+@"delegate object D1();
+delegate object? D2();
+class Program
+{
+    static void F(object x, object? y)
+    {
+        x = null; // 1
+        y = 2;
+        D1 _1 = new (() => x); // 2
+        D2 _2 = new (() => x);
+        D1 _3 = new (() => y);
+        D2 _4 = new (() => y);
+    }
+}";
+            var comp = CreateCompilation(source, options: WithNullableEnable());
+            comp.VerifyDiagnostics(
+                // (7,13): warning CS8600: Converting null literal or possible null value to non-nullable type.
+                //         x = null; // 1
+                Diagnostic(ErrorCode.WRN_ConvertingNullableToNonNullable, "null").WithLocation(7, 13),
+                // (9,28): warning CS8603: Possible null reference return.
+                //         D1 _1 = new (() => x); // 2
+                Diagnostic(ErrorCode.WRN_NullReferenceReturn, "x").WithLocation(9, 28));
+        }
+
+        /// <summary>
+        /// The scenario is cloned from <see cref="DelegateCreation_FromMethodGroup_ReadonlyRefCovariance_01"/>
+        /// </summary>
+        [Fact]
+        public void DelegateCreation_FromMethodGroup_ReadonlyRefCovariance_01_TargetTyped()
+        {
+            var source = @"
+delegate ref readonly T D<T>();
+
+class C
+{
+    void M()
+    {
+        D<string?> d2 = M1;
+        D<string> d = new (d2); // 2
+    }
+
+    ref readonly string M1() => throw null!;
+    ref readonly string? M2() => throw null!;
+}";
+            var comp = CreateNullableCompilation(source);
+            comp.VerifyDiagnostics(
+                // (9,28): warning CS8621: Nullability of reference types in return type of 'ref readonly string? D<string?>.Invoke()' doesn't match the target delegate 'D<string>' (possibly because of nullability attributes).
+                //         D<string> d = new (d2); // 2
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInReturnTypeOfTargetDelegate, "d2").WithArguments("ref readonly string? D<string?>.Invoke()", "D<string>").WithLocation(9, 28)
+                );
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/StructConstructorTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/StructConstructorTests.cs
index 0b959997e1537..6105f5f25dce7 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/StructConstructorTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/StructConstructorTests.cs
@@ -2052,6 +2052,14 @@ static void F4(S4 s = default) { }
     static void G2(S2 s = new()) { }
     static void G3(S3 s = new()) { }
     static void G4(S4 s = new()) { }
+    static void G5(S1? s = new()) { }
+    static void G6(S1? s = new S1()) { }
+    static void G7(decimal s = new(1)) { }
+    static void G8(decimal s = new decimal(1)) { }
+    static void G9(decimal? s = new(1)) { }
+    static void G10(decimal? s = new decimal(1)) { }
+    static void G11(decimal s = (decimal)1) { }
+    static void G12(decimal? s = (decimal)2) { }
 }";
             var comp = CreateCompilation(source);
             comp.VerifyDiagnostics(
@@ -2072,7 +2080,26 @@ static void F4(S4 s = default) { }
                 Diagnostic(ErrorCode.ERR_BadAccess, "new()").WithArguments("S4.S4()").WithLocation(14, 27),
                 // (14,27): error CS1736: Default parameter value for 's' must be a compile-time constant
                 //     static void G4(S4 s = new()) { }
-                Diagnostic(ErrorCode.ERR_DefaultValueMustBeConstant, "new()").WithArguments("s").WithLocation(14, 27));
+                Diagnostic(ErrorCode.ERR_DefaultValueMustBeConstant, "new()").WithArguments("s").WithLocation(14, 27),
+                // (15,24): error CS1770: A value of type 'S1' cannot be used as default parameter for nullable parameter 's' because 'S1' is not a simple type
+                //     static void G5(S1? s = new()) { }
+                Diagnostic(ErrorCode.ERR_NoConversionForNubDefaultParam, "s").WithArguments("S1", "s").WithLocation(15, 24),
+                // (16,24): error CS1770: A value of type 'S1' cannot be used as default parameter for nullable parameter 's' because 'S1' is not a simple type
+                //     static void G6(S1? s = new S1()) { }
+                Diagnostic(ErrorCode.ERR_NoConversionForNubDefaultParam, "s").WithArguments("S1", "s").WithLocation(16, 24),
+                // (17,32): error CS1736: Default parameter value for 's' must be a compile-time constant
+                //     static void G7(decimal s = new(1)) { }
+                Diagnostic(ErrorCode.ERR_DefaultValueMustBeConstant, "new(1)").WithArguments("s").WithLocation(17, 32),
+                // (18,32): error CS1736: Default parameter value for 's' must be a compile-time constant
+                //     static void G8(decimal s = new decimal(1)) { }
+                Diagnostic(ErrorCode.ERR_DefaultValueMustBeConstant, "new decimal(1)").WithArguments("s").WithLocation(18, 32),
+                // (19,33): error CS1736: Default parameter value for 's' must be a compile-time constant
+                //     static void G9(decimal? s = new(1)) { }
+                Diagnostic(ErrorCode.ERR_DefaultValueMustBeConstant, "new(1)").WithArguments("s").WithLocation(19, 33),
+                // (20,34): error CS1736: Default parameter value for 's' must be a compile-time constant
+                //     static void G10(decimal? s = new decimal(1)) { }
+                Diagnostic(ErrorCode.ERR_DefaultValueMustBeConstant, "new decimal(1)").WithArguments("s").WithLocation(20, 34)
+                );
         }
 
         [Fact]
@@ -2112,6 +2139,60 @@ static void F3(S3 s = default) { }
                 Diagnostic(ErrorCode.ERR_DefaultValueMustBeConstant, "new()").WithArguments("s").WithLocation(21, 27));
         }
 
+        [Fact]
+        public void ParameterDefaultValues_03()
+        {
+            var source =
+@"public struct S1 { }
+public class Program
+{
+    public static void G1(S1 s = new()) { }
+    public static void G2(S1 s = new S1()) { }
+}";
+            var comp = CreateCompilation(source);
+            CompileAndVerify(comp, symbolValidator: validate, sourceSymbolValidator: validate).VerifyDiagnostics();
+
+            void validate(ModuleSymbol m)
+            {
+                var g1 = m.GlobalNamespace.GetMember<MethodSymbol>("Program.G1");
+                Assert.True(g1.Parameters[0].HasExplicitDefaultValue);
+                Assert.Null(g1.Parameters[0].ExplicitDefaultValue);
+                Assert.True(g1.Parameters[0].ExplicitDefaultConstantValue.IsNull);
+
+                var g2 = m.GlobalNamespace.GetMember<MethodSymbol>("Program.G2");
+                Assert.True(g2.Parameters[0].HasExplicitDefaultValue);
+                Assert.Null(g2.Parameters[0].ExplicitDefaultValue);
+                Assert.True(g2.Parameters[0].ExplicitDefaultConstantValue.IsNull);
+            }
+        }
+
+        [Fact]
+        public void ParameterDefaultValues_04()
+        {
+            var source =
+@"
+public class Program
+{
+    public static void G1(bool? s = new()) { }
+    public static void G2(bool? s = new bool()) { }
+}";
+            var comp = CreateCompilation(source);
+            CompileAndVerify(comp, symbolValidator: validate, sourceSymbolValidator: validate).VerifyDiagnostics();
+
+            void validate(ModuleSymbol m)
+            {
+                var g1 = m.GlobalNamespace.GetMember<MethodSymbol>("Program.G1");
+                Assert.True(g1.Parameters[0].HasExplicitDefaultValue);
+                Assert.False((bool)g1.Parameters[0].ExplicitDefaultValue);
+                Assert.False(g1.Parameters[0].ExplicitDefaultConstantValue.IsNull);
+
+                var g2 = m.GlobalNamespace.GetMember<MethodSymbol>("Program.G2");
+                Assert.True(g2.Parameters[0].HasExplicitDefaultValue);
+                Assert.False((bool)g2.Parameters[0].ExplicitDefaultValue);
+                Assert.False(g2.Parameters[0].ExplicitDefaultConstantValue.BooleanValue);
+            }
+        }
+
         [Fact]
         public void Constants()
         {
diff --git a/src/Compilers/CSharp/Test/Symbol/Compilation/SemanticModelGetSemanticInfoTests.cs b/src/Compilers/CSharp/Test/Symbol/Compilation/SemanticModelGetSemanticInfoTests.cs
index a844a058a5fc0..86d5cf053e13e 100644
--- a/src/Compilers/CSharp/Test/Symbol/Compilation/SemanticModelGetSemanticInfoTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Compilation/SemanticModelGetSemanticInfoTests.cs
@@ -5015,7 +5015,7 @@ private Class1(int a, long b) { }
             Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind);
             Assert.Equal("Class1", semanticInfo.ConvertedType.ToTestDisplayString());
             Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind);
-            Assert.Equal(ConversionKind.Identity, semanticInfo.ImplicitConversion.Kind);
+            Assert.Equal(ConversionKind.NoConversion, semanticInfo.ImplicitConversion.Kind);
 
             Assert.Null(semanticInfo.Symbol);
             Assert.Equal(CandidateReason.Inaccessible, semanticInfo.CandidateReason);
@@ -12351,7 +12351,7 @@ static void f()
         }
 
         [Fact]
-        public void AbstractClassWithNew()
+        public void AbstractClassWithNew_01()
         {
             string sourceCode = @"
 using System;
@@ -12366,6 +12366,42 @@ static void Main(string[] args)
 
 abstract class X { }
 
+";
+            var semanticInfo = GetSemanticInfoForTest<IdentifierNameSyntax>(sourceCode);
+
+            Assert.Null(semanticInfo.Type);
+            Assert.Null(semanticInfo.ConvertedType);
+            Assert.Equal(ConversionKind.Identity, semanticInfo.ImplicitConversion.Kind);
+
+            Assert.Null(semanticInfo.Symbol);
+            Assert.Equal(CandidateReason.NotCreatable, semanticInfo.CandidateReason);
+            Assert.Equal(1, semanticInfo.CandidateSymbols.Length);
+            var sortedCandidates = semanticInfo.CandidateSymbols.OrderBy(s => s.ToTestDisplayString(), StringComparer.Ordinal).ToArray();
+            Assert.Equal("X", sortedCandidates[0].ToTestDisplayString());
+            Assert.Equal(SymbolKind.NamedType, sortedCandidates[0].Kind);
+
+            Assert.Equal(0, semanticInfo.MemberGroup.Length);
+        }
+
+        [Fact]
+        public void AbstractClassWithNew_02()
+        {
+            string sourceCode = @"
+using System;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        object o = new /*<bind>*/X/*</bind>*/();
+    }
+}
+
+abstract class X
+{
+    public X() {}
+}
+
 ";
             var semanticInfo = GetSemanticInfoForTest<IdentifierNameSyntax>(sourceCode);
 

From aa8077926c9c390d308b87802d8847039d3046f9 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: Tue, 4 Jan 2022 15:52:32 -0800
Subject: [PATCH 224/444] Fix NRE in CompletionListUpdater (#58602)

---
 .../ItemManager.CompletionListUpdater.cs      | 40 +++++++++++++------
 1 file changed, 28 insertions(+), 12 deletions(-)

diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
index 6d1277648dce3..2a22df8398a2e 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/ItemManager.CompletionListUpdater.cs
@@ -86,21 +86,37 @@ public CompletionListUpdater(
                     : _data.Snapshot;
 
                 _document = snapshotForDocument?.TextBuffer.AsTextContainer().GetOpenDocumentInCurrentContext();
-                _completionService = _document?.GetLanguageService<CompletionService>();
-                _completionRules = _completionService?.GetRules(CompletionOptions.From(_document!.Project)) ?? CompletionRules.Default;
+                if (_document != null)
+                {
+                    _completionService = _document.GetLanguageService<CompletionService>();
+                    _completionRules = _completionService?.GetRules(CompletionOptions.From(_document.Project)) ?? CompletionRules.Default;
 
-                // Let us make the completion Helper used for non-Roslyn items case-sensitive.
-                // We can change this if get requests from partner teams.
-                _completionHelper = _document != null ? CompletionHelper.GetHelper(_document) : new CompletionHelper(isCaseSensitive: true);
-                _filterMethod = _completionService == null
-                    ? ((itemsWithPatternMatches, text) => CompletionService.FilterItems(_completionHelper, itemsWithPatternMatches, text))
-                    : ((itemsWithPatternMatches, text) => _completionService.FilterItems(_document!, itemsWithPatternMatches, text));
+                    // Let us make the completion Helper used for non-Roslyn items case-sensitive.
+                    // We can change this if get requests from partner teams.
+                    _completionHelper = CompletionHelper.GetHelper(_document);
+                    _filterMethod = _completionService == null
+                        ? ((itemsWithPatternMatches, text) => CompletionService.FilterItems(_completionHelper, itemsWithPatternMatches, text))
+                        : ((itemsWithPatternMatches, text) => _completionService.FilterItems(_document, itemsWithPatternMatches, text));
 
-                // Nothing to highlight if user hasn't typed anything yet.
-                _highlightMatchingPortions = _filterText.Length > 0
-                    && globalOptions.GetOption(CompletionViewOptions.HighlightMatchingPortionsOfCompletionListItems, _document?.Project.Language);
+                    // Nothing to highlight if user hasn't typed anything yet.
+                    _highlightMatchingPortions = _filterText.Length > 0
+                        && globalOptions.GetOption(CompletionViewOptions.HighlightMatchingPortionsOfCompletionListItems, _document.Project.Language);
 
-                _showCompletionItemFilters = globalOptions.GetOption(CompletionViewOptions.ShowCompletionItemFilters, _document?.Project.Language);
+                    _showCompletionItemFilters = globalOptions.GetOption(CompletionViewOptions.ShowCompletionItemFilters, _document.Project.Language);
+                }
+                else
+                {
+                    _completionService = null;
+                    _completionRules = CompletionRules.Default;
+
+                    // Let us make the completion Helper used for non-Roslyn items case-sensitive.
+                    // We can change this if get requests from partner teams.
+                    _completionHelper = new CompletionHelper(isCaseSensitive: true);
+                    _filterMethod = (itemsWithPatternMatches, text) => CompletionService.FilterItems(_completionHelper, itemsWithPatternMatches, text);
+
+                    _highlightMatchingPortions = false;
+                    _showCompletionItemFilters = true;
+                }
             }
 
             public FilteredCompletionModel? UpdateCompletionList(CancellationToken cancellationToken)

From 00893140c239f876be6201ea06c29a2becbd3325 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: Tue, 4 Jan 2022 16:33:12 -0800
Subject: [PATCH 225/444] Storage options refactoring (#58556)

* Pass StorageOptions to remote service

* Push ClassificationOptions creation higher up in call chain
---
 ...stractFindUsagesService.ProgressAdapter.cs |  6 +++--
 ...bstractFindUsagesService_FindReferences.cs |  4 +++-
 .../IDefinitionsAndReferencesFactory.cs       |  7 ++++--
 .../SemanticClassificationUtilities.cs        | 13 +++++++----
 .../QuickInfo/IntellisenseQuickInfoBuilder.cs |  5 ++++-
 .../References/FindUsagesLSPContext.cs        |  8 +++++--
 .../ClassifiedSpansAndHighlightSpanFactory.cs | 20 ++++++++---------
 .../ValueTracking/ValueTrackedItem.cs         |  5 +++--
 .../SemanticTokens/SemanticTokensHelpers.cs   |  8 ++++---
 ...bstractTableDataSourceFindUsagesContext.cs |  7 +++---
 ...ntainedDocument.DocumentServiceProvider.cs |  7 +++---
 .../ValueTrackingCommandHandler.cs            |  5 +++--
 .../AbstractClassificationService.cs          | 10 +++++----
 .../Classification/ClassifierHelper.cs        |  4 ++--
 .../IRemoteSemanticClassificationService.cs   |  8 ++++++-
 ...teSemanticClassificationService.Caching.cs | 22 +++++++++++--------
 .../RemoteSemanticClassificationService.cs    |  4 +++-
 17 files changed, 91 insertions(+), 52 deletions(-)

diff --git a/src/EditorFeatures/Core/FindUsages/AbstractFindUsagesService.ProgressAdapter.cs b/src/EditorFeatures/Core/FindUsages/AbstractFindUsagesService.ProgressAdapter.cs
index 55bf00bc58dbd..f8ca798184b05 100644
--- a/src/EditorFeatures/Core/FindUsages/AbstractFindUsagesService.ProgressAdapter.cs
+++ b/src/EditorFeatures/Core/FindUsages/AbstractFindUsagesService.ProgressAdapter.cs
@@ -27,21 +27,23 @@ private class FindLiteralsProgressAdapter : IStreamingFindLiteralReferencesProgr
         {
             private readonly IFindUsagesContext _context;
             private readonly DefinitionItem _definition;
+            private readonly ClassificationOptions _classificationOptions;
 
             public IStreamingProgressTracker ProgressTracker
                 => _context.ProgressTracker;
 
             public FindLiteralsProgressAdapter(
-                IFindUsagesContext context, DefinitionItem definition)
+                IFindUsagesContext context, DefinitionItem definition, ClassificationOptions classificationOptions)
             {
                 _context = context;
                 _definition = definition;
+                _classificationOptions = classificationOptions;
             }
 
             public async ValueTask OnReferenceFoundAsync(Document document, TextSpan span, CancellationToken cancellationToken)
             {
                 var documentSpan = await ClassifiedSpansAndHighlightSpanFactory.GetClassifiedDocumentSpanAsync(
-                    document, span, cancellationToken).ConfigureAwait(false);
+                    document, span, _classificationOptions, cancellationToken).ConfigureAwait(false);
                 await _context.OnReferenceFoundAsync(
                     new SourceReferenceItem(_definition, documentSpan, SymbolUsageInfo.None), cancellationToken).ConfigureAwait(false);
             }
diff --git a/src/EditorFeatures/Core/FindUsages/AbstractFindUsagesService_FindReferences.cs b/src/EditorFeatures/Core/FindUsages/AbstractFindUsagesService_FindReferences.cs
index cec274b7cb069..c2d540945713f 100644
--- a/src/EditorFeatures/Core/FindUsages/AbstractFindUsagesService_FindReferences.cs
+++ b/src/EditorFeatures/Core/FindUsages/AbstractFindUsagesService_FindReferences.cs
@@ -7,6 +7,7 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Classification;
 using Microsoft.CodeAnalysis.FindSymbols;
 using Microsoft.CodeAnalysis.FindUsages;
 using Microsoft.CodeAnalysis.LanguageServices;
@@ -224,7 +225,8 @@ private static async Task<bool> TryFindLiteralReferencesAsync(
 
             await context.OnDefinitionFoundAsync(definition, cancellationToken).ConfigureAwait(false);
 
-            var progressAdapter = new FindLiteralsProgressAdapter(context, definition);
+            var classificationOptions = ClassificationOptions.From(document.Project);
+            var progressAdapter = new FindLiteralsProgressAdapter(context, definition, classificationOptions);
 
             // Now call into the underlying FAR engine to find reference.  The FAR
             // engine will push results into the 'progress' instance passed into it.
diff --git a/src/EditorFeatures/Core/FindUsages/IDefinitionsAndReferencesFactory.cs b/src/EditorFeatures/Core/FindUsages/IDefinitionsAndReferencesFactory.cs
index d84848d3af49f..805b7382eb81d 100644
--- a/src/EditorFeatures/Core/FindUsages/IDefinitionsAndReferencesFactory.cs
+++ b/src/EditorFeatures/Core/FindUsages/IDefinitionsAndReferencesFactory.cs
@@ -165,10 +165,12 @@ private static async Task<DefinitionItem> ToDefinitionItemAsync(
                         var document = solution.GetDocument(location.SourceTree);
                         if (document != null)
                         {
+                            var classificationOptions = ClassificationOptions.From(document.Project);
+
                             var documentLocation = !includeClassifiedSpans
                                 ? new DocumentSpan(document, location.SourceSpan)
                                 : await ClassifiedSpansAndHighlightSpanFactory.GetClassifiedDocumentSpanAsync(
-                                    document, location.SourceSpan, cancellationToken).ConfigureAwait(false);
+                                    document, location.SourceSpan, classificationOptions, cancellationToken).ConfigureAwait(false);
 
                             sourceLocations.Add(documentLocation);
                         }
@@ -239,9 +241,10 @@ private static ImmutableDictionary<string, string> GetProperties(ISymbol definit
 
             var document = referenceLocation.Document;
             var sourceSpan = location.SourceSpan;
+            var options = ClassificationOptions.From(document.Project);
 
             var documentSpan = await ClassifiedSpansAndHighlightSpanFactory.GetClassifiedDocumentSpanAsync(
-                document, sourceSpan, cancellationToken).ConfigureAwait(false);
+                document, sourceSpan, options, cancellationToken).ConfigureAwait(false);
 
             return new SourceReferenceItem(definitionItem, documentSpan, referenceLocation.SymbolUsageInfo, referenceLocation.AdditionalProperties);
         }
diff --git a/src/EditorFeatures/Core/Implementation/Classification/SemanticClassificationUtilities.cs b/src/EditorFeatures/Core/Implementation/Classification/SemanticClassificationUtilities.cs
index 6bd34a453593f..5033212ed5266 100644
--- a/src/EditorFeatures/Core/Implementation/Classification/SemanticClassificationUtilities.cs
+++ b/src/EditorFeatures/Core/Implementation/Classification/SemanticClassificationUtilities.cs
@@ -17,6 +17,7 @@
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Storage;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.CodeAnalysis.Text.Shared.Extensions;
 using Microsoft.VisualStudio.Text;
@@ -38,6 +39,8 @@ public static async Task ProduceTagsAsync(
             if (document == null)
                 return;
 
+            var options = ClassificationOptions.From(document.Project);
+
             // Don't block getting classifications on building the full compilation.  This may take a significant amount
             // of time and can cause a very latency sensitive operation (copying) to block the user while we wait on this
             // work to happen.  
@@ -52,7 +55,7 @@ public static async Task ProduceTagsAsync(
             spanToTag = new DocumentSnapshotSpan(document, spanToTag.SnapshotSpan);
 
             var classified = await TryClassifyContainingMemberSpanAsync(
-                    context, spanToTag, classificationService, typeMap, cancellationToken).ConfigureAwait(false);
+                    context, spanToTag, classificationService, typeMap, options, cancellationToken).ConfigureAwait(false);
             if (classified)
             {
                 return;
@@ -61,7 +64,7 @@ public static async Task ProduceTagsAsync(
             // We weren't able to use our specialized codepaths for semantic classifying. 
             // Fall back to classifying the full span that was asked for.
             await ClassifySpansAsync(
-                context, spanToTag, classificationService, typeMap, cancellationToken).ConfigureAwait(false);
+                context, spanToTag, classificationService, typeMap, options, cancellationToken).ConfigureAwait(false);
         }
 
         private static async Task<bool> TryClassifyContainingMemberSpanAsync(
@@ -69,6 +72,7 @@ private static async Task<bool> TryClassifyContainingMemberSpanAsync(
             DocumentSnapshotSpan spanToTag,
             IClassificationService classificationService,
             ClassificationTypeMap typeMap,
+            ClassificationOptions options,
             CancellationToken cancellationToken)
         {
             var range = context.TextChangeRange;
@@ -126,7 +130,7 @@ private static async Task<bool> TryClassifyContainingMemberSpanAsync(
 
             // re-classify only the member we're inside.
             await ClassifySpansAsync(
-                context, subSpanToTag, classificationService, typeMap, cancellationToken).ConfigureAwait(false);
+                context, subSpanToTag, classificationService, typeMap, options, cancellationToken).ConfigureAwait(false);
             return true;
         }
 
@@ -135,6 +139,7 @@ private static async Task ClassifySpansAsync(
             DocumentSnapshotSpan spanToTag,
             IClassificationService classificationService,
             ClassificationTypeMap typeMap,
+            ClassificationOptions options,
             CancellationToken cancellationToken)
         {
             try
@@ -150,7 +155,7 @@ private static async Task ClassifySpansAsync(
                     await classificationService.AddSemanticClassificationsAsync(
                         document,
                         snapshotSpan.Span.ToTextSpan(),
-                        ClassificationOptions.From(document.Project),
+                        options,
                         classifiedSpans,
                         cancellationToken).ConfigureAwait(false);
 
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/IntellisenseQuickInfoBuilder.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/IntellisenseQuickInfoBuilder.cs
index 78740c89f8fb2..28055ba350ec6 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/IntellisenseQuickInfoBuilder.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/IntellisenseQuickInfoBuilder.cs
@@ -15,6 +15,7 @@
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.QuickInfo;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
+using Microsoft.CodeAnalysis.Storage;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Adornments;
 using Microsoft.VisualStudio.Utilities;
@@ -100,11 +101,13 @@ private static async Task<ContainerElement> BuildInteractiveContentAsync(CodeAna
             // build text for RelatedSpan
             if (quickInfoItem.RelatedSpans.Any() && context?.Document is Document document)
             {
+                var classificationOptions = ClassificationOptions.From(document.Project);
+
                 var textRuns = new List<ClassifiedTextRun>();
                 var spanSeparatorNeededBefore = false;
                 foreach (var span in quickInfoItem.RelatedSpans)
                 {
-                    var classifiedSpans = await ClassifierHelper.GetClassifiedSpansAsync(document, span, cancellationToken).ConfigureAwait(false);
+                    var classifiedSpans = await ClassifierHelper.GetClassifiedSpansAsync(document, span, classificationOptions, cancellationToken).ConfigureAwait(false);
 
                     var tabSize = document.Project.Solution.Options.GetOption(FormattingOptions.TabSize, document.Project.Language);
                     var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
diff --git a/src/EditorFeatures/Core/Implementation/LanguageServer/Handlers/References/FindUsagesLSPContext.cs b/src/EditorFeatures/Core/Implementation/LanguageServer/Handlers/References/FindUsagesLSPContext.cs
index af0772543a3ed..59f7a8875cc37 100644
--- a/src/EditorFeatures/Core/Implementation/LanguageServer/Handlers/References/FindUsagesLSPContext.cs
+++ b/src/EditorFeatures/Core/Implementation/LanguageServer/Handlers/References/FindUsagesLSPContext.cs
@@ -281,10 +281,14 @@ public override async ValueTask OnReferenceFoundAsync(SourceReferenceItem refere
                 // General case
                 if (documentSpan != null)
                 {
+                    var document = documentSpan.Value.Document;
+                    var classificationOptions = ClassificationOptions.From(document.Project);
+
                     var classifiedSpansAndHighlightSpan = await ClassifiedSpansAndHighlightSpanFactory.ClassifyAsync(
-                        documentSpan.Value, cancellationToken).ConfigureAwait(false);
+                        documentSpan.Value, classificationOptions, cancellationToken).ConfigureAwait(false);
+
                     var classifiedSpans = classifiedSpansAndHighlightSpan.ClassifiedSpans;
-                    var docText = await documentSpan.Value.Document.GetTextAsync(cancellationToken).ConfigureAwait(false);
+                    var docText = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
                     var classifiedTextRuns = GetClassifiedTextRuns(id, definitionId, documentSpan.Value, isWrittenTo, classifiedSpans, docText);
 
                     return new ClassifiedTextElement(classifiedTextRuns.ToArray());
diff --git a/src/Features/Core/Portable/ClassifiedSpansAndHighlightSpanFactory.cs b/src/Features/Core/Portable/ClassifiedSpansAndHighlightSpanFactory.cs
index 147f49ec2c97e..fa6091bb64689 100644
--- a/src/Features/Core/Portable/ClassifiedSpansAndHighlightSpanFactory.cs
+++ b/src/Features/Core/Portable/ClassifiedSpansAndHighlightSpanFactory.cs
@@ -15,10 +15,10 @@ namespace Microsoft.CodeAnalysis.Classification
     internal static class ClassifiedSpansAndHighlightSpanFactory
     {
         public static async Task<DocumentSpan> GetClassifiedDocumentSpanAsync(
-            Document document, TextSpan sourceSpan, CancellationToken cancellationToken)
+            Document document, TextSpan sourceSpan, ClassificationOptions options, CancellationToken cancellationToken)
         {
             var classifiedSpans = await ClassifyAsync(
-                document, sourceSpan, cancellationToken).ConfigureAwait(false);
+                document, sourceSpan, options, cancellationToken).ConfigureAwait(false);
 
             var properties = ImmutableDictionary<string, object>.Empty.Add(
                 ClassifiedSpansAndHighlightSpan.Key, classifiedSpans);
@@ -27,7 +27,7 @@ public static async Task<DocumentSpan> GetClassifiedDocumentSpanAsync(
         }
 
         public static async Task<ClassifiedSpansAndHighlightSpan> ClassifyAsync(
-            DocumentSpan documentSpan, CancellationToken cancellationToken)
+            DocumentSpan documentSpan, ClassificationOptions options, CancellationToken cancellationToken)
         {
             // If the document span is providing us with the classified spans up front, then we
             // can just use that.  Otherwise, go back and actually classify the text for the line
@@ -39,11 +39,11 @@ public static async Task<ClassifiedSpansAndHighlightSpan> ClassifyAsync(
             }
 
             return await ClassifyAsync(
-                documentSpan.Document, documentSpan.SourceSpan, cancellationToken).ConfigureAwait(false);
+                documentSpan.Document, documentSpan.SourceSpan, options, cancellationToken).ConfigureAwait(false);
         }
 
         private static async Task<ClassifiedSpansAndHighlightSpan> ClassifyAsync(
-            Document document, TextSpan sourceSpan, CancellationToken cancellationToken)
+            Document document, TextSpan sourceSpan, ClassificationOptions options, CancellationToken cancellationToken)
         {
             var sourceText = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
 
@@ -51,7 +51,7 @@ private static async Task<ClassifiedSpansAndHighlightSpan> ClassifyAsync(
             var lineSpan = GetLineSpanForReference(sourceText, narrowSpan);
 
             var taggedLineParts = await GetTaggedTextForDocumentRegionAsync(
-                document, narrowSpan, lineSpan, cancellationToken).ConfigureAwait(false);
+                document, narrowSpan, lineSpan, options, cancellationToken).ConfigureAwait(false);
             return taggedLineParts;
         }
 
@@ -64,22 +64,22 @@ private static TextSpan GetLineSpanForReference(SourceText sourceText, TextSpan
         }
 
         private static async Task<ClassifiedSpansAndHighlightSpan> GetTaggedTextForDocumentRegionAsync(
-            Document document, TextSpan narrowSpan, TextSpan widenedSpan, CancellationToken cancellationToken)
+            Document document, TextSpan narrowSpan, TextSpan widenedSpan, ClassificationOptions options, CancellationToken cancellationToken)
         {
             var highlightSpan = new TextSpan(
                 start: narrowSpan.Start - widenedSpan.Start,
                 length: narrowSpan.Length);
 
             var classifiedSpans = await GetClassifiedSpansAsync(
-                document, narrowSpan, widenedSpan, cancellationToken).ConfigureAwait(false);
+                document, narrowSpan, widenedSpan, options, cancellationToken).ConfigureAwait(false);
             return new ClassifiedSpansAndHighlightSpan(classifiedSpans, highlightSpan);
         }
 
         private static async Task<ImmutableArray<ClassifiedSpan>> GetClassifiedSpansAsync(
-            Document document, TextSpan narrowSpan, TextSpan widenedSpan, CancellationToken cancellationToken)
+            Document document, TextSpan narrowSpan, TextSpan widenedSpan, ClassificationOptions options, CancellationToken cancellationToken)
         {
             var result = await ClassifierHelper.GetClassifiedSpansAsync(
-                document, widenedSpan, cancellationToken).ConfigureAwait(false);
+                document, widenedSpan, options, cancellationToken).ConfigureAwait(false);
             if (!result.IsDefault)
             {
                 return result;
diff --git a/src/Features/Core/Portable/ValueTracking/ValueTrackedItem.cs b/src/Features/Core/Portable/ValueTracking/ValueTrackedItem.cs
index 5d4654fd52358..75ba3b2074b61 100644
--- a/src/Features/Core/Portable/ValueTracking/ValueTrackedItem.cs
+++ b/src/Features/Core/Portable/ValueTracking/ValueTrackedItem.cs
@@ -75,8 +75,9 @@ public override string ToString()
 
             if (sourceText is null)
             {
-                var documentSpan = await ClassifiedSpansAndHighlightSpanFactory.GetClassifiedDocumentSpanAsync(document, textSpan, cancellationToken).ConfigureAwait(false);
-                var classificationResult = await ClassifiedSpansAndHighlightSpanFactory.ClassifyAsync(documentSpan, cancellationToken).ConfigureAwait(false);
+                var options = ClassificationOptions.From(document.Project);
+                var documentSpan = await ClassifiedSpansAndHighlightSpanFactory.GetClassifiedDocumentSpanAsync(document, textSpan, options, cancellationToken).ConfigureAwait(false);
+                var classificationResult = await ClassifiedSpansAndHighlightSpanFactory.ClassifyAsync(documentSpan, options, cancellationToken).ConfigureAwait(false);
                 classifiedSpans = classificationResult.ClassifiedSpans;
                 var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
                 sourceText = await syntaxTree.GetTextAsync(cancellationToken).ConfigureAwait(false);
diff --git a/src/Features/LanguageServer/Protocol/Handler/SemanticTokens/SemanticTokensHelpers.cs b/src/Features/LanguageServer/Protocol/Handler/SemanticTokens/SemanticTokensHelpers.cs
index 7d24e2c02b2c5..b01c001e5307c 100644
--- a/src/Features/LanguageServer/Protocol/Handler/SemanticTokens/SemanticTokensHelpers.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/SemanticTokens/SemanticTokensHelpers.cs
@@ -150,8 +150,10 @@ static SemanticTokensHelpers()
             var isFinalized = document.Project.TryGetCompilation(out var compilation) && compilation == semanticModel.Compilation;
             document = frozenDocument;
 
+            var options = ClassificationOptions.From(document.Project);
+
             var classifiedSpans = await GetClassifiedSpansForDocumentAsync(
-                document, textSpan, includeSyntacticClassifications, cancellationToken).ConfigureAwait(false);
+                document, textSpan, options, includeSyntacticClassifications, cancellationToken).ConfigureAwait(false);
 
             // Multi-line tokens are not supported by VS (tracked by https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1265495).
             // Roslyn's classifier however can return multi-line classified spans, so we must break these up into single-line spans.
@@ -165,6 +167,7 @@ static SemanticTokensHelpers()
         private static async Task<ClassifiedSpan[]> GetClassifiedSpansForDocumentAsync(
             Document document,
             TextSpan textSpan,
+            ClassificationOptions options,
             bool includeSyntacticClassifications,
             CancellationToken cancellationToken)
         {
@@ -186,12 +189,11 @@ private static async Task<ClassifiedSpan[]> GetClassifiedSpansForDocumentAsync(
                 // `fillInClassifiedSpanGaps` includes whitespace in the results, which we don't care about in LSP.
                 // Therefore, we set both optional parameters to false.
                 var spans = await ClassifierHelper.GetClassifiedSpansAsync(
-                    document, textSpan, cancellationToken, removeAdditiveSpans: false, fillInClassifiedSpanGaps: false).ConfigureAwait(false);
+                    document, textSpan, options, cancellationToken, removeAdditiveSpans: false, fillInClassifiedSpanGaps: false).ConfigureAwait(false);
                 classifiedSpans.AddRange(spans);
             }
             else
             {
-                var options = ClassificationOptions.From(document.Project);
                 await classificationService.AddSemanticClassificationsAsync(
                     document, textSpan, options, classifiedSpans, cancellationToken).ConfigureAwait(false);
             }
diff --git a/src/VisualStudio/Core/Def/Implementation/FindReferences/Contexts/AbstractTableDataSourceFindUsagesContext.cs b/src/VisualStudio/Core/Def/Implementation/FindReferences/Contexts/AbstractTableDataSourceFindUsagesContext.cs
index 604fd5fe775cb..6acb93c07d7c4 100644
--- a/src/VisualStudio/Core/Def/Implementation/FindReferences/Contexts/AbstractTableDataSourceFindUsagesContext.cs
+++ b/src/VisualStudio/Core/Def/Implementation/FindReferences/Contexts/AbstractTableDataSourceFindUsagesContext.cs
@@ -345,8 +345,9 @@ public sealed override ValueTask OnDefinitionFoundAsync(DefinitionItem definitio
                 CancellationToken cancellationToken)
             {
                 var document = documentSpan.Document;
+                var options = ClassificationOptions.From(document.Project);
                 var sourceText = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
-                var (excerptResult, lineText) = await ExcerptAsync(sourceText, documentSpan, cancellationToken).ConfigureAwait(false);
+                var (excerptResult, lineText) = await ExcerptAsync(sourceText, documentSpan, options, cancellationToken).ConfigureAwait(false);
 
                 var mappedDocumentSpan = await AbstractDocumentSpanEntry.TryMapAndGetFirstAsync(documentSpan, sourceText, cancellationToken).ConfigureAwait(false);
                 if (mappedDocumentSpan == null)
@@ -374,7 +375,7 @@ public sealed override ValueTask OnDefinitionFoundAsync(DefinitionItem definitio
             }
 
             private async Task<(ExcerptResult, SourceText)> ExcerptAsync(
-                SourceText sourceText, DocumentSpan documentSpan, CancellationToken cancellationToken)
+                SourceText sourceText, DocumentSpan documentSpan, ClassificationOptions options, CancellationToken cancellationToken)
             {
                 var excerptService = documentSpan.Document.Services.GetService<IDocumentExcerptService>();
                 if (excerptService != null)
@@ -386,7 +387,7 @@ public sealed override ValueTask OnDefinitionFoundAsync(DefinitionItem definitio
                     }
                 }
 
-                var classificationResult = await ClassifiedSpansAndHighlightSpanFactory.ClassifyAsync(documentSpan, cancellationToken).ConfigureAwait(false);
+                var classificationResult = await ClassifiedSpansAndHighlightSpanFactory.ClassifyAsync(documentSpan, options, cancellationToken).ConfigureAwait(false);
 
                 // need to fix the span issue tracking here - https://github.com/dotnet/roslyn/issues/31001
                 var excerptResult = new ExcerptResult(
diff --git a/src/VisualStudio/Core/Def/Implementation/Venus/ContainedDocument.DocumentServiceProvider.cs b/src/VisualStudio/Core/Def/Implementation/Venus/ContainedDocument.DocumentServiceProvider.cs
index c1d94a3319048..ec2af8bb6c4b3 100644
--- a/src/VisualStudio/Core/Def/Implementation/Venus/ContainedDocument.DocumentServiceProvider.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Venus/ContainedDocument.DocumentServiceProvider.cs
@@ -165,14 +165,15 @@ public DocumentExcerpter(ITextBuffer primaryBuffer)
                         return null;
                     }
 
-                    var classifiedSpansOnContent = await GetClassifiedSpansOnContentAsync(document, roslynSnapshot, contentSpanOnPrimarySnapshot.Value, cancellationToken).ConfigureAwait(false);
+                    var options = ClassificationOptions.From(document.Project);
+                    var classifiedSpansOnContent = await GetClassifiedSpansOnContentAsync(document, roslynSnapshot, contentSpanOnPrimarySnapshot.Value, options, cancellationToken).ConfigureAwait(false);
 
                     // the default implementation has no idea how to classify the primary snapshot
                     return new ExcerptResult(content, spanOnContent, classifiedSpansOnContent, document, span);
                 }
 
                 private static async Task<ImmutableArray<ClassifiedSpan>> GetClassifiedSpansOnContentAsync(
-                    Document document, ITextSnapshot roslynSnapshot, SnapshotSpan contentSpanOnPrimarySnapshot, CancellationToken cancellationToken)
+                    Document document, ITextSnapshot roslynSnapshot, SnapshotSpan contentSpanOnPrimarySnapshot, ClassificationOptions options, CancellationToken cancellationToken)
                 {
                     var primarySnapshot = (IProjectionSnapshot)contentSpanOnPrimarySnapshot.Snapshot;
 
@@ -197,7 +198,7 @@ private static async Task<ImmutableArray<ClassifiedSpan>> GetClassifiedSpansOnCo
                         // we don't have guarantee that pirmary snapshot is from same snapshot as roslyn snapshot. make sure
                         // we map it to right snapshot
                         var fixedUpSpan = roslynSpan.TranslateTo(roslynSnapshot, SpanTrackingMode.EdgeExclusive);
-                        var classifiedSpans = await ClassifierHelper.GetClassifiedSpansAsync(document, fixedUpSpan.Span.ToTextSpan(), cancellationToken).ConfigureAwait(false);
+                        var classifiedSpans = await ClassifierHelper.GetClassifiedSpansAsync(document, fixedUpSpan.Span.ToTextSpan(), options, cancellationToken).ConfigureAwait(false);
                         if (classifiedSpans.IsDefault)
                         {
                             continue;
diff --git a/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingCommandHandler.cs b/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingCommandHandler.cs
index 15c73b4ccb77f..d50811de2e1b9 100644
--- a/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingCommandHandler.cs
+++ b/src/VisualStudio/Core/Def/ValueTracking/ValueTrackingCommandHandler.cs
@@ -156,10 +156,11 @@ private async Task ShowToolWindowAsync(ITextView textView, ISymbol selectedSymbo
 
             RoslynDebug.AssertNotNull(location.SourceTree);
             var document = solution.GetRequiredDocument(location.SourceTree);
+            var options = ClassificationOptions.From(document.Project);
 
             var sourceText = await location.SourceTree.GetTextAsync(cancellationToken).ConfigureAwait(false);
-            var documentSpan = await ClassifiedSpansAndHighlightSpanFactory.GetClassifiedDocumentSpanAsync(document, location.SourceSpan, cancellationToken).ConfigureAwait(false);
-            var classificationResult = await ClassifiedSpansAndHighlightSpanFactory.ClassifyAsync(documentSpan, cancellationToken).ConfigureAwait(false);
+            var documentSpan = await ClassifiedSpansAndHighlightSpanFactory.GetClassifiedDocumentSpanAsync(document, location.SourceSpan, options, cancellationToken).ConfigureAwait(false);
+            var classificationResult = await ClassifiedSpansAndHighlightSpanFactory.ClassifyAsync(documentSpan, options, cancellationToken).ConfigureAwait(false);
 
             var root = new TreeItemViewModel(
                 location.SourceSpan,
diff --git a/src/Workspaces/Core/Portable/Classification/AbstractClassificationService.cs b/src/Workspaces/Core/Portable/Classification/AbstractClassificationService.cs
index 28ade4ec636e7..723be90a8468f 100644
--- a/src/Workspaces/Core/Portable/Classification/AbstractClassificationService.cs
+++ b/src/Workspaces/Core/Portable/Classification/AbstractClassificationService.cs
@@ -8,6 +8,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Extensions;
 using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.ReassignedVariable;
 using Microsoft.CodeAnalysis.Remote;
@@ -45,6 +46,8 @@ public async Task AddSemanticClassificationsAsync(Document document, TextSpan te
                 return;
             }
 
+            var database = document.Project.Solution.Options.GetPersistentStorageDatabase();
+
             var client = await RemoteHostClient.TryGetClientAsync(document.Project, cancellationToken).ConfigureAwait(false);
             if (client != null)
             {
@@ -53,14 +56,14 @@ public async Task AddSemanticClassificationsAsync(Document document, TextSpan te
                 // service.GetSemanticClassificationsAsync below) as we want to try to read in the cached
                 // classifications without doing any syncing to the OOP process.
                 var isFullyLoaded = IsFullyLoaded(document, cancellationToken);
-                if (await TryGetCachedClassificationsAsync(document, textSpan, result, client, isFullyLoaded, cancellationToken).ConfigureAwait(false))
+                if (await TryGetCachedClassificationsAsync(document, textSpan, result, client, database, isFullyLoaded, cancellationToken).ConfigureAwait(false))
                     return;
 
                 // Call the project overload.  Semantic classification only needs the current project's information
                 // to classify properly.
                 var classifiedSpans = await client.TryInvokeAsync<IRemoteSemanticClassificationService, SerializableClassifiedSpans>(
                    document.Project,
-                   (service, solutionInfo, cancellationToken) => service.GetSemanticClassificationsAsync(solutionInfo, document.Id, textSpan, options, isFullyLoaded, cancellationToken),
+                   (service, solutionInfo, cancellationToken) => service.GetSemanticClassificationsAsync(solutionInfo, document.Id, textSpan, options, database, isFullyLoaded, cancellationToken),
                    cancellationToken).ConfigureAwait(false);
 
                 // if the remote call fails do nothing (error has already been reported)
@@ -90,7 +93,7 @@ private static bool IsFullyLoaded(Document document, CancellationToken cancellat
 
         private static async Task<bool> TryGetCachedClassificationsAsync(
             Document document, TextSpan textSpan, ArrayBuilder<ClassifiedSpan> result,
-            RemoteHostClient client, bool isFullyLoaded, CancellationToken cancellationToken)
+            RemoteHostClient client, StorageDatabase database, bool isFullyLoaded, CancellationToken cancellationToken)
         {
             // Only try to get cached classifications if we're not fully loaded yet.
             if (isFullyLoaded)
@@ -98,7 +101,6 @@ private static async Task<bool> TryGetCachedClassificationsAsync(
 
             var (documentKey, checksum) = await SemanticClassificationCacheUtilities.GetDocumentKeyAndChecksumAsync(
                 document, cancellationToken).ConfigureAwait(false);
-            var database = document.Project.Solution.Options.GetPersistentStorageDatabase();
 
             var cachedSpans = await client.TryInvokeAsync<IRemoteSemanticClassificationService, SerializableClassifiedSpans?>(
                document.Project,
diff --git a/src/Workspaces/Core/Portable/Classification/ClassifierHelper.cs b/src/Workspaces/Core/Portable/Classification/ClassifierHelper.cs
index 8c2b3354b4eba..abf88045f74e1 100644
--- a/src/Workspaces/Core/Portable/Classification/ClassifierHelper.cs
+++ b/src/Workspaces/Core/Portable/Classification/ClassifierHelper.cs
@@ -8,6 +8,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Storage;
 using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.CodeAnalysis.Classification
@@ -23,6 +24,7 @@ internal static class ClassifierHelper
         public static async Task<ImmutableArray<ClassifiedSpan>> GetClassifiedSpansAsync(
             Document document,
             TextSpan span,
+            ClassificationOptions options,
             CancellationToken cancellationToken,
             bool removeAdditiveSpans = true,
             bool fillInClassifiedSpanGaps = true)
@@ -33,8 +35,6 @@ public static async Task<ImmutableArray<ClassifiedSpan>> GetClassifiedSpansAsync
                 return default;
             }
 
-            var options = ClassificationOptions.From(document.Project);
-
             // Call out to the individual language to classify the chunk of text around the
             // reference. We'll get both the syntactic and semantic spans for this region.
             // Because the semantic tags may override the semantic ones (for example, 
diff --git a/src/Workspaces/Core/Portable/Classification/IRemoteSemanticClassificationService.cs b/src/Workspaces/Core/Portable/Classification/IRemoteSemanticClassificationService.cs
index 7e259c5846709..30647d6e0eddd 100644
--- a/src/Workspaces/Core/Portable/Classification/IRemoteSemanticClassificationService.cs
+++ b/src/Workspaces/Core/Portable/Classification/IRemoteSemanticClassificationService.cs
@@ -19,7 +19,13 @@ namespace Microsoft.CodeAnalysis.Classification
     internal interface IRemoteSemanticClassificationService
     {
         ValueTask<SerializableClassifiedSpans> GetSemanticClassificationsAsync(
-            PinnedSolutionInfo solutionInfo, DocumentId documentId, TextSpan span, ClassificationOptions options, bool isFullyLoaded, CancellationToken cancellationToken);
+            PinnedSolutionInfo solutionInfo,
+            DocumentId documentId,
+            TextSpan span,
+            ClassificationOptions options,
+            StorageDatabase database,
+            bool isFullyLoaded,
+            CancellationToken cancellationToken);
 
         /// <summary>
         /// Tries to get cached semantic classifications for the specified document and the specified <paramref
diff --git a/src/Workspaces/Remote/ServiceHub/Services/SemanticClassification/RemoteSemanticClassificationService.Caching.cs b/src/Workspaces/Remote/ServiceHub/Services/SemanticClassification/RemoteSemanticClassificationService.Caching.cs
index 19d06e10d79b0..c27597453dc1c 100644
--- a/src/Workspaces/Remote/ServiceHub/Services/SemanticClassification/RemoteSemanticClassificationService.Caching.cs
+++ b/src/Workspaces/Remote/ServiceHub/Services/SemanticClassification/RemoteSemanticClassificationService.Caching.cs
@@ -51,16 +51,16 @@ internal sealed partial class RemoteSemanticClassificationService : BrokeredServ
         /// same document may appear multiple times inside of this queue (for different versions of the document).
         /// However, we'll only process the last version of any document added.
         /// </summary>
-        private readonly AsyncBatchingWorkQueue<Document> _workQueue;
+        private readonly AsyncBatchingWorkQueue<(Document, ClassificationOptions, StorageDatabase)> _workQueue;
         private readonly CancellationTokenSource _cancellationTokenSource = new();
 
         public RemoteSemanticClassificationService(in ServiceConstructionArguments arguments)
             : base(arguments)
         {
-            _workQueue = new AsyncBatchingWorkQueue<Document>(
+            _workQueue = new AsyncBatchingWorkQueue<(Document, ClassificationOptions, StorageDatabase)>(
                 TimeSpan.FromMilliseconds(TaggerConstants.ShortDelay),
                 CacheSemanticClassificationsAsync,
-                EqualityComparer<Document>.Default,
+                EqualityComparer<(Document, ClassificationOptions, StorageDatabase)>.Default,
                 AsynchronousOperationListenerProvider.NullListener,
                 _cancellationTokenSource.Token);
         }
@@ -82,20 +82,25 @@ public override void Dispose()
         }
 
         private static async ValueTask CacheSemanticClassificationsAsync(
-            ImmutableArray<Document> documents, CancellationToken cancellationToken)
+            ImmutableArray<(Document document, ClassificationOptions options, StorageDatabase database)> documents, CancellationToken cancellationToken)
         {
             // Group all the requests by document (as we may have gotten many requests for the same document). Then,
             // only process the last document from each group (we don't need to bother stale versions of a particular
             // document).
-            var groups = documents.GroupBy(d => d.Id);
-            var tasks = groups.Select(g => Task.Run(() => CacheSemanticClassificationsAsync(g.Last(), cancellationToken), cancellationToken));
+            var groups = documents.GroupBy(d => d.document.Id);
+            var tasks = groups.Select(g => Task.Run(() =>
+            {
+                var (document, options, database) = g.Last();
+                return CacheSemanticClassificationsAsync(document, options, database, cancellationToken);
+            }, cancellationToken));
+
             await Task.WhenAll(tasks).ConfigureAwait(false);
         }
 
-        private static async Task CacheSemanticClassificationsAsync(Document document, CancellationToken cancellationToken)
+        private static async Task CacheSemanticClassificationsAsync(Document document, ClassificationOptions options, StorageDatabase database, CancellationToken cancellationToken)
         {
             var solution = document.Project.Solution;
-            var persistenceService = solution.Workspace.Services.GetPersistentStorageService(solution.Options);
+            var persistenceService = solution.Workspace.Services.GetPersistentStorageService(database);
             var storage = await persistenceService.GetStorageAsync(SolutionKey.ToSolutionKey(solution), cancellationToken).ConfigureAwait(false);
             await using var _1 = storage.ConfigureAwait(false);
             if (storage == null)
@@ -119,7 +124,6 @@ private static async Task CacheSemanticClassificationsAsync(Document document, C
 
             // Compute classifications for the full span.
             var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
-            var options = ClassificationOptions.From(document.Project);
             await classificationService.AddSemanticClassificationsAsync(document, new TextSpan(0, text.Length), options, classifiedSpans, cancellationToken).ConfigureAwait(false);
 
             using var stream = SerializableBytes.CreateWritableStream();
diff --git a/src/Workspaces/Remote/ServiceHub/Services/SemanticClassification/RemoteSemanticClassificationService.cs b/src/Workspaces/Remote/ServiceHub/Services/SemanticClassification/RemoteSemanticClassificationService.cs
index cd77d44cbb2df..4d08ac6ca22fa 100644
--- a/src/Workspaces/Remote/ServiceHub/Services/SemanticClassification/RemoteSemanticClassificationService.cs
+++ b/src/Workspaces/Remote/ServiceHub/Services/SemanticClassification/RemoteSemanticClassificationService.cs
@@ -6,6 +6,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Classification;
 using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Storage;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
@@ -24,6 +25,7 @@ public ValueTask<SerializableClassifiedSpans> GetSemanticClassificationsAsync(
             DocumentId documentId,
             TextSpan span,
             ClassificationOptions options,
+            StorageDatabase database,
             bool isFullyLoaded,
             CancellationToken cancellationToken)
         {
@@ -45,7 +47,7 @@ await AbstractClassificationService.AddSemanticClassificationsInCurrentProcessAs
                         _cachedData.Clear();
 
                     // Enqueue this document into our work queue to fully classify and cache.
-                    _workQueue.AddWork(document);
+                    _workQueue.AddWork((document, options, database));
                 }
 
                 return SerializableClassifiedSpans.Dehydrate(temp.ToImmutable());

From 7cb8d74294471854b120c059daea1da8a2882c0d 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: Tue, 4 Jan 2022 16:34:33 -0800
Subject: [PATCH 226/444] Inline hints options refactoring (#58552)

---
 .../InlineHintsDataTaggerProvider.cs          |  4 +-
 .../InlineHints/AbstractInlineHintsTests.vb   | 33 ++++++---
 .../InlineHints/AbstractInlineHintsService.cs |  7 +-
 ...AbstractInlineParameterNameHintsService.cs |  4 +-
 .../AbstractInlineTypeHintsService.cs         |  4 +-
 .../InlineHints/IInlineHintsService.cs        |  5 +-
 .../IInlineParameterNameHintsService.cs       |  3 +-
 .../InlineHints/IInlineTypeHintsService.cs    |  3 +-
 .../InlineHints/InlineHintsOptions.cs         | 24 +++++++
 .../InlineParameterHintsOptions.cs            | 63 +---------------
 .../InlineHints/InlineTypeHintsOptions.cs     | 72 +++++++++++++++++++
 .../InlineHints/FSharpInlineHintsService.cs   |  2 +-
 .../OmniSharpInlineHintsService.cs            |  4 +-
 13 files changed, 140 insertions(+), 88 deletions(-)
 create mode 100644 src/Features/Core/Portable/InlineHints/InlineHintsOptions.cs
 create mode 100644 src/Features/Core/Portable/InlineHints/InlineTypeHintsOptions.cs

diff --git a/src/EditorFeatures/Core/InlineHints/InlineHintsDataTaggerProvider.cs b/src/EditorFeatures/Core/InlineHints/InlineHintsDataTaggerProvider.cs
index 88fde964d8ac5..e812f239b9a99 100644
--- a/src/EditorFeatures/Core/InlineHints/InlineHintsDataTaggerProvider.cs
+++ b/src/EditorFeatures/Core/InlineHints/InlineHintsDataTaggerProvider.cs
@@ -107,8 +107,10 @@ protected override async Task ProduceTagsAsync(
             if (service == null)
                 return;
 
+            var options = InlineHintsOptions.From(document.Project);
+
             var snapshotSpan = documentSnapshotSpan.SnapshotSpan;
-            var hints = await service.GetInlineHintsAsync(document, snapshotSpan.Span.ToTextSpan(), cancellationToken).ConfigureAwait(false);
+            var hints = await service.GetInlineHintsAsync(document, snapshotSpan.Span.ToTextSpan(), options, cancellationToken).ConfigureAwait(false);
             foreach (var hint in hints)
             {
                 // If we don't have any text to actually show the user, then don't make a tag.
diff --git a/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb b/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb
index c1765e4e792c7..03567de4486f8 100644
--- a/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb
+++ b/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb
@@ -6,6 +6,7 @@ Imports System.Threading
 Imports Microsoft.CodeAnalysis.Editor.InlineHints
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
 Imports Microsoft.CodeAnalysis.InlineHints
+Imports Microsoft.CodeAnalysis.LanguageServices
 Imports Microsoft.CodeAnalysis.Options
 
 Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
@@ -15,16 +16,23 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
             Using workspace = TestWorkspace.Create(test)
                 WpfTestRunner.RequireWpfFact($"{NameOf(AbstractInlineHintsTests)}.{NameOf(Me.VerifyParamHints)} creates asynchronous taggers")
 
-                workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options.WithChangedOption(
-                    InlineParameterHintsOptions.Metadata.EnabledForParameters,
-                    workspace.CurrentSolution.Projects().First().Language,
-                    optionIsEnabled)))
+                Dim options = New InlineParameterHintsOptions(
+                    EnabledForParameters:=optionIsEnabled,
+                    ForLiteralParameters:=True,
+                    ForIndexerParameters:=True,
+                    ForObjectCreationParameters:=True,
+                    ForOtherParameters:=False,
+                    SuppressForParametersThatDifferOnlyBySuffix:=True,
+                    SuppressForParametersThatMatchMethodIntent:=True,
+                    SuppressForParametersThatMatchArgumentName:=True)
+
+                Dim displayOptions = New SymbolDescriptionOptions()
 
                 Dim hostDocument = workspace.Documents.Single()
                 Dim snapshot = hostDocument.GetTextBuffer().CurrentSnapshot
                 Dim document = workspace.CurrentSolution.GetDocument(hostDocument.Id)
                 Dim tagService = document.GetRequiredLanguageService(Of IInlineParameterNameHintsService)
-                Dim inlineHints = Await tagService.GetInlineHintsAsync(document, New Text.TextSpan(0, snapshot.Length), New CancellationToken())
+                Dim inlineHints = Await tagService.GetInlineHintsAsync(document, New Text.TextSpan(0, snapshot.Length), options, displayOptions, CancellationToken.None)
 
                 Dim producedTags = From hint In inlineHints
                                    Select hint.DisplayParts.GetFullText().TrimEnd() + hint.Span.ToString
@@ -50,20 +58,23 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
         Protected Async Function VerifyTypeHints(test As XElement, Optional optionIsEnabled As Boolean = True, Optional ephemeral As Boolean = False) As Task
             Using workspace = TestWorkspace.Create(test)
                 WpfTestRunner.RequireWpfFact($"{NameOf(AbstractInlineHintsTests)}.{NameOf(Me.VerifyTypeHints)} creates asynchronous taggers")
-                Dim globalOptions = workspace.GetService(Of IGlobalOptionService)
 
-                Dim language = workspace.CurrentSolution.Projects().First().Language
+                Dim globalOptions = workspace.GetService(Of IGlobalOptionService)
+                globalOptions.SetGlobalOption(New OptionKey(InlineHintsGlobalStateOption.DisplayAllOverride), ephemeral)
 
-                workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(
-                    workspace.CurrentSolution.Options.WithChangedOption(InlineTypeHintsOptions.Metadata.EnabledForTypes, language, optionIsEnabled AndAlso Not ephemeral)))
+                Dim options = New InlineTypeHintsOptions(
+                    EnabledForTypes:=optionIsEnabled AndAlso Not ephemeral,
+                    ForImplicitVariableTypes:=True,
+                    ForLambdaParameterTypes:=True,
+                    ForImplicitObjectCreation:=True)
 
-                globalOptions.SetGlobalOption(New OptionKey(InlineHintsGlobalStateOption.DisplayAllOverride), ephemeral)
+                Dim displayOptions = New SymbolDescriptionOptions()
 
                 Dim hostDocument = workspace.Documents.Single()
                 Dim snapshot = hostDocument.GetTextBuffer().CurrentSnapshot
                 Dim document = workspace.CurrentSolution.GetDocument(hostDocument.Id)
                 Dim tagService = document.GetRequiredLanguageService(Of IInlineTypeHintsService)
-                Dim typeHints = Await tagService.GetInlineHintsAsync(document, New Text.TextSpan(0, snapshot.Length), New CancellationToken())
+                Dim typeHints = Await tagService.GetInlineHintsAsync(document, New Text.TextSpan(0, snapshot.Length), options, displayOptions, CancellationToken.None)
 
                 Dim producedTags = From hint In typeHints
                                    Select hint.DisplayParts.GetFullText() + ":" + hint.Span.ToString()
diff --git a/src/Features/Core/Portable/InlineHints/AbstractInlineHintsService.cs b/src/Features/Core/Portable/InlineHints/AbstractInlineHintsService.cs
index ae8ecbaff3699..010899b408704 100644
--- a/src/Features/Core/Portable/InlineHints/AbstractInlineHintsService.cs
+++ b/src/Features/Core/Portable/InlineHints/AbstractInlineHintsService.cs
@@ -6,6 +6,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 
@@ -14,18 +15,18 @@ namespace Microsoft.CodeAnalysis.InlineHints
     internal abstract class AbstractInlineHintsService : IInlineHintsService
     {
         public async Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(
-            Document document, TextSpan textSpan, CancellationToken cancellationToken)
+            Document document, TextSpan textSpan, InlineHintsOptions options, CancellationToken cancellationToken)
         {
             var inlineParameterService = document.GetLanguageService<IInlineParameterNameHintsService>();
             var inlineTypeService = document.GetLanguageService<IInlineTypeHintsService>();
 
             var parameters = inlineParameterService == null
                 ? ImmutableArray<InlineHint>.Empty
-                : await inlineParameterService.GetInlineHintsAsync(document, textSpan, cancellationToken).ConfigureAwait(false);
+                : await inlineParameterService.GetInlineHintsAsync(document, textSpan, options.ParameterOptions, options.DisplayOptions, cancellationToken).ConfigureAwait(false);
 
             var types = inlineTypeService == null
                 ? ImmutableArray<InlineHint>.Empty
-                : await inlineTypeService.GetInlineHintsAsync(document, textSpan, cancellationToken).ConfigureAwait(false);
+                : await inlineTypeService.GetInlineHintsAsync(document, textSpan, options.TypeOptions, options.DisplayOptions, cancellationToken).ConfigureAwait(false);
 
             return parameters.Concat(types);
         }
diff --git a/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs b/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
index 521ed98ac7763..93ffdf9e57ad7 100644
--- a/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
+++ b/src/Features/Core/Portable/InlineHints/AbstractInlineParameterNameHintsService.cs
@@ -41,10 +41,8 @@ protected abstract void AddAllParameterNameHintLocations(
 
         protected abstract bool IsIndexer(SyntaxNode node, IParameterSymbol parameter);
 
-        public async Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(Document document, TextSpan textSpan, CancellationToken cancellationToken)
+        public async Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(Document document, TextSpan textSpan, InlineParameterHintsOptions options, SymbolDescriptionOptions displayOptions, CancellationToken cancellationToken)
         {
-            var options = InlineParameterHintsOptions.From(document.Project);
-            var displayOptions = SymbolDescriptionOptions.From(document.Project);
             var displayAllOverride = _globalOptions.GetOption(InlineHintsGlobalStateOption.DisplayAllOverride);
 
             var enabledForParameters = displayAllOverride || options.EnabledForParameters;
diff --git a/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs b/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
index ca8e1b990878d..ab2cebb0dc4f9 100644
--- a/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
+++ b/src/Features/Core/Portable/InlineHints/AbstractInlineTypeHintsService.cs
@@ -38,10 +38,8 @@ public AbstractInlineTypeHintsService(IGlobalOptionService globalOptions)
             CancellationToken cancellationToken);
 
         public async Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(
-            Document document, TextSpan textSpan, CancellationToken cancellationToken)
+            Document document, TextSpan textSpan, InlineTypeHintsOptions options, SymbolDescriptionOptions displayOptions, CancellationToken cancellationToken)
         {
-            var options = InlineTypeHintsOptions.From(document.Project);
-            var displayOptions = SymbolDescriptionOptions.From(document.Project);
             var displayAllOverride = _globalOptions.GetOption(InlineHintsGlobalStateOption.DisplayAllOverride);
 
             var enabledForTypes = options.EnabledForTypes;
diff --git a/src/Features/Core/Portable/InlineHints/IInlineHintsService.cs b/src/Features/Core/Portable/InlineHints/IInlineHintsService.cs
index 4952e0d0e0c4f..a2e2e3412f803 100644
--- a/src/Features/Core/Portable/InlineHints/IInlineHintsService.cs
+++ b/src/Features/Core/Portable/InlineHints/IInlineHintsService.cs
@@ -6,13 +6,14 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
-using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.LanguageServices;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.CodeAnalysis.InlineHints
 {
     internal interface IInlineHintsService : ILanguageService
     {
-        Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(Document document, TextSpan textSpan, CancellationToken cancellationToken);
+        Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(Document document, TextSpan textSpan, InlineHintsOptions options, CancellationToken cancellationToken);
     }
 }
diff --git a/src/Features/Core/Portable/InlineHints/IInlineParameterNameHintsService.cs b/src/Features/Core/Portable/InlineHints/IInlineParameterNameHintsService.cs
index 63cb8906d01f3..d79821085aeb8 100644
--- a/src/Features/Core/Portable/InlineHints/IInlineParameterNameHintsService.cs
+++ b/src/Features/Core/Portable/InlineHints/IInlineParameterNameHintsService.cs
@@ -6,6 +6,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.CodeAnalysis.InlineHints
@@ -16,6 +17,6 @@ namespace Microsoft.CodeAnalysis.InlineHints
     /// </summary>
     internal interface IInlineParameterNameHintsService : ILanguageService
     {
-        Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(Document document, TextSpan textSpan, CancellationToken cancellationToken);
+        Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(Document document, TextSpan textSpan, InlineParameterHintsOptions options, SymbolDescriptionOptions displayOptions, CancellationToken cancellationToken);
     }
 }
diff --git a/src/Features/Core/Portable/InlineHints/IInlineTypeHintsService.cs b/src/Features/Core/Portable/InlineHints/IInlineTypeHintsService.cs
index 87f6b64be5f13..2227402a1a8d0 100644
--- a/src/Features/Core/Portable/InlineHints/IInlineTypeHintsService.cs
+++ b/src/Features/Core/Portable/InlineHints/IInlineTypeHintsService.cs
@@ -6,6 +6,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.CodeAnalysis.InlineHints
@@ -16,6 +17,6 @@ namespace Microsoft.CodeAnalysis.InlineHints
     /// </summary>
     internal interface IInlineTypeHintsService : ILanguageService
     {
-        Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(Document document, TextSpan textSpan, CancellationToken cancellationToken);
+        Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(Document document, TextSpan textSpan, InlineTypeHintsOptions options, SymbolDescriptionOptions displayOptions, CancellationToken cancellationToken);
     }
 }
diff --git a/src/Features/Core/Portable/InlineHints/InlineHintsOptions.cs b/src/Features/Core/Portable/InlineHints/InlineHintsOptions.cs
new file mode 100644
index 0000000000000..a2a2396a324d0
--- /dev/null
+++ b/src/Features/Core/Portable/InlineHints/InlineHintsOptions.cs
@@ -0,0 +1,24 @@
+// 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.LanguageServices;
+using Microsoft.CodeAnalysis.Options;
+
+namespace Microsoft.CodeAnalysis.InlineHints
+{
+    internal readonly record struct InlineHintsOptions(
+        InlineParameterHintsOptions ParameterOptions,
+        InlineTypeHintsOptions TypeOptions,
+        SymbolDescriptionOptions DisplayOptions)
+    {
+        public static InlineHintsOptions From(Project project)
+            => From(project.Solution.Options, project.Language);
+
+        public static InlineHintsOptions From(OptionSet options, string language)
+            => new(
+                ParameterOptions: InlineParameterHintsOptions.From(options, language),
+                TypeOptions: InlineTypeHintsOptions.From(options, language),
+                DisplayOptions: SymbolDescriptionOptions.From(options, language));
+    }
+}
diff --git a/src/Features/Core/Portable/InlineHints/InlineParameterHintsOptions.cs b/src/Features/Core/Portable/InlineHints/InlineParameterHintsOptions.cs
index 5d3730ff573a7..5eec066d24f12 100644
--- a/src/Features/Core/Portable/InlineHints/InlineParameterHintsOptions.cs
+++ b/src/Features/Core/Portable/InlineHints/InlineParameterHintsOptions.cs
@@ -11,7 +11,7 @@
 
 namespace Microsoft.CodeAnalysis.InlineHints
 {
-    internal record struct InlineParameterHintsOptions(
+    internal readonly record struct InlineParameterHintsOptions(
         bool EnabledForParameters,
         bool ForLiteralParameters,
         bool ForIndexerParameters,
@@ -25,7 +25,7 @@ public static InlineParameterHintsOptions From(Project project)
             => From(project.Solution.Options, project.Language);
 
         public static InlineParameterHintsOptions From(OptionSet options, string language)
-          => new(
+            => new(
                 EnabledForParameters: options.GetOption(Metadata.EnabledForParameters, language),
                 ForLiteralParameters: options.GetOption(Metadata.ForLiteralParameters, language),
                 ForIndexerParameters: options.GetOption(Metadata.ForIndexerParameters, language),
@@ -105,63 +105,4 @@ public Metadata()
                     storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.InlineParameterNameHints.SuppressForParametersThatMatchArgumentName"));
         }
     }
-
-    internal record struct InlineTypeHintsOptions(
-        bool EnabledForTypes,
-        bool ForImplicitVariableTypes,
-        bool ForLambdaParameterTypes,
-        bool ForImplicitObjectCreation)
-    {
-        public static InlineTypeHintsOptions From(Project project)
-            => From(project.Solution.Options, project.Language);
-
-        public static InlineTypeHintsOptions From(OptionSet options, string language)
-          => new(
-                EnabledForTypes: options.GetOption(Metadata.EnabledForTypes, language),
-                ForImplicitVariableTypes: options.GetOption(Metadata.ForImplicitVariableTypes, language),
-                ForLambdaParameterTypes: options.GetOption(Metadata.ForLambdaParameterTypes, language),
-                ForImplicitObjectCreation: options.GetOption(Metadata.ForImplicitObjectCreation, language));
-
-        [ExportSolutionOptionProvider, Shared]
-        internal sealed class Metadata : IOptionProvider
-        {
-            [ImportingConstructor]
-            [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-            public Metadata()
-            {
-            }
-
-            public ImmutableArray<IOption> Options { get; } = ImmutableArray.Create<IOption>(
-                EnabledForTypes,
-                ForImplicitVariableTypes,
-                ForLambdaParameterTypes,
-                ForImplicitObjectCreation);
-
-            private const string FeatureName = "InlineHintsOptions";
-
-            public static readonly PerLanguageOption2<bool> EnabledForTypes =
-                new(FeatureName,
-                    nameof(EnabledForTypes),
-                    defaultValue: false,
-                    storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.InlineTypeHints"));
-
-            public static readonly PerLanguageOption2<bool> ForImplicitVariableTypes =
-                new(FeatureName,
-                    nameof(ForImplicitVariableTypes),
-                    defaultValue: true,
-                    storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.InlineTypeHints.ForImplicitVariableTypes"));
-
-            public static readonly PerLanguageOption2<bool> ForLambdaParameterTypes =
-                new(FeatureName,
-                    nameof(ForLambdaParameterTypes),
-                    defaultValue: true,
-                    storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.InlineTypeHints.ForLambdaParameterTypes"));
-
-            public static readonly PerLanguageOption2<bool> ForImplicitObjectCreation =
-                new(FeatureName,
-                    nameof(ForImplicitObjectCreation),
-                    defaultValue: true,
-                    storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.InlineTypeHints.ForImplicitObjectCreation"));
-        }
-    }
 }
diff --git a/src/Features/Core/Portable/InlineHints/InlineTypeHintsOptions.cs b/src/Features/Core/Portable/InlineHints/InlineTypeHintsOptions.cs
new file mode 100644
index 0000000000000..a3fab02d85102
--- /dev/null
+++ b/src/Features/Core/Portable/InlineHints/InlineTypeHintsOptions.cs
@@ -0,0 +1,72 @@
+// 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.Immutable;
+using System.Composition;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Options.Providers;
+
+namespace Microsoft.CodeAnalysis.InlineHints
+{
+    internal readonly record struct InlineTypeHintsOptions(
+        bool EnabledForTypes,
+        bool ForImplicitVariableTypes,
+        bool ForLambdaParameterTypes,
+        bool ForImplicitObjectCreation)
+    {
+        public static InlineTypeHintsOptions From(Project project)
+            => From(project.Solution.Options, project.Language);
+
+        public static InlineTypeHintsOptions From(OptionSet options, string language)
+          => new(
+                EnabledForTypes: options.GetOption(Metadata.EnabledForTypes, language),
+                ForImplicitVariableTypes: options.GetOption(Metadata.ForImplicitVariableTypes, language),
+                ForLambdaParameterTypes: options.GetOption(Metadata.ForLambdaParameterTypes, language),
+                ForImplicitObjectCreation: options.GetOption(Metadata.ForImplicitObjectCreation, language));
+
+        [ExportSolutionOptionProvider, Shared]
+        internal sealed class Metadata : IOptionProvider
+        {
+            [ImportingConstructor]
+            [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+            public Metadata()
+            {
+            }
+
+            public ImmutableArray<IOption> Options { get; } = ImmutableArray.Create<IOption>(
+                EnabledForTypes,
+                ForImplicitVariableTypes,
+                ForLambdaParameterTypes,
+                ForImplicitObjectCreation);
+
+            private const string FeatureName = "InlineHintsOptions";
+
+            public static readonly PerLanguageOption2<bool> EnabledForTypes =
+                new(FeatureName,
+                    nameof(EnabledForTypes),
+                    defaultValue: false,
+                    storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.InlineTypeHints"));
+
+            public static readonly PerLanguageOption2<bool> ForImplicitVariableTypes =
+                new(FeatureName,
+                    nameof(ForImplicitVariableTypes),
+                    defaultValue: true,
+                    storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.InlineTypeHints.ForImplicitVariableTypes"));
+
+            public static readonly PerLanguageOption2<bool> ForLambdaParameterTypes =
+                new(FeatureName,
+                    nameof(ForLambdaParameterTypes),
+                    defaultValue: true,
+                    storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.InlineTypeHints.ForLambdaParameterTypes"));
+
+            public static readonly PerLanguageOption2<bool> ForImplicitObjectCreation =
+                new(FeatureName,
+                    nameof(ForImplicitObjectCreation),
+                    defaultValue: true,
+                    storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.InlineTypeHints.ForImplicitObjectCreation"));
+        }
+    }
+}
diff --git a/src/Tools/ExternalAccess/FSharp/Internal/InlineHints/FSharpInlineHintsService.cs b/src/Tools/ExternalAccess/FSharp/Internal/InlineHints/FSharpInlineHintsService.cs
index 27d8d498a86be..b31ae4e182941 100644
--- a/src/Tools/ExternalAccess/FSharp/Internal/InlineHints/FSharpInlineHintsService.cs
+++ b/src/Tools/ExternalAccess/FSharp/Internal/InlineHints/FSharpInlineHintsService.cs
@@ -27,7 +27,7 @@ public FSharpInlineHintsService(
             _service = service;
         }
 
-        public async Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(Document document, TextSpan textSpan, CancellationToken cancellationToken)
+        public async Task<ImmutableArray<InlineHint>> GetInlineHintsAsync(Document document, TextSpan textSpan, InlineHintsOptions options, CancellationToken cancellationToken)
         {
             if (_service == null)
                 return ImmutableArray<InlineHint>.Empty;
diff --git a/src/Tools/ExternalAccess/OmniSharp/InlineHints/OmniSharpInlineHintsService.cs b/src/Tools/ExternalAccess/OmniSharp/InlineHints/OmniSharpInlineHintsService.cs
index d0822334c1185..01c26617fcc5b 100644
--- a/src/Tools/ExternalAccess/OmniSharp/InlineHints/OmniSharpInlineHintsService.cs
+++ b/src/Tools/ExternalAccess/OmniSharp/InlineHints/OmniSharpInlineHintsService.cs
@@ -17,7 +17,9 @@ internal static class OmniSharpInlineHintsService
         public static async Task<ImmutableArray<OmniSharpInlineHint>> GetInlineHintsAsync(Document document, TextSpan textSpan, CancellationToken cancellationToken)
         {
             var service = document.GetRequiredLanguageService<IInlineHintsService>();
-            var hints = await service.GetInlineHintsAsync(document, textSpan, cancellationToken).ConfigureAwait(false);
+            var options = InlineHintsOptions.From(document.Project);
+
+            var hints = await service.GetInlineHintsAsync(document, textSpan, options, cancellationToken).ConfigureAwait(false);
             return hints.SelectAsArray(static h => new OmniSharpInlineHint(
                 h.Span,
                 h.DisplayParts,

From 554f5df1360abddc4eccac51634c7ba1393cbd98 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: Tue, 4 Jan 2022 16:35:47 -0800
Subject: [PATCH 227/444] Extract method options refactoring (#58549)

---
 .../ExtractMethodCommandHandler.cs            |  6 ++-
 .../ExtractMethod/ExtractMethodBase.cs        | 12 ++----
 .../ExtractMethod/ExtractMethodTests.cs       |  4 +-
 .../AbstractExtractMethodCommandHandler.cs    | 28 +++++++------
 .../ExtractMethodPresentationOptions.cs}      | 14 ++++---
 .../ExtractMethodCommandHandler.vb            |  6 ++-
 .../ExtractMethodTests.LanguageInteraction.vb |  4 +-
 .../ExtractMethod/ExtractMethodTests.vb       | 11 ++----
 .../CSharpExtractMethodService.cs             |  2 +-
 .../CSharpSelectionResult.ExpressionResult.cs |  2 +-
 .../CSharpSelectionResult.StatementResult.cs  |  2 +-
 .../ExtractMethod/CSharpSelectionResult.cs    |  5 +--
 .../ExtractMethod/CSharpSelectionValidator.cs |  2 +-
 ...actExtractMethodCodeRefactoringProvider.cs | 19 +++++----
 .../AbstractExtractMethodService.cs           |  6 +--
 .../ExtractMethod/ExtractMethodOptions.cs     | 39 ++++++++++++++++---
 .../ExtractMethod/ExtractMethodService.cs     |  2 +-
 .../ExtractMethod/IExtractMethodService.cs    |  2 +-
 .../ExtractMethod/MethodExtractor.Analyzer.cs |  2 +-
 .../Portable/ExtractMethod/SelectionResult.cs | 12 +-----
 .../ExtractMethod/SelectionValidator.cs       |  4 +-
 .../VisualBasicExtractMethodService.vb        |  2 +-
 .../VisualBasicSelectionResult.vb             |  4 +-
 .../VisualBasicSelectionValidator.vb          |  2 +-
 .../Options/AdvancedOptionPageControl.xaml.cs |  2 +-
 .../AutomationObject.ExtractMethod.cs         |  8 ++--
 .../Options/AdvancedOptionPageControl.xaml.vb |  2 +-
 .../AutomationObject.ExtractMethod.vb         |  8 ++--
 28 files changed, 120 insertions(+), 92 deletions(-)
 rename src/{Features/Core/Portable/ExtractMethod/ExtractMethodOptionsProvider.cs => EditorFeatures/Core/Implementation/ExtractMethod/ExtractMethodPresentationOptions.cs} (57%)

diff --git a/src/EditorFeatures/CSharp/ExtractMethod/ExtractMethodCommandHandler.cs b/src/EditorFeatures/CSharp/ExtractMethod/ExtractMethodCommandHandler.cs
index 502465bcd6e23..538a825537709 100644
--- a/src/EditorFeatures/CSharp/ExtractMethod/ExtractMethodCommandHandler.cs
+++ b/src/EditorFeatures/CSharp/ExtractMethod/ExtractMethodCommandHandler.cs
@@ -9,6 +9,7 @@
 using Microsoft.CodeAnalysis.Editor.Implementation.ExtractMethod;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.VisualStudio.Commanding;
 using Microsoft.VisualStudio.Text.Operations;
 using Microsoft.VisualStudio.Utilities;
@@ -27,8 +28,9 @@ internal class ExtractMethodCommandHandler :
         public ExtractMethodCommandHandler(
             IThreadingContext threadingContext,
             ITextBufferUndoManagerProvider undoManager,
-            IInlineRenameService renameService)
-            : base(threadingContext, undoManager, renameService)
+            IInlineRenameService renameService,
+            IGlobalOptionService globalOptions)
+            : base(threadingContext, undoManager, renameService, globalOptions)
         {
         }
     }
diff --git a/src/EditorFeatures/CSharpTest/ExtractMethod/ExtractMethodBase.cs b/src/EditorFeatures/CSharpTest/ExtractMethod/ExtractMethodBase.cs
index 805080c0e7c16..0dea28ee23a34 100644
--- a/src/EditorFeatures/CSharpTest/ExtractMethod/ExtractMethodBase.cs
+++ b/src/EditorFeatures/CSharpTest/ExtractMethod/ExtractMethodBase.cs
@@ -126,9 +126,7 @@ protected static async Task<SyntaxNode> ExtractMethodAsync(
             var document = workspace.CurrentSolution.GetDocument(testDocument.Id);
             Assert.NotNull(document);
 
-            var originalOptions = await document.GetOptionsAsync();
-            var options = originalOptions.WithChangedOption(ExtractMethodOptions.DontPutOutOrRefOnStruct, document.Project.Language, dontPutOutOrRefOnStruct);
-
+            var options = new ExtractMethodOptions(DontPutOutOrRefOnStruct: dontPutOutOrRefOnStruct);
             var semanticDocument = await SemanticDocument.CreateAsync(document, CancellationToken.None);
             var validator = new CSharpSelectionValidator(semanticDocument, testDocument.SelectedSpans.Single(), localFunction: false, options);
 
@@ -164,10 +162,8 @@ protected static async Task TestSelectionAsync(string codeWithMarker, bool expec
             var document = workspace.CurrentSolution.GetDocument(testDocument.Id);
             Assert.NotNull(document);
 
-            var options = await document.GetOptionsAsync(CancellationToken.None);
-
             var semanticDocument = await SemanticDocument.CreateAsync(document, CancellationToken.None);
-            var validator = new CSharpSelectionValidator(semanticDocument, textSpanOverride ?? namedSpans["b"].Single(), localFunction: false, options);
+            var validator = new CSharpSelectionValidator(semanticDocument, textSpanOverride ?? namedSpans["b"].Single(), localFunction: false, ExtractMethodOptions.Default);
             var result = await validator.GetValidSelectionAsync(CancellationToken.None);
 
             Assert.True(expectedFail ? result.Status.Failed() : result.Status.Succeeded());
@@ -188,11 +184,9 @@ protected static async Task IterateAllAsync(string code)
             var root = await document.GetSyntaxRootAsync();
             var iterator = root.DescendantNodesAndSelf().Cast<SyntaxNode>();
 
-            var originalOptions = await document.GetOptionsAsync();
-
             foreach (var node in iterator)
             {
-                var validator = new CSharpSelectionValidator(semanticDocument, node.Span, localFunction: false, originalOptions);
+                var validator = new CSharpSelectionValidator(semanticDocument, node.Span, localFunction: false, ExtractMethodOptions.Default);
                 var result = await validator.GetValidSelectionAsync(CancellationToken.None);
 
                 // check the obvious case
diff --git a/src/EditorFeatures/CSharpTest/ExtractMethod/ExtractMethodTests.cs b/src/EditorFeatures/CSharpTest/ExtractMethod/ExtractMethodTests.cs
index 31afbd994fb98..b95540de7e212 100644
--- a/src/EditorFeatures/CSharpTest/ExtractMethod/ExtractMethodTests.cs
+++ b/src/EditorFeatures/CSharpTest/ExtractMethod/ExtractMethodTests.cs
@@ -10376,7 +10376,7 @@ public async Task ExtractMethod_Argument1()
             var service = new CSharpExtractMethodService();
             Assert.NotNull(await Record.ExceptionAsync(async () =>
             {
-                var tree = await service.ExtractMethodAsync(document: null, textSpan: default, localFunction: false, options: null, CancellationToken.None);
+                var tree = await service.ExtractMethodAsync(document: null, textSpan: default, localFunction: false, options: ExtractMethodOptions.Default, CancellationToken.None);
             }));
         }
 
@@ -10392,7 +10392,7 @@ public async Task ExtractMethod_Argument2()
 
             var service = new CSharpExtractMethodService() as IExtractMethodService;
 
-            await service.ExtractMethodAsync(document, textSpan: default, localFunction: false);
+            await service.ExtractMethodAsync(document, textSpan: default, localFunction: false, ExtractMethodOptions.Default, CancellationToken.None);
         }
 
         [WpfFact]
diff --git a/src/EditorFeatures/Core/Implementation/ExtractMethod/AbstractExtractMethodCommandHandler.cs b/src/EditorFeatures/Core/Implementation/ExtractMethod/AbstractExtractMethodCommandHandler.cs
index e60413924f00b..47ad629348701 100644
--- a/src/EditorFeatures/Core/Implementation/ExtractMethod/AbstractExtractMethodCommandHandler.cs
+++ b/src/EditorFeatures/Core/Implementation/ExtractMethod/AbstractExtractMethodCommandHandler.cs
@@ -11,6 +11,7 @@
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.ExtractMethod;
 using Microsoft.CodeAnalysis.Notification;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.CodeAnalysis.Text.Shared.Extensions;
 using Microsoft.VisualStudio.Commanding;
@@ -28,11 +29,13 @@ internal abstract class AbstractExtractMethodCommandHandler : ICommandHandler<Ex
         private readonly IThreadingContext _threadingContext;
         private readonly ITextBufferUndoManagerProvider _undoManager;
         private readonly IInlineRenameService _renameService;
+        private readonly IGlobalOptionService _globalOptions;
 
         public AbstractExtractMethodCommandHandler(
             IThreadingContext threadingContext,
             ITextBufferUndoManagerProvider undoManager,
-            IInlineRenameService renameService)
+            IInlineRenameService renameService,
+            IGlobalOptionService globalOptions)
         {
             Contract.ThrowIfNull(threadingContext);
             Contract.ThrowIfNull(undoManager);
@@ -41,6 +44,7 @@ public AbstractExtractMethodCommandHandler(
             _threadingContext = threadingContext;
             _undoManager = undoManager;
             _renameService = renameService;
+            _globalOptions = globalOptions;
         }
         public string DisplayName => EditorFeaturesResources.Extract_Method;
 
@@ -102,14 +106,15 @@ private bool Execute(
                 return false;
             }
 
+            var options = ExtractMethodOptions.From(document.Project);
             var result = ExtractMethodService.ExtractMethodAsync(
-                document, spans.Single().Span.ToTextSpan(), localFunction: false, cancellationToken: cancellationToken).WaitAndGetResult(cancellationToken);
+                document, spans.Single().Span.ToTextSpan(), localFunction: false, options, cancellationToken).WaitAndGetResult(cancellationToken);
             Contract.ThrowIfNull(result);
 
             if (!result.Succeeded && !result.SucceededWithSuggestion)
             {
                 // if it failed due to out/ref parameter in async method, try it with different option
-                var newResult = TryWithoutMakingValueTypesRef(document, spans, result, cancellationToken);
+                var newResult = TryWithoutMakingValueTypesRef(document, spans, result, options, cancellationToken);
                 if (newResult != null)
                 {
                     var notificationService = document.Project.Solution.Workspace.Services.GetService<INotificationService>();
@@ -164,7 +169,7 @@ private bool Execute(
         ///       Extract Method does not proceed further and is done.
         /// False: the user proceeded to a best effort scenario.
         /// </returns>
-        private static bool TryNotifyFailureToUser(Document document, ExtractMethodResult result, IUIThreadOperationContext waitContext)
+        private bool TryNotifyFailureToUser(Document document, ExtractMethodResult result, IUIThreadOperationContext waitContext)
         {
             // We are about to show a modal UI dialog so we should take over the command execution
             // wait context. That means the command system won't attempt to show its own wait dialog 
@@ -175,7 +180,7 @@ private static bool TryNotifyFailureToUser(Document document, ExtractMethodResul
             var notificationService = solution.Workspace.Services.GetService<INotificationService>();
 
             // see whether we will allow best effort extraction and if it is possible.
-            if (!solution.Options.GetOption(ExtractMethodOptions.AllowBestEffort, project.Language) ||
+            if (!_globalOptions.GetOption(ExtractMethodPresentationOptions.AllowBestEffort, document.Project.Language) ||
                 !result.Status.HasBestEffort() ||
                 result.DocumentWithoutFinalFormatting == null)
             {
@@ -209,11 +214,9 @@ private static bool TryNotifyFailureToUser(Document document, ExtractMethodResul
         }
 
         private static ExtractMethodResult TryWithoutMakingValueTypesRef(
-            Document document, NormalizedSnapshotSpanCollection spans, ExtractMethodResult result, CancellationToken cancellationToken)
+            Document document, NormalizedSnapshotSpanCollection spans, ExtractMethodResult result, ExtractMethodOptions options, CancellationToken cancellationToken)
         {
-            var options = document.Project.Solution.Options;
-
-            if (options.GetOption(ExtractMethodOptions.DontPutOutOrRefOnStruct, document.Project.Language) || !result.Reasons.IsSingle())
+            if (options.DontPutOutOrRefOnStruct || !result.Reasons.IsSingle())
             {
                 return null;
             }
@@ -222,9 +225,12 @@ private static ExtractMethodResult TryWithoutMakingValueTypesRef(
             var length = FeaturesResources.Asynchronous_method_cannot_have_ref_out_parameters_colon_bracket_0_bracket.IndexOf(':');
             if (reason != null && length > 0 && reason.IndexOf(FeaturesResources.Asynchronous_method_cannot_have_ref_out_parameters_colon_bracket_0_bracket.Substring(0, length), 0, length, StringComparison.Ordinal) >= 0)
             {
-                options = options.WithChangedOption(ExtractMethodOptions.DontPutOutOrRefOnStruct, document.Project.Language, true);
                 var newResult = ExtractMethodService.ExtractMethodAsync(
-                    document, spans.Single().Span.ToTextSpan(), localFunction: false, options, cancellationToken).WaitAndGetResult(cancellationToken);
+                    document,
+                    spans.Single().Span.ToTextSpan(),
+                    localFunction: false,
+                    options with { DontPutOutOrRefOnStruct = true },
+                    cancellationToken).WaitAndGetResult(cancellationToken);
 
                 // retry succeeded, return new result
                 if (newResult.Succeeded || newResult.SucceededWithSuggestion)
diff --git a/src/Features/Core/Portable/ExtractMethod/ExtractMethodOptionsProvider.cs b/src/EditorFeatures/Core/Implementation/ExtractMethod/ExtractMethodPresentationOptions.cs
similarity index 57%
rename from src/Features/Core/Portable/ExtractMethod/ExtractMethodOptionsProvider.cs
rename to src/EditorFeatures/Core/Implementation/ExtractMethod/ExtractMethodPresentationOptions.cs
index ab5682fb2fb56..9850088e3b467 100644
--- a/src/Features/Core/Portable/ExtractMethod/ExtractMethodOptionsProvider.cs
+++ b/src/EditorFeatures/Core/Implementation/ExtractMethod/ExtractMethodPresentationOptions.cs
@@ -11,17 +11,21 @@
 
 namespace Microsoft.CodeAnalysis.ExtractMethod
 {
-    [ExportSolutionOptionProvider, Shared]
-    internal class ExtractMethodOptionsProvider : IOptionProvider
+    [ExportGlobalOptionProvider, Shared]
+    internal sealed class ExtractMethodPresentationOptions : IOptionProvider
     {
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public ExtractMethodOptionsProvider()
+        public ExtractMethodPresentationOptions()
         {
         }
 
         public ImmutableArray<IOption> Options { get; } = ImmutableArray.Create<IOption>(
-            ExtractMethodOptions.AllowBestEffort,
-            ExtractMethodOptions.DontPutOutOrRefOnStruct);
+            AllowBestEffort);
+
+        private const string FeatureName = "ExtractMethodOptions";
+
+        public static readonly PerLanguageOption2<bool> AllowBestEffort = new(FeatureName, "AllowBestEffort", defaultValue: true,
+            storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.Allow Best Effort"));
     }
 }
diff --git a/src/EditorFeatures/VisualBasic/ExtractMethod/ExtractMethodCommandHandler.vb b/src/EditorFeatures/VisualBasic/ExtractMethod/ExtractMethodCommandHandler.vb
index 7f242e5912d1d..568e315071bec 100644
--- a/src/EditorFeatures/VisualBasic/ExtractMethod/ExtractMethodCommandHandler.vb
+++ b/src/EditorFeatures/VisualBasic/ExtractMethod/ExtractMethodCommandHandler.vb
@@ -6,6 +6,7 @@ Imports System.ComponentModel.Composition
 Imports System.Diagnostics.CodeAnalysis
 Imports Microsoft.CodeAnalysis.Editor.Implementation.ExtractMethod
 Imports Microsoft.CodeAnalysis.Editor.[Shared].Utilities
+Imports Microsoft.CodeAnalysis.Options
 Imports Microsoft.VisualStudio.Commanding
 Imports Microsoft.VisualStudio.Text.Operations
 Imports Microsoft.VisualStudio.Utilities
@@ -22,8 +23,9 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.ExtractMethod
         <SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification:="Used in test code: https://github.com/dotnet/roslyn/issues/42814")>
         Public Sub New(threadingContext As IThreadingContext,
                        undoManager As ITextBufferUndoManagerProvider,
-                       renameService As IInlineRenameService)
-            MyBase.New(threadingContext, undoManager, renameService)
+                       renameService As IInlineRenameService,
+                       globalOptions As IGlobalOptionService)
+            MyBase.New(threadingContext, undoManager, renameService, globalOptions)
         End Sub
     End Class
 End Namespace
diff --git a/src/EditorFeatures/VisualBasicTest/ExtractMethod/ExtractMethodTests.LanguageInteraction.vb b/src/EditorFeatures/VisualBasicTest/ExtractMethod/ExtractMethodTests.LanguageInteraction.vb
index 8e3a5f55fe5be..45d239267732a 100644
--- a/src/EditorFeatures/VisualBasicTest/ExtractMethod/ExtractMethodTests.LanguageInteraction.vb
+++ b/src/EditorFeatures/VisualBasicTest/ExtractMethod/ExtractMethodTests.LanguageInteraction.vb
@@ -7,6 +7,7 @@ Imports Microsoft.CodeAnalysis.Editor.[Shared].Utilities
 Imports Microsoft.CodeAnalysis.Editor.UnitTests
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
 Imports Microsoft.CodeAnalysis.Editor.VisualBasic.ExtractMethod
+Imports Microsoft.CodeAnalysis.Options
 Imports Microsoft.VisualStudio.Text.Editor.Commanding.Commands
 Imports Microsoft.VisualStudio.Text.Operations
 
@@ -3388,7 +3389,8 @@ End Namespace"
                     Dim handler = New ExtractMethodCommandHandler(
                         workspace.GetService(Of IThreadingContext)(),
                         workspace.GetService(Of ITextBufferUndoManagerProvider)(),
-                        workspace.GetService(Of IInlineRenameService)())
+                        workspace.GetService(Of IInlineRenameService)(),
+                        workspace.GetService(Of IGlobalOptionService)())
 
                     Dim state = handler.GetCommandState(New ExtractMethodCommandArgs(textView, textView.TextBuffer))
                     Assert.True(state.IsUnspecified)
diff --git a/src/EditorFeatures/VisualBasicTest/ExtractMethod/ExtractMethodTests.vb b/src/EditorFeatures/VisualBasicTest/ExtractMethod/ExtractMethodTests.vb
index ee4456dee8dd0..b232c311c599e 100644
--- a/src/EditorFeatures/VisualBasicTest/ExtractMethod/ExtractMethodTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/ExtractMethod/ExtractMethodTests.vb
@@ -96,8 +96,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.ExtractMethod
             Dim document = workspace.CurrentSolution.GetDocument(testDocument.Id)
             Assert.NotNull(document)
 
-            Dim originalOptions = Await document.GetOptionsAsync()
-            Dim options = originalOptions.WithChangedOption(ExtractMethodOptions.DontPutOutOrRefOnStruct, document.Project.Language, dontPutOutOrRefOnStruct)
+            Dim options = New ExtractMethodOptions(DontPutOutOrRefOnStruct:=dontPutOutOrRefOnStruct)
 
             Dim sdocument = Await SemanticDocument.CreateAsync(document, CancellationToken.None)
             Dim validator = New VisualBasicSelectionValidator(sdocument, snapshotSpan.Span.ToTextSpan(), options)
@@ -128,10 +127,8 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.ExtractMethod
                 Dim document = workspace.CurrentSolution.GetDocument(workspace.Documents.First().Id)
                 Assert.NotNull(document)
 
-                Dim originalOptions = Await document.GetOptionsAsync()
-
                 Dim sdocument = Await SemanticDocument.CreateAsync(document, CancellationToken.None)
-                Dim validator = New VisualBasicSelectionValidator(sdocument, namedSpans("b").Single(), originalOptions)
+                Dim validator = New VisualBasicSelectionValidator(sdocument, namedSpans("b").Single(), ExtractMethodOptions.Default)
                 Dim result = Await validator.GetValidSelectionAsync(CancellationToken.None)
 
                 If expectedFail Then
@@ -163,11 +160,9 @@ End Class</text>
                 Dim root = Await document.GetSyntaxRootAsync()
                 Dim iterator = root.DescendantNodesAndSelf()
 
-                Dim originalOptions = Await document.GetOptionsAsync()
-
                 For Each node In iterator
                     Try
-                        Dim validator = New VisualBasicSelectionValidator(sdocument, node.Span, originalOptions)
+                        Dim validator = New VisualBasicSelectionValidator(sdocument, node.Span, ExtractMethodOptions.Default)
                         Dim result = Await validator.GetValidSelectionAsync(CancellationToken.None)
 
                         ' check the obvious case
diff --git a/src/Features/CSharp/Portable/ExtractMethod/CSharpExtractMethodService.cs b/src/Features/CSharp/Portable/ExtractMethod/CSharpExtractMethodService.cs
index b09e94d3a8583..35d31d35119cc 100644
--- a/src/Features/CSharp/Portable/ExtractMethod/CSharpExtractMethodService.cs
+++ b/src/Features/CSharp/Portable/ExtractMethod/CSharpExtractMethodService.cs
@@ -23,7 +23,7 @@ public CSharpExtractMethodService()
         {
         }
 
-        protected override CSharpSelectionValidator CreateSelectionValidator(SemanticDocument document, TextSpan textSpan, bool localFunction, OptionSet options)
+        protected override CSharpSelectionValidator CreateSelectionValidator(SemanticDocument document, TextSpan textSpan, bool localFunction, ExtractMethodOptions options)
             => new CSharpSelectionValidator(document, textSpan, localFunction, options);
 
         protected override CSharpMethodExtractor CreateMethodExtractor(CSharpSelectionResult selectionResult, bool localFunction)
diff --git a/src/Features/CSharp/Portable/ExtractMethod/CSharpSelectionResult.ExpressionResult.cs b/src/Features/CSharp/Portable/ExtractMethod/CSharpSelectionResult.ExpressionResult.cs
index 68b9940f9abd3..1c0d81407d5a4 100644
--- a/src/Features/CSharp/Portable/ExtractMethod/CSharpSelectionResult.ExpressionResult.cs
+++ b/src/Features/CSharp/Portable/ExtractMethod/CSharpSelectionResult.ExpressionResult.cs
@@ -24,7 +24,7 @@ public ExpressionResult(
                 OperationStatus status,
                 TextSpan originalSpan,
                 TextSpan finalSpan,
-                OptionSet options,
+                ExtractMethodOptions options,
                 bool selectionInExpression,
                 SemanticDocument document,
                 SyntaxAnnotation firstTokenAnnotation,
diff --git a/src/Features/CSharp/Portable/ExtractMethod/CSharpSelectionResult.StatementResult.cs b/src/Features/CSharp/Portable/ExtractMethod/CSharpSelectionResult.StatementResult.cs
index 262b06e092ccf..e0b8ae55ec9ed 100644
--- a/src/Features/CSharp/Portable/ExtractMethod/CSharpSelectionResult.StatementResult.cs
+++ b/src/Features/CSharp/Portable/ExtractMethod/CSharpSelectionResult.StatementResult.cs
@@ -22,7 +22,7 @@ public StatementResult(
                 OperationStatus status,
                 TextSpan originalSpan,
                 TextSpan finalSpan,
-                OptionSet options,
+                ExtractMethodOptions options,
                 bool selectionInExpression,
                 SemanticDocument document,
                 SyntaxAnnotation firstTokenAnnotation,
diff --git a/src/Features/CSharp/Portable/ExtractMethod/CSharpSelectionResult.cs b/src/Features/CSharp/Portable/ExtractMethod/CSharpSelectionResult.cs
index 31802dec9c035..467ffcf7d04df 100644
--- a/src/Features/CSharp/Portable/ExtractMethod/CSharpSelectionResult.cs
+++ b/src/Features/CSharp/Portable/ExtractMethod/CSharpSelectionResult.cs
@@ -13,7 +13,6 @@
 using Microsoft.CodeAnalysis.CSharp.LanguageServices;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.ExtractMethod;
-using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
@@ -26,7 +25,7 @@ public static async Task<CSharpSelectionResult> CreateAsync(
             OperationStatus status,
             TextSpan originalSpan,
             TextSpan finalSpan,
-            OptionSet options,
+            ExtractMethodOptions options,
             bool selectionInExpression,
             SemanticDocument document,
             SyntaxToken firstToken,
@@ -65,7 +64,7 @@ protected CSharpSelectionResult(
             OperationStatus status,
             TextSpan originalSpan,
             TextSpan finalSpan,
-            OptionSet options,
+            ExtractMethodOptions options,
             bool selectionInExpression,
             SemanticDocument document,
             SyntaxAnnotation firstTokenAnnotation,
diff --git a/src/Features/CSharp/Portable/ExtractMethod/CSharpSelectionValidator.cs b/src/Features/CSharp/Portable/ExtractMethod/CSharpSelectionValidator.cs
index d47db8206b1c0..e31dfc8200a70 100644
--- a/src/Features/CSharp/Portable/ExtractMethod/CSharpSelectionValidator.cs
+++ b/src/Features/CSharp/Portable/ExtractMethod/CSharpSelectionValidator.cs
@@ -30,7 +30,7 @@ public CSharpSelectionValidator(
             SemanticDocument document,
             TextSpan textSpan,
             bool localFunction,
-            OptionSet options)
+            ExtractMethodOptions options)
             : base(document, textSpan, options)
         {
             _localFunction = localFunction;
diff --git a/src/Features/Core/Portable/CodeRefactorings/ExtractMethod/AbstractExtractMethodCodeRefactoringProvider.cs b/src/Features/Core/Portable/CodeRefactorings/ExtractMethod/AbstractExtractMethodCodeRefactoringProvider.cs
index 440ab240d1e53..82bbd31742cba 100644
--- a/src/Features/Core/Portable/CodeRefactorings/ExtractMethod/AbstractExtractMethodCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/CodeRefactorings/ExtractMethod/AbstractExtractMethodCodeRefactoringProvider.cs
@@ -56,32 +56,36 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
                 return;
             }
 
-            var actions = await GetCodeActionsAsync(document, textSpan, cancellationToken: cancellationToken).ConfigureAwait(false);
+            var options = ExtractMethodOptions.From(document.Project);
+            var actions = await GetCodeActionsAsync(document, textSpan, options, cancellationToken).ConfigureAwait(false);
             context.RegisterRefactorings(actions);
         }
 
         private static async Task<ImmutableArray<CodeAction>> GetCodeActionsAsync(
             Document document,
             TextSpan textSpan,
+             ExtractMethodOptions options,
             CancellationToken cancellationToken)
         {
             using var _ = ArrayBuilder<CodeAction>.GetInstance(out var actions);
-            var methodAction = await ExtractMethodAsync(document, textSpan, cancellationToken).ConfigureAwait(false);
+            var methodAction = await ExtractMethodAsync(document, textSpan, options, cancellationToken).ConfigureAwait(false);
             actions.AddIfNotNull(methodAction);
 
-            var localFunctionAction = await ExtractLocalFunctionAsync(document, textSpan, cancellationToken).ConfigureAwait(false);
+            var localFunctionAction = await ExtractLocalFunctionAsync(document, textSpan, options, cancellationToken).ConfigureAwait(false);
             actions.AddIfNotNull(localFunctionAction);
 
             return actions.ToImmutable();
         }
 
-        private static async Task<CodeAction> ExtractMethodAsync(Document document, TextSpan textSpan, CancellationToken cancellationToken)
+        private static async Task<CodeAction> ExtractMethodAsync(Document document, TextSpan textSpan, ExtractMethodOptions options, CancellationToken cancellationToken)
         {
             var result = await ExtractMethodService.ExtractMethodAsync(
                 document,
                 textSpan,
                 localFunction: false,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                options,
+                cancellationToken).ConfigureAwait(false);
+
             Contract.ThrowIfNull(result);
 
             if (!result.Succeeded && !result.SucceededWithSuggestion)
@@ -97,7 +101,7 @@ private static async Task<CodeAction> ExtractMethodAsync(Document document, Text
                 nameof(FeaturesResources.Extract_method));
         }
 
-        private static async Task<CodeAction> ExtractLocalFunctionAsync(Document document, TextSpan textSpan, CancellationToken cancellationToken)
+        private static async Task<CodeAction> ExtractLocalFunctionAsync(Document document, TextSpan textSpan, ExtractMethodOptions options, CancellationToken cancellationToken)
         {
             var syntaxTree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
             var syntaxFacts = document.GetLanguageService<ISyntaxFactsService>();
@@ -110,7 +114,8 @@ private static async Task<CodeAction> ExtractLocalFunctionAsync(Document documen
                 document,
                 textSpan,
                 localFunction: true,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                options,
+                cancellationToken).ConfigureAwait(false);
             Contract.ThrowIfNull(localFunctionResult);
 
             if (localFunctionResult.Succeeded || localFunctionResult.SucceededWithSuggestion)
diff --git a/src/Features/Core/Portable/ExtractMethod/AbstractExtractMethodService.cs b/src/Features/Core/Portable/ExtractMethod/AbstractExtractMethodService.cs
index a5b450c215daa..ac7d1adbe3f2e 100644
--- a/src/Features/Core/Portable/ExtractMethod/AbstractExtractMethodService.cs
+++ b/src/Features/Core/Portable/ExtractMethod/AbstractExtractMethodService.cs
@@ -14,18 +14,16 @@ internal abstract class AbstractExtractMethodService<TValidator, TExtractor, TRe
         where TExtractor : MethodExtractor
         where TResult : SelectionResult
     {
-        protected abstract TValidator CreateSelectionValidator(SemanticDocument document, TextSpan textSpan, bool localFunction, OptionSet options);
+        protected abstract TValidator CreateSelectionValidator(SemanticDocument document, TextSpan textSpan, bool localFunction, ExtractMethodOptions options);
         protected abstract TExtractor CreateMethodExtractor(TResult selectionResult, bool localFunction);
 
         public async Task<ExtractMethodResult> ExtractMethodAsync(
             Document document,
             TextSpan textSpan,
             bool localFunction,
-            OptionSet? options,
+            ExtractMethodOptions options,
             CancellationToken cancellationToken)
         {
-            options ??= await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
-
             var semanticDocument = await SemanticDocument.CreateAsync(document, cancellationToken).ConfigureAwait(false);
 
             var validator = CreateSelectionValidator(semanticDocument, textSpan, localFunction, options);
diff --git a/src/Features/Core/Portable/ExtractMethod/ExtractMethodOptions.cs b/src/Features/Core/Portable/ExtractMethod/ExtractMethodOptions.cs
index 86a606d5872e5..61366380a943f 100644
--- a/src/Features/Core/Portable/ExtractMethod/ExtractMethodOptions.cs
+++ b/src/Features/Core/Portable/ExtractMethod/ExtractMethodOptions.cs
@@ -2,16 +2,45 @@
 // 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.Composition;
+using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Options.Providers;
 
 namespace Microsoft.CodeAnalysis.ExtractMethod
 {
-    internal static class ExtractMethodOptions
+    internal readonly record struct ExtractMethodOptions(
+        bool DontPutOutOrRefOnStruct)
     {
-        public static readonly PerLanguageOption2<bool> AllowBestEffort = new(nameof(ExtractMethodOptions), nameof(AllowBestEffort), defaultValue: true,
-            storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.Allow Best Effort"));
+        public static readonly ExtractMethodOptions Default
+          = new(
+              DontPutOutOrRefOnStruct: Metadata.DontPutOutOrRefOnStruct.DefaultValue);
 
-        public static readonly PerLanguageOption2<bool> DontPutOutOrRefOnStruct = new(nameof(ExtractMethodOptions), nameof(DontPutOutOrRefOnStruct), defaultValue: true,
-            storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.Don't Put Out Or Ref On Strcut")); // NOTE: the spelling error is what we've shipped and thus should not change
+        public static ExtractMethodOptions From(Project project)
+            => From(project.Solution.Options, project.Language);
+
+        public static ExtractMethodOptions From(OptionSet options, string language)
+          => new(
+              DontPutOutOrRefOnStruct: options.GetOption(Metadata.DontPutOutOrRefOnStruct, language));
+
+        [ExportSolutionOptionProvider, Shared]
+        internal sealed class Metadata : IOptionProvider
+        {
+            [ImportingConstructor]
+            [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+            public Metadata()
+            {
+            }
+
+            public ImmutableArray<IOption> Options { get; } = ImmutableArray.Create<IOption>(
+                DontPutOutOrRefOnStruct);
+
+            private const string FeatureName = "ExtractMethodOptions";
+
+            public static readonly PerLanguageOption2<bool> DontPutOutOrRefOnStruct = new(FeatureName, "DontPutOutOrRefOnStruct", defaultValue: true,
+                storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.Don't Put Out Or Ref On Strcut")); // NOTE: the spelling error is what we've shipped and thus should not change
+        }
     }
 }
diff --git a/src/Features/Core/Portable/ExtractMethod/ExtractMethodService.cs b/src/Features/Core/Portable/ExtractMethod/ExtractMethodService.cs
index 3370d91e688b1..3f42c691933ab 100644
--- a/src/Features/Core/Portable/ExtractMethod/ExtractMethodService.cs
+++ b/src/Features/Core/Portable/ExtractMethod/ExtractMethodService.cs
@@ -12,7 +12,7 @@ namespace Microsoft.CodeAnalysis.ExtractMethod
 {
     internal static class ExtractMethodService
     {
-        public static Task<ExtractMethodResult> ExtractMethodAsync(Document document, TextSpan textSpan, bool localFunction, OptionSet? options = null, CancellationToken cancellationToken = default)
+        public static Task<ExtractMethodResult> ExtractMethodAsync(Document document, TextSpan textSpan, bool localFunction, ExtractMethodOptions options, CancellationToken cancellationToken)
             => document.GetRequiredLanguageService<IExtractMethodService>().ExtractMethodAsync(document, textSpan, localFunction, options, cancellationToken);
     }
 }
diff --git a/src/Features/Core/Portable/ExtractMethod/IExtractMethodService.cs b/src/Features/Core/Portable/ExtractMethod/IExtractMethodService.cs
index b50db0b87a5a4..354dbf6a4ff9b 100644
--- a/src/Features/Core/Portable/ExtractMethod/IExtractMethodService.cs
+++ b/src/Features/Core/Portable/ExtractMethod/IExtractMethodService.cs
@@ -12,6 +12,6 @@ namespace Microsoft.CodeAnalysis.ExtractMethod
 {
     internal interface IExtractMethodService : ILanguageService
     {
-        Task<ExtractMethodResult> ExtractMethodAsync(Document document, TextSpan textSpan, bool localFunction, OptionSet? options = null, CancellationToken cancellationToken = default);
+        Task<ExtractMethodResult> ExtractMethodAsync(Document document, TextSpan textSpan, bool localFunction, ExtractMethodOptions options, CancellationToken cancellationToken);
     }
 }
diff --git a/src/Features/Core/Portable/ExtractMethod/MethodExtractor.Analyzer.cs b/src/Features/Core/Portable/ExtractMethod/MethodExtractor.Analyzer.cs
index 4dcf89443b860..f59b9b0d71b87 100644
--- a/src/Features/Core/Portable/ExtractMethod/MethodExtractor.Analyzer.cs
+++ b/src/Features/Core/Portable/ExtractMethod/MethodExtractor.Analyzer.cs
@@ -547,7 +547,7 @@ private bool TryGetVariableStyle(
                     return true;
                 }
 
-                if (UserDefinedValueType(model.Compilation, type) && !SelectionResult.DontPutOutOrRefOnStruct)
+                if (UserDefinedValueType(model.Compilation, type) && !SelectionResult.Options.DontPutOutOrRefOnStruct)
                 {
                     variableStyle = AlwaysReturn(variableStyle);
                     return true;
diff --git a/src/Features/Core/Portable/ExtractMethod/SelectionResult.cs b/src/Features/Core/Portable/ExtractMethod/SelectionResult.cs
index 6ed48f6d5459f..f5236e968d648 100644
--- a/src/Features/Core/Portable/ExtractMethod/SelectionResult.cs
+++ b/src/Features/Core/Portable/ExtractMethod/SelectionResult.cs
@@ -29,7 +29,7 @@ protected SelectionResult(
             OperationStatus status,
             TextSpan originalSpan,
             TextSpan finalSpan,
-            OptionSet options,
+            ExtractMethodOptions options,
             bool selectionInExpression,
             SemanticDocument document,
             SyntaxAnnotation firstTokenAnnotation,
@@ -59,7 +59,7 @@ protected SelectionResult(
         public OperationStatus Status { get; }
         public TextSpan OriginalSpan { get; }
         public TextSpan FinalSpan { get; }
-        public OptionSet Options { get; }
+        public ExtractMethodOptions Options { get; }
         public bool SelectionInExpression { get; }
         public SemanticDocument SemanticDocument { get; private set; }
         public SyntaxAnnotation FirstTokenAnnotation { get; }
@@ -193,13 +193,5 @@ private bool IsConfigureAwaitFalse(SyntaxNode node)
             var expression = syntaxFacts.GetExpressionOfArgument(argument);
             return syntaxFacts.IsFalseLiteralExpression(expression);
         }
-
-        public bool DontPutOutOrRefOnStruct
-        {
-            get
-            {
-                return Options.GetOption(ExtractMethodOptions.DontPutOutOrRefOnStruct, SemanticDocument.Project.Language);
-            }
-        }
     }
 }
diff --git a/src/Features/Core/Portable/ExtractMethod/SelectionValidator.cs b/src/Features/Core/Portable/ExtractMethod/SelectionValidator.cs
index c0d5191237495..aef1dfc561380 100644
--- a/src/Features/Core/Portable/ExtractMethod/SelectionValidator.cs
+++ b/src/Features/Core/Portable/ExtractMethod/SelectionValidator.cs
@@ -24,12 +24,12 @@ internal abstract partial class SelectionValidator
 
         protected readonly SemanticDocument SemanticDocument;
         protected readonly TextSpan OriginalSpan;
-        protected readonly OptionSet Options;
+        protected readonly ExtractMethodOptions Options;
 
         protected SelectionValidator(
             SemanticDocument document,
             TextSpan textSpan,
-            OptionSet options)
+            ExtractMethodOptions options)
         {
             Contract.ThrowIfNull(document);
 
diff --git a/src/Features/VisualBasic/Portable/ExtractMethod/VisualBasicExtractMethodService.vb b/src/Features/VisualBasic/Portable/ExtractMethod/VisualBasicExtractMethodService.vb
index 7739490ed7f5b..f8418af28345e 100644
--- a/src/Features/VisualBasic/Portable/ExtractMethod/VisualBasicExtractMethodService.vb
+++ b/src/Features/VisualBasic/Portable/ExtractMethod/VisualBasicExtractMethodService.vb
@@ -21,7 +21,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExtractMethod
         Protected Overrides Function CreateSelectionValidator(document As SemanticDocument,
                                                               textSpan As TextSpan,
                                                               localFunction As Boolean,
-                                                              options As OptionSet) As VisualBasicSelectionValidator
+                                                              options As ExtractMethodOptions) As VisualBasicSelectionValidator
             Return New VisualBasicSelectionValidator(document, textSpan, options)
         End Function
 
diff --git a/src/Features/VisualBasic/Portable/ExtractMethod/VisualBasicSelectionResult.vb b/src/Features/VisualBasic/Portable/ExtractMethod/VisualBasicSelectionResult.vb
index 3b4efa2083c66..e84e3d1aec908 100644
--- a/src/Features/VisualBasic/Portable/ExtractMethod/VisualBasicSelectionResult.vb
+++ b/src/Features/VisualBasic/Portable/ExtractMethod/VisualBasicSelectionResult.vb
@@ -21,7 +21,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExtractMethod
             status As OperationStatus,
             originalSpan As TextSpan,
             finalSpan As TextSpan,
-            options As OptionSet,
+            options As ExtractMethodOptions,
             selectionInExpression As Boolean,
             document As SemanticDocument,
             firstToken As SyntaxToken,
@@ -53,7 +53,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExtractMethod
             status As OperationStatus,
             originalSpan As TextSpan,
             finalSpan As TextSpan,
-            options As OptionSet,
+            options As ExtractMethodOptions,
             selectionInExpression As Boolean,
             document As SemanticDocument,
             firstTokenAnnotation As SyntaxAnnotation,
diff --git a/src/Features/VisualBasic/Portable/ExtractMethod/VisualBasicSelectionValidator.vb b/src/Features/VisualBasic/Portable/ExtractMethod/VisualBasicSelectionValidator.vb
index c8c7fe6bf3875..7b0d6de815cc8 100644
--- a/src/Features/VisualBasic/Portable/ExtractMethod/VisualBasicSelectionValidator.vb
+++ b/src/Features/VisualBasic/Portable/ExtractMethod/VisualBasicSelectionValidator.vb
@@ -17,7 +17,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExtractMethod
 
         Public Sub New(document As SemanticDocument,
                        textSpan As TextSpan,
-                       options As OptionSet)
+                       options As ExtractMethodOptions)
             MyBase.New(document, textSpan, options)
         End Sub
 
diff --git a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
index f769d0fbfbe3a..8481b60ff48ad 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
@@ -116,7 +116,7 @@ public AdvancedOptionPageControl(OptionStore optionStore, IComponentModel compon
                 return optionStore.GetOption(SourceGeneratedFileManager.Options.EnableOpeningInWorkspaceFeatureFlag);
             });
 
-            BindToOption(DontPutOutOrRefOnStruct, ExtractMethodOptions.DontPutOutOrRefOnStruct, LanguageNames.CSharp);
+            BindToOption(DontPutOutOrRefOnStruct, ExtractMethodOptions.Metadata.DontPutOutOrRefOnStruct, LanguageNames.CSharp);
 
             BindToOption(with_other_members_of_the_same_kind, ImplementTypeOptions.Metadata.InsertionBehavior, ImplementTypeInsertionBehavior.WithOtherMembersOfTheSameKind, LanguageNames.CSharp);
             BindToOption(at_the_end, ImplementTypeOptions.Metadata.InsertionBehavior, ImplementTypeInsertionBehavior.AtTheEnd, LanguageNames.CSharp);
diff --git a/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.ExtractMethod.cs b/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.ExtractMethod.cs
index 05f3658e2a39d..b1bb1037b4004 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.ExtractMethod.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.ExtractMethod.cs
@@ -10,14 +10,14 @@ public partial class AutomationObject
     {
         public int ExtractMethod_AllowBestEffort
         {
-            get { return GetBooleanOption(ExtractMethodOptions.AllowBestEffort); }
-            set { SetBooleanOption(ExtractMethodOptions.AllowBestEffort, value); }
+            get { return GetBooleanOption(ExtractMethodPresentationOptions.AllowBestEffort); }
+            set { SetBooleanOption(ExtractMethodPresentationOptions.AllowBestEffort, value); }
         }
 
         public int ExtractMethod_DoNotPutOutOrRefOnStruct
         {
-            get { return GetBooleanOption(ExtractMethodOptions.DontPutOutOrRefOnStruct); }
-            set { SetBooleanOption(ExtractMethodOptions.DontPutOutOrRefOnStruct, value); }
+            get { return GetBooleanOption(ExtractMethodOptions.Metadata.DontPutOutOrRefOnStruct); }
+            set { SetBooleanOption(ExtractMethodOptions.Metadata.DontPutOutOrRefOnStruct, value); }
         }
     }
 }
diff --git a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb
index 9855802da5742..b9ff70af91605 100644
--- a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb
+++ b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb
@@ -130,7 +130,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Options
             BindToOption(Editor_color_scheme, ColorSchemeOptions.ColorScheme)
 
             ' Extract method
-            BindToOption(DontPutOutOrRefOnStruct, ExtractMethodOptions.DontPutOutOrRefOnStruct, LanguageNames.VisualBasic)
+            BindToOption(DontPutOutOrRefOnStruct, ExtractMethodOptions.Metadata.DontPutOutOrRefOnStruct, LanguageNames.VisualBasic)
 
             ' Implement Interface or Abstract Class
             BindToOption(with_other_members_of_the_same_kind, ImplementTypeOptions.Metadata.InsertionBehavior, ImplementTypeInsertionBehavior.WithOtherMembersOfTheSameKind, LanguageNames.VisualBasic)
diff --git a/src/VisualStudio/VisualBasic/Impl/Options/AutomationObject/AutomationObject.ExtractMethod.vb b/src/VisualStudio/VisualBasic/Impl/Options/AutomationObject/AutomationObject.ExtractMethod.vb
index 866055c4dd7da..39a900af250ae 100644
--- a/src/VisualStudio/VisualBasic/Impl/Options/AutomationObject/AutomationObject.ExtractMethod.vb
+++ b/src/VisualStudio/VisualBasic/Impl/Options/AutomationObject/AutomationObject.ExtractMethod.vb
@@ -8,19 +8,19 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Options
     Partial Public Class AutomationObject
         Public Property ExtractMethod_AllowBestEffort As Boolean
             Get
-                Return GetBooleanOption(ExtractMethodOptions.AllowBestEffort)
+                Return GetBooleanOption(ExtractMethodPresentationOptions.AllowBestEffort)
             End Get
             Set(value As Boolean)
-                SetBooleanOption(ExtractMethodOptions.AllowBestEffort, value)
+                SetBooleanOption(ExtractMethodPresentationOptions.AllowBestEffort, value)
             End Set
         End Property
 
         Public Property ExtractMethod_DoNotPutOutOrRefOnStruct As Boolean
             Get
-                Return GetBooleanOption(ExtractMethodOptions.DontPutOutOrRefOnStruct)
+                Return GetBooleanOption(ExtractMethodOptions.Metadata.DontPutOutOrRefOnStruct)
             End Get
             Set(value As Boolean)
-                SetBooleanOption(ExtractMethodOptions.DontPutOutOrRefOnStruct, value)
+                SetBooleanOption(ExtractMethodOptions.Metadata.DontPutOutOrRefOnStruct, value)
             End Set
         End Property
     End Class

From 5759391a69c30a83756a119bc3241ca8f5aca3c3 Mon Sep 17 00:00:00 2001
From: Jason Malinowski <jason.malinowski@microsoft.com>
Date: Tue, 4 Jan 2022 18:09:05 -0800
Subject: [PATCH 228/444] Upgrade Microsoft.VisualStudio.Telemetry to 16.4.22

This brings updated support for collecting heaps when faults happen. We
use the VS-shipped version in-proc and our ServiceHub process that runs
on .NET Framework, but we still need to upgrade this for .NET Core-based
ServiceHub processes.
---
 eng/Versions.props | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/eng/Versions.props b/eng/Versions.props
index f0ffd74e8c5fe..73156c2224466 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -93,7 +93,7 @@
     <MicrosoftCodeAnalysisVisualBasicCodeStyleVersion>$(CodeStyleAnalyzerVersion)</MicrosoftCodeAnalysisVisualBasicCodeStyleVersion>
     <MicrosoftCodeAnalysisAnalyzerUtilitiesVersion>3.3.0</MicrosoftCodeAnalysisAnalyzerUtilitiesVersion>
     <MicrosoftCodeAnalysisPerformanceSensitiveAnalyzersVersion>$(RoslynDiagnosticsNugetPackageVersion)</MicrosoftCodeAnalysisPerformanceSensitiveAnalyzersVersion>
-    <MicrosoftCSharpVersion>4.3.0</MicrosoftCSharpVersion>
+    <MicrosoftCSharpVersion>4.7.0</MicrosoftCSharpVersion>
     <MicrosoftDevDivOptimizationDataPowerShellVersion>1.0.339</MicrosoftDevDivOptimizationDataPowerShellVersion>
     <MicrosoftDiagnosticsRuntimeVersion>0.8.31-beta</MicrosoftDiagnosticsRuntimeVersion>
     <MicrosoftDiagnosticsTracingTraceEventVersion>1.0.35</MicrosoftDiagnosticsTracingTraceEventVersion>
@@ -166,13 +166,13 @@
     <MicrosoftVisualStudioProgressionInterfacesVersion>15.8.27812-alpha</MicrosoftVisualStudioProgressionInterfacesVersion>
     <MicrosoftVisualStudioProjectSystemVersion>17.0.77-pre-g62a6cb5699</MicrosoftVisualStudioProjectSystemVersion>
     <MicrosoftVisualStudioProjectSystemManagedVersion>2.3.6152103</MicrosoftVisualStudioProjectSystemManagedVersion>
-    <MicrosoftVisualStudioRemoteControlVersion>16.3.41</MicrosoftVisualStudioRemoteControlVersion>
+    <MicrosoftVisualStudioRemoteControlVersion>16.3.44</MicrosoftVisualStudioRemoteControlVersion>
     <MicrosoftVisualStudioSDKAnalyzersVersion>16.10.10</MicrosoftVisualStudioSDKAnalyzersVersion>
     <MicrosoftVisualStudioSetupConfigurationInteropVersion>1.16.30</MicrosoftVisualStudioSetupConfigurationInteropVersion>
     <MicrosoftVisualStudioShell150Version>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftVisualStudioShell150Version>
     <MicrosoftVisualStudioShellFrameworkVersion>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftVisualStudioShellFrameworkVersion>
     <MicrosoftVisualStudioShellDesignVersion>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftVisualStudioShellDesignVersion>
-    <MicrosoftVisualStudioTelemetryVersion>16.3.211</MicrosoftVisualStudioTelemetryVersion>
+    <MicrosoftVisualStudioTelemetryVersion>16.4.22</MicrosoftVisualStudioTelemetryVersion>
     <MicrosoftVisualStudioTemplateWizardInterfaceVersion>8.0.0.0-alpha</MicrosoftVisualStudioTemplateWizardInterfaceVersion>
     <MicrosoftVisualStudioTextDataVersion>$(VisualStudioEditorNewPackagesVersion)</MicrosoftVisualStudioTextDataVersion>
     <MicrosoftVisualStudioTextInternalVersion>$(VisualStudioEditorNewPackagesVersion)</MicrosoftVisualStudioTextInternalVersion>

From 513b828dcab2e9185382410e0283686e11879bf3 Mon Sep 17 00:00:00 2001
From: David Wengier <david.wengier@microsoft.com>
Date: Wed, 5 Jan 2022 13:26:17 +1100
Subject: [PATCH 229/444] SourceLink quality of life improvements (#58209)

---
 .../AbstractPdbSourceDocumentTests.cs         |  15 ++-
 .../PdbFileLocatorServiceTests.cs             |  14 +-
 .../PdbSourceDocumentLoaderServiceTests.cs    |   8 +-
 .../PdbSourceDocumentTests.cs                 |  22 ++--
 .../TestSourceLinkService.cs                  |  12 +-
 .../Core/Portable/FeaturesResources.resx      |  74 +++++++++++
 .../IPdbFileLocatorService.cs                 |   2 +-
 .../IPdbSourceDocumentLoaderService.cs        |   7 +-
 .../IPdbSourceDocumentLogger.cs               |  15 ++-
 .../PdbSourceDocument/ISourceLinkService.cs   |  12 +-
 .../PdbFileLocatorService.cs                  |  81 ++++++++----
 .../PdbSourceDocumentLoaderService.cs         |  77 ++++++++---
 ...rceDocumentMetadataAsSourceFileProvider.cs |  44 +++++--
 .../PdbSourceDocument/TelemetryMessage.cs     |  46 +++++++
 .../Portable/xlf/FeaturesResources.cs.xlf     | 120 ++++++++++++++++++
 .../Portable/xlf/FeaturesResources.de.xlf     | 120 ++++++++++++++++++
 .../Portable/xlf/FeaturesResources.es.xlf     | 120 ++++++++++++++++++
 .../Portable/xlf/FeaturesResources.fr.xlf     | 120 ++++++++++++++++++
 .../Portable/xlf/FeaturesResources.it.xlf     | 120 ++++++++++++++++++
 .../Portable/xlf/FeaturesResources.ja.xlf     | 120 ++++++++++++++++++
 .../Portable/xlf/FeaturesResources.ko.xlf     | 120 ++++++++++++++++++
 .../Portable/xlf/FeaturesResources.pl.xlf     | 120 ++++++++++++++++++
 .../Portable/xlf/FeaturesResources.pt-BR.xlf  | 120 ++++++++++++++++++
 .../Portable/xlf/FeaturesResources.ru.xlf     | 120 ++++++++++++++++++
 .../Portable/xlf/FeaturesResources.tr.xlf     | 120 ++++++++++++++++++
 .../xlf/FeaturesResources.zh-Hans.xlf         | 120 ++++++++++++++++++
 .../xlf/FeaturesResources.zh-Hant.xlf         | 120 ++++++++++++++++++
 .../PdbSourceDocumentOutputWindowLogger.cs    | 119 +++++++++++++++++
 .../PdbSourceDocument/SourceLinkService.cs    |  36 ++++--
 .../Core/Def/ServicesVSResources.resx         |   3 +
 .../Core/Def/xlf/ServicesVSResources.cs.xlf   |   5 +
 .../Core/Def/xlf/ServicesVSResources.de.xlf   |   5 +
 .../Core/Def/xlf/ServicesVSResources.es.xlf   |   5 +
 .../Core/Def/xlf/ServicesVSResources.fr.xlf   |   5 +
 .../Core/Def/xlf/ServicesVSResources.it.xlf   |   5 +
 .../Core/Def/xlf/ServicesVSResources.ja.xlf   |   5 +
 .../Core/Def/xlf/ServicesVSResources.ko.xlf   |   5 +
 .../Core/Def/xlf/ServicesVSResources.pl.xlf   |   5 +
 .../Def/xlf/ServicesVSResources.pt-BR.xlf     |   5 +
 .../Core/Def/xlf/ServicesVSResources.ru.xlf   |   5 +
 .../Core/Def/xlf/ServicesVSResources.tr.xlf   |   5 +
 .../Def/xlf/ServicesVSResources.zh-Hans.xlf   |   5 +
 .../Def/xlf/ServicesVSResources.zh-Hant.xlf   |   5 +
 .../Compiler/Core/Log/FunctionId.cs           |   2 +
 44 files changed, 2100 insertions(+), 114 deletions(-)
 create mode 100644 src/Features/Core/Portable/PdbSourceDocument/TelemetryMessage.cs
 create mode 100644 src/VisualStudio/Core/Def/PdbSourceDocument/PdbSourceDocumentOutputWindowLogger.cs

diff --git a/src/EditorFeatures/CSharpTest/PdbSourceDocument/AbstractPdbSourceDocumentTests.cs b/src/EditorFeatures/CSharpTest/PdbSourceDocument/AbstractPdbSourceDocumentTests.cs
index 4cc1bff1419f7..3655a1a69ac16 100644
--- a/src/EditorFeatures/CSharpTest/PdbSourceDocument/AbstractPdbSourceDocumentTests.cs
+++ b/src/EditorFeatures/CSharpTest/PdbSourceDocument/AbstractPdbSourceDocumentTests.cs
@@ -96,17 +96,18 @@ protected static async Task TestAsync(
                 buildReferenceAssembly,
                 windowsPdb: false);
 
-            await GenerateFileAndVerifyAsync(project, symbol, source, expectedSpan, expectNullResult);
+            await GenerateFileAndVerifyAsync(project, symbol, sourceLocation, source, expectedSpan, expectNullResult);
         }
 
         protected static async Task GenerateFileAndVerifyAsync(
             Project project,
             ISymbol symbol,
+            Location sourceLocation,
             string expected,
             Text.TextSpan expectedSpan,
             bool expectNullResult)
         {
-            var (actual, actualSpan) = await GetGeneratedSourceTextAsync(project, symbol, expectNullResult);
+            var (actual, actualSpan) = await GetGeneratedSourceTextAsync(project, symbol, sourceLocation, expectNullResult);
 
             if (actual is null)
                 return;
@@ -121,6 +122,7 @@ protected static async Task GenerateFileAndVerifyAsync(
         protected static async Task<(SourceText?, TextSpan)> GetGeneratedSourceTextAsync(
             Project project,
             ISymbol symbol,
+            Location sourceLocation,
             bool expectNullResult)
         {
             using var workspace = (TestWorkspace)project.Solution.Workspace;
@@ -140,6 +142,15 @@ protected static async Task GenerateFileAndVerifyAsync(
                     Assert.NotSame(NullResultMetadataAsSourceFileProvider.NullResult, file);
                 }
 
+                if (sourceLocation == Location.OnDisk)
+                {
+                    Assert.True(file.DocumentTitle.Contains($"[{FeaturesResources.external}]"));
+                }
+                else
+                {
+                    Assert.True(file.DocumentTitle.Contains($"[{FeaturesResources.embedded}]"));
+                }
+
                 AssertEx.NotNull(file, $"No source document was found in the pdb for the symbol.");
 
                 var masWorkspace = service.TryGetWorkspace();
diff --git a/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbFileLocatorServiceTests.cs b/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbFileLocatorServiceTests.cs
index f7e9cf1d44843..ee1af8cbb24f0 100644
--- a/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbFileLocatorServiceTests.cs
+++ b/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbFileLocatorServiceTests.cs
@@ -34,9 +34,9 @@ await RunTestAsync(async path =>
                 File.Move(GetPdbPath(path), pdbFilePath);
 
                 var sourceLinkService = new TestSourceLinkService(pdbFilePath: pdbFilePath);
-                var service = new PdbFileLocatorService(sourceLinkService);
+                var service = new PdbFileLocatorService(sourceLinkService, logger: null);
 
-                using var result = await service.GetDocumentDebugInfoReaderAsync(GetDllPath(path), logger: null, CancellationToken.None);
+                using var result = await service.GetDocumentDebugInfoReaderAsync(GetDllPath(path), new TelemetryMessage(CancellationToken.None), CancellationToken.None);
 
                 Assert.NotNull(result);
             });
@@ -63,10 +63,10 @@ await RunTestAsync(async path =>
                 var pdbFilePath = Path.Combine(path, "SourceLink.pdb");
                 File.Move(GetPdbPath(path), pdbFilePath);
 
-                var sourceLinkService = new TestSourceLinkService(pdbFilePath: pdbFilePath, isPortablePdb: false);
-                var service = new PdbFileLocatorService(sourceLinkService);
+                var sourceLinkService = new TestSourceLinkService(pdbFilePath);
+                var service = new PdbFileLocatorService(sourceLinkService, logger: null);
 
-                using var result = await service.GetDocumentDebugInfoReaderAsync(GetDllPath(path), logger: null, CancellationToken.None);
+                using var result = await service.GetDocumentDebugInfoReaderAsync(GetDllPath(path), new TelemetryMessage(CancellationToken.None), CancellationToken.None);
 
                 Assert.Null(result);
             });
@@ -92,9 +92,9 @@ await RunTestAsync(async path =>
                 File.Move(GetPdbPath(path), pdbFilePath);
 
                 var sourceLinkService = new TestSourceLinkService(pdbFilePath: null);
-                var service = new PdbFileLocatorService(sourceLinkService);
+                var service = new PdbFileLocatorService(sourceLinkService, logger: null);
 
-                using var result = await service.GetDocumentDebugInfoReaderAsync(GetDllPath(path), logger: null, CancellationToken.None);
+                using var result = await service.GetDocumentDebugInfoReaderAsync(GetDllPath(path), new TelemetryMessage(CancellationToken.None), CancellationToken.None);
 
                 Assert.Null(result);
             });
diff --git a/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbSourceDocumentLoaderServiceTests.cs b/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbSourceDocumentLoaderServiceTests.cs
index 844e8b58681d1..aad7f09787ae7 100644
--- a/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbSourceDocumentLoaderServiceTests.cs
+++ b/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbSourceDocumentLoaderServiceTests.cs
@@ -38,13 +38,13 @@ await RunTestAsync(async path =>
                 File.Move(GetSourceFilePath(path), sourceFilePath);
 
                 var sourceLinkService = new Lazy<ISourceLinkService?>(() => new TestSourceLinkService(sourceFilePath: sourceFilePath));
-                var service = new PdbSourceDocumentLoaderService(sourceLinkService);
+                var service = new PdbSourceDocumentLoaderService(sourceLinkService, logger: null);
 
                 using var hash = SHA256.Create();
                 var fileHash = hash.ComputeHash(File.ReadAllBytes(sourceFilePath));
 
                 var sourceDocument = new SourceDocument("goo.cs", Text.SourceHashAlgorithm.Sha256, fileHash.ToImmutableArray(), null, "https://sourcelink");
-                var result = await service.LoadSourceDocumentAsync(path, sourceDocument, Encoding.UTF8, logger: null, CancellationToken.None);
+                var result = await service.LoadSourceDocumentAsync(path, sourceDocument, Encoding.UTF8, new TelemetryMessage(CancellationToken.None), CancellationToken.None);
 
                 Assert.NotNull(result);
                 Assert.Equal(sourceFilePath, result!.FilePath);
@@ -71,10 +71,10 @@ await RunTestAsync(async path =>
                 File.Move(GetSourceFilePath(path), sourceFilePath);
 
                 var sourceLinkService = new Lazy<ISourceLinkService?>(() => new TestSourceLinkService(sourceFilePath: sourceFilePath));
-                var service = new PdbSourceDocumentLoaderService(sourceLinkService);
+                var service = new PdbSourceDocumentLoaderService(sourceLinkService, logger: null);
 
                 var sourceDocument = new SourceDocument("goo.cs", Text.SourceHashAlgorithm.None, default, null, SourceLinkUrl: null);
-                var result = await service.LoadSourceDocumentAsync(path, sourceDocument, Encoding.UTF8, logger: null, CancellationToken.None);
+                var result = await service.LoadSourceDocumentAsync(path, sourceDocument, Encoding.UTF8, new TelemetryMessage(CancellationToken.None), CancellationToken.None);
 
                 Assert.Null(result);
             });
diff --git a/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbSourceDocumentTests.cs b/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbSourceDocumentTests.cs
index 16c13ec0302a8..81549ce6025f8 100644
--- a/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbSourceDocumentTests.cs
+++ b/src/EditorFeatures/CSharpTest/PdbSourceDocument/PdbSourceDocumentTests.cs
@@ -401,7 +401,7 @@ await RunTestAsync(async path =>
                 // Now delete the PDB
                 File.Delete(GetPdbPath(path));
 
-                await GenerateFileAndVerifyAsync(project, symbol, source, expectedSpan, expectNullResult: true);
+                await GenerateFileAndVerifyAsync(project, symbol, Location.OnDisk, source, expectedSpan, expectNullResult: true);
             });
         }
 
@@ -423,7 +423,7 @@ await RunTestAsync(async path =>
                 // Now delete the DLL
                 File.Delete(GetDllPath(path));
 
-                await GenerateFileAndVerifyAsync(project, symbol, source, expectedSpan, expectNullResult: true);
+                await GenerateFileAndVerifyAsync(project, symbol, Location.OnDisk, source, expectedSpan, expectNullResult: true);
             });
         }
 
@@ -444,7 +444,7 @@ await RunTestAsync(async path =>
                 // Now delete the source
                 File.Delete(GetSourceFilePath(path));
 
-                await GenerateFileAndVerifyAsync(project, symbol, source, expectedSpan, expectNullResult: true);
+                await GenerateFileAndVerifyAsync(project, symbol, Location.OnDisk, source, expectedSpan, expectNullResult: true);
             });
         }
 
@@ -463,7 +463,7 @@ await RunTestAsync(async path =>
                 var (project, symbol) = await CompileAndFindSymbolAsync(path, Location.OnDisk, Location.OnDisk, metadataSource, c => c.GetMember("C.E"), windowsPdb: true);
 
                 //TODO: This should not be a null result: https://github.com/dotnet/roslyn/issues/55834
-                await GenerateFileAndVerifyAsync(project, symbol, source, expectedSpan, expectNullResult: true);
+                await GenerateFileAndVerifyAsync(project, symbol, Location.OnDisk, source, expectedSpan, expectNullResult: true);
             });
         }
 
@@ -485,7 +485,7 @@ await RunTestAsync(async path =>
                 // Now make the PDB a zero byte file
                 File.WriteAllBytes(GetPdbPath(path), new byte[0]);
 
-                await GenerateFileAndVerifyAsync(project, symbol, source, expectedSpan, expectNullResult: true);
+                await GenerateFileAndVerifyAsync(project, symbol, Location.OnDisk, source, expectedSpan, expectNullResult: true);
             });
         }
 
@@ -509,7 +509,7 @@ await RunTestAsync(async path =>
                 var corruptPdb = new byte[] { 66, 83, 74, 66, 68, 87 };
                 File.WriteAllBytes(GetPdbPath(path), corruptPdb);
 
-                await GenerateFileAndVerifyAsync(project, symbol, source, expectedSpan, expectNullResult: true);
+                await GenerateFileAndVerifyAsync(project, symbol, Location.OnDisk, source, expectedSpan, expectNullResult: true);
             });
         }
 
@@ -545,7 +545,7 @@ await RunTestAsync(async path =>
                 File.Delete(pdbFilePath);
                 File.Move(archivePdbFilePath, pdbFilePath);
 
-                await GenerateFileAndVerifyAsync(project, symbol, source1, expectedSpan, expectNullResult: true);
+                await GenerateFileAndVerifyAsync(project, symbol, Location.OnDisk, source1, expectedSpan, expectNullResult: true);
             });
         }
 
@@ -573,7 +573,7 @@ await RunTestAsync(async path =>
 
                 File.WriteAllText(GetSourceFilePath(path), source2, Encoding.UTF8);
 
-                await GenerateFileAndVerifyAsync(project, symbol, metadataSource, expectedSpan, expectNullResult: true);
+                await GenerateFileAndVerifyAsync(project, symbol, Location.OnDisk, metadataSource, expectedSpan, expectNullResult: true);
             });
         }
 
@@ -609,7 +609,7 @@ await RunTestAsync(async path =>
 
                 var (project, symbol) = await CompileAndFindSymbolAsync(path, pdbLocation, Location.Embedded, encodedSourceText, c => c.GetMember("C.E"));
 
-                var (actualText, _) = await GetGeneratedSourceTextAsync(project, symbol, expectNullResult: false);
+                var (actualText, _) = await GetGeneratedSourceTextAsync(project, symbol, Location.Embedded, expectNullResult: false);
 
                 AssertEx.NotNull(actualText);
                 AssertEx.NotNull(actualText.Encoding);
@@ -638,7 +638,7 @@ await RunTestAsync(async path =>
 
                 var (project, symbol) = await CompileAndFindSymbolAsync(path, pdbLocation, Location.Embedded, encodedSourceText, c => c.GetMember("C.E"));
 
-                var (actualText, _) = await GetGeneratedSourceTextAsync(project, symbol, expectNullResult: false);
+                var (actualText, _) = await GetGeneratedSourceTextAsync(project, symbol, Location.Embedded, expectNullResult: false);
 
                 AssertEx.NotNull(actualText);
                 AssertEx.NotNull(actualText.Encoding);
@@ -667,7 +667,7 @@ await RunTestAsync(async path =>
 
                 var (project, symbol) = await CompileAndFindSymbolAsync(path, pdbLocation, Location.Embedded, encodedSourceText, c => c.GetMember("C.E"), fallbackEncoding: encoding);
 
-                var (actualText, _) = await GetGeneratedSourceTextAsync(project, symbol, expectNullResult: false);
+                var (actualText, _) = await GetGeneratedSourceTextAsync(project, symbol, Location.Embedded, expectNullResult: false);
 
                 AssertEx.NotNull(actualText);
                 AssertEx.NotNull(actualText.Encoding);
diff --git a/src/EditorFeatures/CSharpTest/PdbSourceDocument/TestSourceLinkService.cs b/src/EditorFeatures/CSharpTest/PdbSourceDocument/TestSourceLinkService.cs
index 87918089e5ac7..6cc3573b5b292 100644
--- a/src/EditorFeatures/CSharpTest/PdbSourceDocument/TestSourceLinkService.cs
+++ b/src/EditorFeatures/CSharpTest/PdbSourceDocument/TestSourceLinkService.cs
@@ -13,33 +13,31 @@ internal class TestSourceLinkService : ISourceLinkService
     {
         private readonly string? _pdbFilePath;
         private readonly string? _sourceFilePath;
-        private readonly bool _isPortablePdb;
 
-        public TestSourceLinkService(string? pdbFilePath = null, string? sourceFilePath = null, bool isPortablePdb = true)
+        public TestSourceLinkService(string? pdbFilePath = null, string? sourceFilePath = null)
         {
             _pdbFilePath = pdbFilePath;
             _sourceFilePath = sourceFilePath;
-            _isPortablePdb = isPortablePdb;
         }
 
-        public Task<PdbFilePathResult?> GetPdbFilePathAsync(string dllPath, PEReader peReader, IPdbSourceDocumentLogger? logger, CancellationToken cancellationToken)
+        public Task<PdbFilePathResult?> GetPdbFilePathAsync(string dllPath, PEReader peReader, CancellationToken cancellationToken)
         {
             if (_pdbFilePath is null)
             {
                 return Task.FromResult<PdbFilePathResult?>(null);
             }
 
-            return Task.FromResult<PdbFilePathResult?>(new PdbFilePathResult(_pdbFilePath, "status", Log: null, _isPortablePdb));
+            return Task.FromResult<PdbFilePathResult?>(new PdbFilePathResult(_pdbFilePath));
         }
 
-        public Task<SourceFilePathResult?> GetSourceFilePathAsync(string url, string relativePath, IPdbSourceDocumentLogger? logger, CancellationToken cancellationToken)
+        public Task<SourceFilePathResult?> GetSourceFilePathAsync(string url, string relativePath, CancellationToken cancellationToken)
         {
             if (_sourceFilePath is null)
             {
                 return Task.FromResult<SourceFilePathResult?>(null);
             }
 
-            return Task.FromResult<SourceFilePathResult?>(new SourceFilePathResult(_sourceFilePath, Log: null));
+            return Task.FromResult<SourceFilePathResult?>(new SourceFilePathResult(_sourceFilePath));
         }
     }
 }
diff --git a/src/Features/Core/Portable/FeaturesResources.resx b/src/Features/Core/Portable/FeaturesResources.resx
index cc83c35a35680..03929436c8985 100644
--- a/src/Features/Core/Portable/FeaturesResources.resx
+++ b/src/Features/Core/Portable/FeaturesResources.resx
@@ -2948,4 +2948,78 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
   <data name="Silent" xml:space="preserve">
     <value>Silent</value>
   </data>
+  <data name="embedded" xml:space="preserve">
+    <value>embedded</value>
+    <comment>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</comment>
+  </data>
+  <data name="external" xml:space="preserve">
+    <value>external</value>
+    <comment>External means "external source", meaning source files that are not part of the current solution</comment>
+  </data>
+  <data name="Could_not_find_PDB_on_disk_or_embedded" xml:space="preserve">
+    <value>Could not find portable PDB on disk or embedded.</value>
+  </data>
+  <data name="Error_reading_PDB_0" xml:space="preserve">
+    <value>Error reading PDB: '{0}'</value>
+  </data>
+  <data name="Found_embedded_PDB_file" xml:space="preserve">
+    <value>Found embedded PDB file.</value>
+  </data>
+  <data name="Found_PDB_file_at_0" xml:space="preserve">
+    <value>Found PDB file at '{0}'</value>
+  </data>
+  <data name="Found_PDB_on_symbol_server" xml:space="preserve">
+    <value>Found PDB on symbol server.</value>
+  </data>
+  <data name="Found_PDB_on_symbol_server_but_could_not_read_file" xml:space="preserve">
+    <value>Found PDB on symbol server but could not read file.</value>
+  </data>
+  <data name="Navigating_to_symbol_0_from_1" xml:space="preserve">
+    <value>Navigating to symbol '{0}' from '{1}'.</value>
+  </data>
+  <data name="No_source_document_info_found_in_PDB" xml:space="preserve">
+    <value>No source document info found in PDB.</value>
+  </data>
+  <data name="Source_code_language_information_was_not_found_in_PDB" xml:space="preserve">
+    <value>Source code language information was not found in PDB.</value>
+  </data>
+  <data name="Source_is_a_reference_assembly" xml:space="preserve">
+    <value>Source is a reference assembly, not enough information to find PDB.</value>
+  </data>
+  <data name="_0_found_in_embedded_PDB" xml:space="preserve">
+    <value>'{0}' found in embedded PDB.</value>
+  </data>
+  <data name="_0_found_in_embedded_PDB_but_checksum_failed" xml:space="preserve">
+    <value>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</value>
+  </data>
+  <data name="_0_found_in_embedded_PDB_but_could_not_write_file_1" xml:space="preserve">
+    <value>'{0}' found in embedded PDB but could not write to temp file: '{1}'</value>
+  </data>
+  <data name="_0_found_in_embedded_PDB_cached_source_file" xml:space="preserve">
+    <value>'{0}' found in embedded PDB and found cached source file.</value>
+  </data>
+  <data name="_0_found_via_SourceLink" xml:space="preserve">
+    <value>'{0}' found via SourceLink.</value>
+  </data>
+  <data name="_0_found_via_SourceLink_but_couldnt_read_file" xml:space="preserve">
+    <value>'{0}' found via SourceLink but couldn't read temp file.</value>
+  </data>
+  <data name="_0_found_in_original_location" xml:space="preserve">
+    <value>'{0}' found in original location.</value>
+  </data>
+  <data name="_0_found_in_original_location_but_checksum_failed" xml:space="preserve">
+    <value>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</value>
+  </data>
+  <data name="Could_not_find_PDB_on_disk_or_embedded_or_server" xml:space="preserve">
+    <value>Could not find PDB on disk, or embedded, or on a symbol server.</value>
+  </data>
+  <data name="Timeout_SourceLink" xml:space="preserve">
+    <value>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</value>
+  </data>
+  <data name="Timeout_symbol_server" xml:space="preserve">
+    <value>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</value>
+  </data>
+  <data name="Symbol_found_in_assembly_path_0" xml:space="preserve">
+    <value>Symbol found in assembly path '{0}'</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/Features/Core/Portable/PdbSourceDocument/IPdbFileLocatorService.cs b/src/Features/Core/Portable/PdbSourceDocument/IPdbFileLocatorService.cs
index a1806acded3a2..d3704df15e292 100644
--- a/src/Features/Core/Portable/PdbSourceDocument/IPdbFileLocatorService.cs
+++ b/src/Features/Core/Portable/PdbSourceDocument/IPdbFileLocatorService.cs
@@ -9,6 +9,6 @@ namespace Microsoft.CodeAnalysis.PdbSourceDocument
 {
     internal interface IPdbFileLocatorService
     {
-        Task<DocumentDebugInfoReader?> GetDocumentDebugInfoReaderAsync(string dllPath, IPdbSourceDocumentLogger? logger, CancellationToken cancellationToken);
+        Task<DocumentDebugInfoReader?> GetDocumentDebugInfoReaderAsync(string dllPath, TelemetryMessage telemetry, CancellationToken cancellationToken);
     }
 }
diff --git a/src/Features/Core/Portable/PdbSourceDocument/IPdbSourceDocumentLoaderService.cs b/src/Features/Core/Portable/PdbSourceDocument/IPdbSourceDocumentLoaderService.cs
index f3b27a12a552f..f58661089f7e4 100644
--- a/src/Features/Core/Portable/PdbSourceDocument/IPdbSourceDocumentLoaderService.cs
+++ b/src/Features/Core/Portable/PdbSourceDocument/IPdbSourceDocumentLoaderService.cs
@@ -10,8 +10,11 @@ namespace Microsoft.CodeAnalysis.PdbSourceDocument
 {
     internal interface IPdbSourceDocumentLoaderService
     {
-        Task<SourceFileInfo?> LoadSourceDocumentAsync(string tempFilePath, SourceDocument sourceDocument, Encoding encoding, IPdbSourceDocumentLogger? logger, CancellationToken cancellationToken);
+        Task<SourceFileInfo?> LoadSourceDocumentAsync(string tempFilePath, SourceDocument sourceDocument, Encoding encoding, TelemetryMessage telemetry, CancellationToken cancellationToken);
     }
 
-    internal sealed record SourceFileInfo(string FilePath, TextLoader Loader);
+    /// <param name="FilePath">The path to the source file on disk</param>
+    /// <param name="SourceDescription">Localized description of where the file came from, for the document tab, eg. Source Link, Embedded, On Disk</param>
+    /// <param name="Loader">The text loader to use</param>
+    internal sealed record SourceFileInfo(string FilePath, string SourceDescription, TextLoader Loader);
 }
diff --git a/src/Features/Core/Portable/PdbSourceDocument/IPdbSourceDocumentLogger.cs b/src/Features/Core/Portable/PdbSourceDocument/IPdbSourceDocumentLogger.cs
index 0735a85ad05a6..f29569eb36f25 100644
--- a/src/Features/Core/Portable/PdbSourceDocument/IPdbSourceDocumentLogger.cs
+++ b/src/Features/Core/Portable/PdbSourceDocument/IPdbSourceDocumentLogger.cs
@@ -2,9 +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.Text;
+using System.Threading.Tasks;
 
 namespace Microsoft.CodeAnalysis.PdbSourceDocument
 {
@@ -14,7 +12,16 @@ namespace Microsoft.CodeAnalysis.PdbSourceDocument
     /// </summary>
     internal interface IPdbSourceDocumentLogger
     {
-        void Clear();
+        Task ClearAsync();
         void Log(string message);
     }
+
+    internal static class PdbSourceDocumentLoggerExtensions
+    {
+        public static void Log(this IPdbSourceDocumentLogger logger, string message, object arg0)
+            => logger.Log(string.Format(message, arg0));
+
+        public static void Log(this IPdbSourceDocumentLogger logger, string message, object arg0, object arg1)
+            => logger.Log(string.Format(message, arg0, arg1));
+    }
 }
diff --git a/src/Features/Core/Portable/PdbSourceDocument/ISourceLinkService.cs b/src/Features/Core/Portable/PdbSourceDocument/ISourceLinkService.cs
index b736048a9a8e8..b22dde390b81d 100644
--- a/src/Features/Core/Portable/PdbSourceDocument/ISourceLinkService.cs
+++ b/src/Features/Core/Portable/PdbSourceDocument/ISourceLinkService.cs
@@ -10,9 +10,9 @@ namespace Microsoft.CodeAnalysis.PdbSourceDocument
 {
     internal interface ISourceLinkService
     {
-        Task<SourceFilePathResult?> GetSourceFilePathAsync(string url, string relativePath, IPdbSourceDocumentLogger? logger, CancellationToken cancellationToken);
+        Task<SourceFilePathResult?> GetSourceFilePathAsync(string url, string relativePath, CancellationToken cancellationToken);
 
-        Task<PdbFilePathResult?> GetPdbFilePathAsync(string dllPath, PEReader peReader, IPdbSourceDocumentLogger? logger, CancellationToken cancellationToken);
+        Task<PdbFilePathResult?> GetPdbFilePathAsync(string dllPath, PEReader peReader, CancellationToken cancellationToken);
     }
 
     // The following types mirror types in Microsoft.VisualStudio.Debugger.Contracts which cannot be referenced at this layer
@@ -21,15 +21,11 @@ internal interface ISourceLinkService
     /// The result of findding a PDB file
     /// </summary>
     /// <param name="PdbFilePath">The path to the PDB file in the debugger cache</param>
-    /// <param name="Status">Status of the operation</param>
-    /// <param name="Log">Any log messages the debugger wrote during the operation</param>
-    /// <param name="IsPortablePdb">Whether the PDB found is portable</param>
-    internal record PdbFilePathResult(string PdbFilePath, string Status, string? Log, bool IsPortablePdb);
+    internal record PdbFilePathResult(string PdbFilePath);
 
     /// <summary>
     /// The result of finding a source file via SourceLink
     /// </summary>
     /// <param name="SourceFilePath">The path to the source file in the debugger cache</param>
-    /// <param name="Log">Any log messages the debugger wrote during the operation</param>
-    internal record SourceFilePathResult(string SourceFilePath, string? Log);
+    internal record SourceFilePathResult(string SourceFilePath);
 }
diff --git a/src/Features/Core/Portable/PdbSourceDocument/PdbFileLocatorService.cs b/src/Features/Core/Portable/PdbSourceDocument/PdbFileLocatorService.cs
index e9e0f09816e61..a38b0e4ab8a7a 100644
--- a/src/Features/Core/Portable/PdbSourceDocument/PdbFileLocatorService.cs
+++ b/src/Features/Core/Portable/PdbSourceDocument/PdbFileLocatorService.cs
@@ -10,7 +10,6 @@
 using System.Reflection.PortableExecutable;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Shared.Utilities;
 using Roslyn.Utilities;
 
@@ -22,15 +21,19 @@ internal sealed class PdbFileLocatorService : IPdbFileLocatorService
         private const int SymbolLocatorTimeout = 2000;
 
         private readonly ISourceLinkService? _sourceLinkService;
+        private readonly IPdbSourceDocumentLogger? _logger;
 
         [ImportingConstructor]
         [SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code")]
-        public PdbFileLocatorService([Import(AllowDefault = true)] ISourceLinkService? sourceLinkService)
+        public PdbFileLocatorService(
+            [Import(AllowDefault = true)] ISourceLinkService? sourceLinkService,
+            [Import(AllowDefault = true)] IPdbSourceDocumentLogger? logger)
         {
             _sourceLinkService = sourceLinkService;
+            _logger = logger;
         }
 
-        public async Task<DocumentDebugInfoReader?> GetDocumentDebugInfoReaderAsync(string dllPath, IPdbSourceDocumentLogger? logger, CancellationToken cancellationToken)
+        public async Task<DocumentDebugInfoReader?> GetDocumentDebugInfoReaderAsync(string dllPath, TelemetryMessage telemetry, CancellationToken cancellationToken)
         {
             var dllStream = IOUtilities.PerformIO(() => File.OpenRead(dllPath));
             if (dllStream is null)
@@ -42,47 +45,73 @@ public PdbFileLocatorService([Import(AllowDefault = true)] ISourceLinkService? s
             try
             {
                 // Try to load the pdb file from disk, or embedded
-                if (peReader.TryOpenAssociatedPortablePdb(dllPath, pdbPath => File.OpenRead(pdbPath), out var pdbReaderProvider, out _))
+                if (peReader.TryOpenAssociatedPortablePdb(dllPath, pdbPath => File.OpenRead(pdbPath), out var pdbReaderProvider, out var pdbFilePath))
                 {
                     Contract.ThrowIfNull(pdbReaderProvider);
 
+                    if (pdbFilePath is null)
+                    {
+                        telemetry.SetPdbSource("embedded");
+                        _logger?.Log(FeaturesResources.Found_embedded_PDB_file);
+                    }
+                    else
+                    {
+                        telemetry.SetPdbSource("ondisk");
+                        _logger?.Log(FeaturesResources.Found_PDB_file_at_0, pdbFilePath);
+                    }
+
                     result = new DocumentDebugInfoReader(peReader, pdbReaderProvider);
                 }
 
-                // Otherwise call the debugger to find the PDB from a symbol server etc.
-                if (result is null && _sourceLinkService is not null)
+                if (result is null)
                 {
-                    var delay = Task.Delay(SymbolLocatorTimeout, cancellationToken);
-                    var pdbResultTask = _sourceLinkService.GetPdbFilePathAsync(dllPath, peReader, logger, cancellationToken);
-
-                    var winner = await Task.WhenAny(pdbResultTask, delay).ConfigureAwait(false);
-
-                    if (winner == pdbResultTask)
+                    if (_sourceLinkService is null)
+                    {
+                        _logger?.Log(FeaturesResources.Could_not_find_PDB_on_disk_or_embedded);
+                    }
+                    else
                     {
-                        var pdbResult = await pdbResultTask.ConfigureAwait(false);
+                        var delay = Task.Delay(SymbolLocatorTimeout, cancellationToken);
+                        // Call the debugger to find the PDB from a symbol server etc.
+                        var pdbResultTask = _sourceLinkService.GetPdbFilePathAsync(dllPath, peReader, cancellationToken);
+
+                        var winner = await Task.WhenAny(pdbResultTask, delay).ConfigureAwait(false);
 
-                        // TODO: Support windows PDBs: https://github.com/dotnet/roslyn/issues/55834
-                        // TODO: Log results from pdbResult.Log: https://github.com/dotnet/roslyn/issues/57352
-                        if (pdbResult is not null)
+                        if (winner == pdbResultTask)
                         {
-                            pdbStream = IOUtilities.PerformIO(() => File.OpenRead(pdbResult.PdbFilePath));
-                            if (pdbStream is not null)
+                            var pdbResult = await pdbResultTask.ConfigureAwait(false);
+                            if (pdbResult is not null)
+                            {
+                                pdbStream = IOUtilities.PerformIO(() => File.OpenRead(pdbResult.PdbFilePath));
+                                if (pdbStream is not null)
+                                {
+                                    var readerProvider = MetadataReaderProvider.FromPortablePdbStream(pdbStream);
+                                    telemetry.SetPdbSource("symbolserver");
+                                    result = new DocumentDebugInfoReader(peReader, readerProvider);
+                                    _logger?.Log(FeaturesResources.Found_PDB_on_symbol_server);
+                                }
+                                else
+                                {
+                                    _logger?.Log(FeaturesResources.Found_PDB_on_symbol_server_but_could_not_read_file);
+                                }
+                            }
+                            else
                             {
-                                var readerProvider = MetadataReaderProvider.FromPortablePdbStream(pdbStream);
-                                result = new DocumentDebugInfoReader(peReader, readerProvider);
+                                _logger?.Log(FeaturesResources.Could_not_find_PDB_on_disk_or_embedded_or_server);
                             }
                         }
-                    }
-                    else
-                    {
-                        // TODO: Log the timeout: https://github.com/dotnet/roslyn/issues/57352
+                        else
+                        {
+                            telemetry.SetPdbSource("timeout");
+                            _logger?.Log(FeaturesResources.Timeout_symbol_server);
+                        }
                     }
                 }
             }
-            catch (BadImageFormatException)
+            catch (BadImageFormatException ex)
             {
                 // If the PDB is corrupt in some way we can just ignore it, and let the system fall through to another provider
-                // TODO: Log this to the output window: https://github.com/dotnet/roslyn/issues/57352
+                _logger?.Log(FeaturesResources.Error_reading_PDB_0, ex.Message);
                 result = null;
             }
             finally
diff --git a/src/Features/Core/Portable/PdbSourceDocument/PdbSourceDocumentLoaderService.cs b/src/Features/Core/Portable/PdbSourceDocument/PdbSourceDocumentLoaderService.cs
index 0d2a2a43a1bf4..f61b83491345c 100644
--- a/src/Features/Core/Portable/PdbSourceDocument/PdbSourceDocumentLoaderService.cs
+++ b/src/Features/Core/Portable/PdbSourceDocument/PdbSourceDocumentLoaderService.cs
@@ -26,24 +26,28 @@ internal sealed class PdbSourceDocumentLoaderService : IPdbSourceDocumentLoaderS
         /// binaries to be eagerly loaded even if they are never used.
         /// </summary>
         private readonly Lazy<ISourceLinkService?> _sourceLinkService;
+        private readonly IPdbSourceDocumentLogger? _logger;
 
         [ImportingConstructor]
         [SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code")]
-        public PdbSourceDocumentLoaderService([Import(AllowDefault = true)] Lazy<ISourceLinkService?> sourceLinkService)
+        public PdbSourceDocumentLoaderService(
+            [Import(AllowDefault = true)] Lazy<ISourceLinkService?> sourceLinkService,
+            [Import(AllowDefault = true)] IPdbSourceDocumentLogger? logger)
         {
             _sourceLinkService = sourceLinkService;
+            _logger = logger;
         }
 
-        public async Task<SourceFileInfo?> LoadSourceDocumentAsync(string tempFilePath, SourceDocument sourceDocument, Encoding encoding, IPdbSourceDocumentLogger? logger, CancellationToken cancellationToken)
+        public async Task<SourceFileInfo?> LoadSourceDocumentAsync(string tempFilePath, SourceDocument sourceDocument, Encoding encoding, TelemetryMessage telemetry, CancellationToken cancellationToken)
         {
             // First we try getting "local" files, either from embedded source or a local file on disk
             // and if they don't work we call the debugger to download a file from SourceLink info
-            return TryGetEmbeddedSourceFile(tempFilePath, sourceDocument, encoding) ??
-                TryGetOriginalFile(sourceDocument, encoding) ??
-                await TryGetSourceLinkFileAsync(sourceDocument, encoding, logger, cancellationToken).ConfigureAwait(false);
+            return TryGetEmbeddedSourceFile(tempFilePath, sourceDocument, encoding, telemetry) ??
+                TryGetOriginalFile(sourceDocument, encoding, telemetry) ??
+                await TryGetSourceLinkFileAsync(sourceDocument, encoding, telemetry, cancellationToken).ConfigureAwait(false);
         }
 
-        private static SourceFileInfo? TryGetEmbeddedSourceFile(string tempFilePath, SourceDocument sourceDocument, Encoding encoding)
+        private SourceFileInfo? TryGetEmbeddedSourceFile(string tempFilePath, SourceDocument sourceDocument, Encoding encoding, TelemetryMessage telemetry)
         {
             if (sourceDocument.EmbeddedTextBytes is null)
                 return null;
@@ -53,8 +57,10 @@ public PdbSourceDocumentLoaderService([Import(AllowDefault = true)] Lazy<ISource
             // We might have already navigated to this file before, so it might exist, but
             // we still need to re-validate the checksum and make sure its not the wrong file
             if (File.Exists(filePath) &&
-                LoadSourceFile(filePath, sourceDocument, encoding, ignoreChecksum: false) is { } existing)
+                LoadSourceFile(filePath, sourceDocument, encoding, FeaturesResources.embedded, ignoreChecksum: false) is { } existing)
             {
+                telemetry.SetSourceFileSource("embedded");
+                _logger?.Log(FeaturesResources._0_found_in_embedded_PDB_cached_source_file, sourceDocument.FilePath);
                 return existing;
             }
 
@@ -95,20 +101,31 @@ public PdbSourceDocumentLoaderService([Import(AllowDefault = true)] Lazy<ISource
 
                         new FileInfo(filePath).IsReadOnly = true;
                     }
-                    catch (IOException)
+                    catch (IOException ex)
                     {
-                        // TODO: Log message to inform the user what went wrong: https://github.com/dotnet/roslyn/issues/57352
+                        _logger?.Log(FeaturesResources._0_found_in_embedded_PDB_but_could_not_write_file_1, sourceDocument.FilePath, ex.Message);
                         return null;
                     }
                 }
 
-                return LoadSourceFile(filePath, sourceDocument, encoding, ignoreChecksum: false);
+                var result = LoadSourceFile(filePath, sourceDocument, encoding, FeaturesResources.embedded, ignoreChecksum: false);
+                if (result is not null)
+                {
+                    telemetry.SetSourceFileSource("embedded");
+                    _logger?.Log(FeaturesResources._0_found_in_embedded_PDB, sourceDocument.FilePath);
+                }
+                else
+                {
+                    _logger?.Log(FeaturesResources._0_found_in_embedded_PDB_but_checksum_failed, sourceDocument.FilePath);
+                }
+
+                return result;
             }
 
             return null;
         }
 
-        private async Task<SourceFileInfo?> TryGetSourceLinkFileAsync(SourceDocument sourceDocument, Encoding encoding, IPdbSourceDocumentLogger? logger, CancellationToken cancellationToken)
+        private async Task<SourceFileInfo?> TryGetSourceLinkFileAsync(SourceDocument sourceDocument, Encoding encoding, TelemetryMessage telemetry, CancellationToken cancellationToken)
         {
             if (sourceDocument.SourceLinkUrl is null || _sourceLinkService.Value is null)
                 return null;
@@ -117,7 +134,7 @@ public PdbSourceDocumentLoaderService([Import(AllowDefault = true)] Lazy<ISource
             var relativePath = Path.GetFileName(sourceDocument.FilePath);
 
             var delay = Task.Delay(SourceLinkTimeout, cancellationToken);
-            var sourceFileTask = _sourceLinkService.Value.GetSourceFilePathAsync(sourceDocument.SourceLinkUrl, relativePath, logger, cancellationToken);
+            var sourceFileTask = _sourceLinkService.Value.GetSourceFilePathAsync(sourceDocument.SourceLinkUrl, relativePath, cancellationToken);
 
             var winner = await Task.WhenAny(sourceFileTask, delay).ConfigureAwait(false);
 
@@ -126,30 +143,52 @@ public PdbSourceDocumentLoaderService([Import(AllowDefault = true)] Lazy<ISource
                 var sourceFile = await sourceFileTask.ConfigureAwait(false);
                 if (sourceFile is not null)
                 {
-                    // TODO: Log results from sourceFile.Log: https://github.com/dotnet/roslyn/issues/57352
                     // TODO: Don't ignore the checksum here: https://github.com/dotnet/roslyn/issues/55834
-                    return LoadSourceFile(sourceFile.SourceFilePath, sourceDocument, encoding, ignoreChecksum: true);
+                    var result = LoadSourceFile(sourceFile.SourceFilePath, sourceDocument, encoding, "SourceLink", ignoreChecksum: true);
+                    if (result is not null)
+                    {
+                        telemetry.SetSourceFileSource("sourcelink");
+                        _logger?.Log(FeaturesResources._0_found_via_SourceLink, sourceDocument.FilePath);
+                    }
+                    else
+                    {
+                        _logger?.Log(FeaturesResources._0_found_via_SourceLink_but_couldnt_read_file, sourceDocument.FilePath);
+                    }
+
+                    return result;
                 }
                 else
                 {
-                    // TODO: Log the timeout: https://github.com/dotnet/roslyn/issues/57352
+                    telemetry.SetSourceFileSource("timeout");
+                    _logger?.Log(FeaturesResources.Timeout_SourceLink);
                 }
             }
 
             return null;
         }
 
-        private static SourceFileInfo? TryGetOriginalFile(SourceDocument sourceDocument, Encoding encoding)
+        private SourceFileInfo? TryGetOriginalFile(SourceDocument sourceDocument, Encoding encoding, TelemetryMessage telemetry)
         {
             if (File.Exists(sourceDocument.FilePath))
             {
-                return LoadSourceFile(sourceDocument.FilePath, sourceDocument, encoding, ignoreChecksum: false);
+                var result = LoadSourceFile(sourceDocument.FilePath, sourceDocument, encoding, FeaturesResources.external, ignoreChecksum: false);
+                if (result is not null)
+                {
+                    telemetry.SetSourceFileSource("ondisk");
+                    _logger?.Log(FeaturesResources._0_found_in_original_location, sourceDocument.FilePath);
+                }
+                else
+                {
+                    _logger?.Log(FeaturesResources._0_found_in_original_location_but_checksum_failed, sourceDocument.FilePath);
+                }
+
+                return result;
             }
 
             return null;
         }
 
-        private static SourceFileInfo? LoadSourceFile(string filePath, SourceDocument sourceDocument, Encoding encoding, bool ignoreChecksum)
+        private static SourceFileInfo? LoadSourceFile(string filePath, SourceDocument sourceDocument, Encoding encoding, string sourceDescription, bool ignoreChecksum)
         {
             return IOUtilities.PerformIO(() =>
             {
@@ -162,7 +201,7 @@ public PdbSourceDocumentLoaderService([Import(AllowDefault = true)] Lazy<ISource
                 {
                     var textAndVersion = TextAndVersion.Create(sourceText, VersionStamp.Default, filePath);
                     var textLoader = TextLoader.From(textAndVersion);
-                    return new SourceFileInfo(filePath, textLoader);
+                    return new SourceFileInfo(filePath, sourceDescription, textLoader);
                 }
 
                 return null;
diff --git a/src/Features/Core/Portable/PdbSourceDocument/PdbSourceDocumentMetadataAsSourceFileProvider.cs b/src/Features/Core/Portable/PdbSourceDocument/PdbSourceDocumentMetadataAsSourceFileProvider.cs
index 10ad8fddb5216..2d537abeb85f4 100644
--- a/src/Features/Core/Portable/PdbSourceDocument/PdbSourceDocumentMetadataAsSourceFileProvider.cs
+++ b/src/Features/Core/Portable/PdbSourceDocument/PdbSourceDocumentMetadataAsSourceFileProvider.cs
@@ -54,26 +54,43 @@ public PdbSourceDocumentMetadataAsSourceFileProvider(
             if (signaturesOnly)
                 return null;
 
+            using var telemetry = new TelemetryMessage(cancellationToken);
+
+            var assemblyName = symbol.ContainingAssembly.Identity.Name;
+
+            if (_logger is not null)
+            {
+                // We block to clear the log from the previous operation, so things don't get confusing
+                // if the log messages are delayed
+                await _logger.ClearAsync().ConfigureAwait(false);
+            }
+
+            _logger?.Log(FeaturesResources.Navigating_to_symbol_0_from_1, symbol, assemblyName);
+
             // If this is a reference assembly then we won't have the right information available, so bail out
             // TODO: find the implementation assembly for the reference assembly, and keep going: https://github.com/dotnet/roslyn/issues/55834
             var isReferenceAssembly = symbol.ContainingAssembly.GetAttributes().Any(attribute => attribute.AttributeClass?.Name == nameof(ReferenceAssemblyAttribute)
                 && attribute.AttributeClass.ToNameDisplayString() == typeof(ReferenceAssemblyAttribute).FullName);
             if (isReferenceAssembly)
+            {
+                _logger?.Log(FeaturesResources.Source_is_a_reference_assembly);
                 return null;
+            }
 
             var compilation = await project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);
 
+            // The purpose of the logging is to help library authors, so we don't log things like this where something
+            // else has gone wrong, so even though if this check fails we won't be able to show the source, it's not something
+            // the user or a library author can control, so no log message.
             if (compilation.GetMetadataReference(symbol.ContainingAssembly) is not PortableExecutableReference { FilePath: not null and var dllPath })
-            {
                 return null;
-            }
 
-            var assemblyName = symbol.ContainingAssembly.Identity.Name;
+            _logger?.Log(FeaturesResources.Symbol_found_in_assembly_path_0, dllPath);
 
             ImmutableDictionary<string, string> pdbCompilationOptions;
             ImmutableArray<SourceDocument> sourceDocuments;
             // We know we have a DLL, call and see if we can find metadata readers for it, and for the PDB (whereever it may be)
-            using (var documentDebugInfoReader = await _pdbFileLocatorService.GetDocumentDebugInfoReaderAsync(dllPath, _logger, cancellationToken).ConfigureAwait(false))
+            using (var documentDebugInfoReader = await _pdbFileLocatorService.GetDocumentDebugInfoReaderAsync(dllPath, telemetry, cancellationToken).ConfigureAwait(false))
             {
                 if (documentDebugInfoReader is null)
                     return null;
@@ -86,7 +103,10 @@ public PdbSourceDocumentMetadataAsSourceFileProvider(
                 // Try to find some actual document information from the PDB
                 sourceDocuments = documentDebugInfoReader.FindSourceDocuments(symbol);
                 if (sourceDocuments.Length == 0)
+                {
+                    _logger?.Log(FeaturesResources.No_source_document_info_found_in_PDB);
                     return null;
+                }
             }
 
             Encoding? defaultEncoding = null;
@@ -129,7 +149,7 @@ public PdbSourceDocumentMetadataAsSourceFileProvider(
             // Get text loaders for our documents. We do this here because if we can't load any of the files, then
             // we can't provide any results, so there is no point adding a project to the workspace etc.
             var encoding = defaultEncoding ?? Encoding.UTF8;
-            var sourceFileInfoTasks = sourceDocuments.Select(sd => _pdbSourceDocumentLoaderService.LoadSourceDocumentAsync(tempFilePath, sd, encoding, _logger, cancellationToken)).ToArray();
+            var sourceFileInfoTasks = sourceDocuments.Select(sd => _pdbSourceDocumentLoaderService.LoadSourceDocumentAsync(tempFilePath, sd, encoding, telemetry, cancellationToken)).ToArray();
             var sourceFileInfos = await Task.WhenAll(sourceFileInfoTasks).ConfigureAwait(false);
             if (sourceFileInfos is null || sourceFileInfos.Where(t => t is null).Any())
                 return null;
@@ -144,7 +164,9 @@ public PdbSourceDocumentMetadataAsSourceFileProvider(
                 navigateProject = workspace.CurrentSolution.GetRequiredProject(projectId);
             }
 
-            var documentPath = sourceFileInfos[0]!.FilePath;
+            // TODO: Support results from multiple source files: https://github.com/dotnet/roslyn/issues/55834
+            var firstSourceFileInfo = sourceFileInfos[0]!;
+            var documentPath = firstSourceFileInfo.FilePath;
             var document = navigateProject.Documents.FirstOrDefault(d => d.FilePath?.Equals(documentPath, StringComparison.OrdinalIgnoreCase) ?? false);
 
             // In order to open documents in VS we need to understand the link from temp file to document and its encoding
@@ -156,21 +178,23 @@ public PdbSourceDocumentMetadataAsSourceFileProvider(
             var navigateLocation = await MetadataAsSourceHelpers.GetLocationInGeneratedSourceAsync(symbolId, document, cancellationToken).ConfigureAwait(false);
             var navigateDocument = navigateProject.GetDocument(navigateLocation.SourceTree);
 
-            // TODO: "from metadata" is technically correct, but could be confusing. From PDB? From Source? https://github.com/dotnet/roslyn/issues/55834
             var documentName = string.Format(
                 "{0} [{1}]",
                 navigateDocument!.Name,
-                FeaturesResources.from_metadata);
+                firstSourceFileInfo.SourceDescription);
 
-            return new MetadataAsSourceFile(documentPath, navigateLocation, documentName, navigateDocument.FilePath);
+            return new MetadataAsSourceFile(documentPath, navigateLocation, documentName, sourceDocuments[0].FilePath);
         }
 
-        private static ProjectInfo? CreateProjectInfo(Workspace workspace, Project project, ImmutableDictionary<string, string> pdbCompilationOptions, string assemblyName)
+        private ProjectInfo? CreateProjectInfo(Workspace workspace, Project project, ImmutableDictionary<string, string> pdbCompilationOptions, string assemblyName)
         {
             // First we need the language name in order to get the services
             // TODO: Find language another way for non portable PDBs: https://github.com/dotnet/roslyn/issues/55834
             if (!pdbCompilationOptions.TryGetValue("language", out var languageName) || languageName is null)
+            {
+                _logger?.Log(FeaturesResources.Source_code_language_information_was_not_found_in_PDB);
                 return null;
+            }
 
             var languageServices = workspace.Services.GetLanguageServices(languageName);
 
diff --git a/src/Features/Core/Portable/PdbSourceDocument/TelemetryMessage.cs b/src/Features/Core/Portable/PdbSourceDocument/TelemetryMessage.cs
new file mode 100644
index 0000000000000..0bfeafe94752b
--- /dev/null
+++ b/src/Features/Core/Portable/PdbSourceDocument/TelemetryMessage.cs
@@ -0,0 +1,46 @@
+// 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.Threading;
+using Microsoft.CodeAnalysis.Internal.Log;
+
+namespace Microsoft.CodeAnalysis.PdbSourceDocument
+{
+    internal class TelemetryMessage : IDisposable
+    {
+        private string? _pdbSource;
+        private string? _sourceFileSource;
+
+        private readonly IDisposable _logBlock;
+
+        public TelemetryMessage(CancellationToken cancellationToken)
+        {
+            var logMessage = KeyValueLogMessage.Create(LogType.UserAction, SetLogProperties);
+            _logBlock = Logger.LogBlock(FunctionId.NavigateToExternalSources, logMessage, cancellationToken);
+        }
+
+        public void SetPdbSource(string source)
+        {
+            _pdbSource = source;
+        }
+
+        public void SetSourceFileSource(string source)
+        {
+            _sourceFileSource = source;
+        }
+
+        private void SetLogProperties(Dictionary<string, object?> properties)
+        {
+            properties["pdb"] = _pdbSource ?? "none";
+            properties["source"] = _sourceFileSource ?? "none";
+        }
+
+        public void Dispose()
+        {
+            _logBlock.Dispose();
+        }
+    }
+}
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf
index 5342279a292fa..078982182e196 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf
@@ -470,6 +470,16 @@ Ujistěte se, že specifikátor tt použijete pro jazyky, pro které je nezbytn
         <target state="translated">Převést typ na {0}</target>
         <note />
       </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
+        <source>Could not find portable PDB on disk or embedded.</source>
+        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
+        <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
+        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
         <source>Create and assign field '{0}'</source>
         <target state="translated">Vytvořit a přiřadit pole {0}</target>
@@ -550,6 +560,11 @@ Ujistěte se, že specifikátor tt použijete pro jazyky, pro které je nezbytn
         <target state="translated">Při vytváření instance CodeFixProvider {0} došlo k chybě.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Error_reading_PDB_0">
+        <source>Error reading PDB: '{0}'</source>
+        <target state="new">Error reading PDB: '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Example">
         <source>Example:</source>
         <target state="translated">Příklad:</target>
@@ -615,6 +630,26 @@ Ujistěte se, že specifikátor tt použijete pro jazyky, pro které je nezbytn
         <target state="translated">Formátuje se dokument.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Found_PDB_file_at_0">
+        <source>Found PDB file at '{0}'</source>
+        <target state="new">Found PDB file at '{0}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server">
+        <source>Found PDB on symbol server.</source>
+        <target state="new">Found PDB on symbol server.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
+        <source>Found PDB on symbol server but could not read file.</source>
+        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_embedded_PDB_file">
+        <source>Found embedded PDB file.</source>
+        <target state="new">Found embedded PDB file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
         <target state="new">Generate abstract method '{0}'</target>
@@ -1035,6 +1070,11 @@ Ujistěte se, že specifikátor tt použijete pro jazyky, pro které je nezbytn
         <target state="translated">Přesunutí {0} vyžaduje restartování aplikace.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigating_to_symbol_0_from_1">
+        <source>Navigating to symbol '{0}' from '{1}'.</source>
+        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Nested_quantifier_0">
         <source>Nested quantifier {0}</source>
         <target state="translated">Vnořený kvantifikátor {0}</target>
@@ -1045,6 +1085,11 @@ Ujistěte se, že specifikátor tt použijete pro jazyky, pro které je nezbytn
         <target state="translated">Žádný společný kořenový uzel pro extrakci</target>
         <note />
       </trans-unit>
+      <trans-unit id="No_source_document_info_found_in_PDB">
+        <source>No source document info found in PDB.</source>
+        <target state="new">No source document info found in PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
         <source>No valid location to insert method call.</source>
         <target state="translated">Není k dispozici žádné platné umístění, kam vložit volání metody.</target>
@@ -2315,6 +2360,16 @@ Pozitivní kontrolní výrazy zpětného vyhledávání s nulovou délkou se obv
         <target state="translated">Seřadit modifikátory dostupnosti</target>
         <note />
       </trans-unit>
+      <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
+        <source>Source code language information was not found in PDB.</source>
+        <target state="new">Source code language information was not found in PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Source_is_a_reference_assembly">
+        <source>Source is a reference assembly, not enough information to find PDB.</source>
+        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
         <source>Split into consecutive '{0}' statements</source>
         <target state="translated">Rozdělit do následných příkazů {0}</target>
@@ -2340,6 +2395,11 @@ Pozitivní kontrolní výrazy zpětného vyhledávání s nulovou délkou se obv
         <target state="translated">Přepnutí mezi funkcí lambda a místní funkcí vyžaduje restartování aplikace.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Symbol_found_in_assembly_path_0">
+        <source>Symbol found in assembly path '{0}'</source>
+        <target state="new">Symbol found in assembly path '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
         <source>TODO: free unmanaged resources (unmanaged objects) and override finalizer</source>
         <target state="translated">TODO: Uvolněte nespravované prostředky (nespravované objekty) a přepište finalizační metodu.</target>
@@ -2365,6 +2425,16 @@ Pozitivní kontrolní výrazy zpětného vyhledávání s nulovou délkou se obv
         <target state="translated">Výběr obsahuje volání lokální funkce, aniž by byla deklarovaná.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Timeout_SourceLink">
+        <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Timeout_symbol_server">
+        <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
         <source>Too many | in (?()|)</source>
         <target state="translated">Příliš mnoho znaků | ve výrazu (?()|)</target>
@@ -2665,6 +2735,46 @@ Pozitivní kontrolní výrazy zpětného vyhledávání s nulovou délkou se obv
         <target state="translated">{0} - {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB">
+        <source>'{0}' found in embedded PDB.</source>
+        <target state="new">'{0}' found in embedded PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
+        <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
+        <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
+        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
+        <source>'{0}' found in embedded PDB and found cached source file.</source>
+        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location">
+        <source>'{0}' found in original location.</source>
+        <target state="new">'{0}' found in original location.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location_but_checksum_failed">
+        <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink">
+        <source>'{0}' found via SourceLink.</source>
+        <target state="new">'{0}' found via SourceLink.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
+        <source>'{0}' found via SourceLink but couldn't read temp file.</source>
+        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="_0_is_not_null_here">
         <source>'{0}' is not null here.</source>
         <target state="translated">{0} tady není null.</target>
@@ -2993,6 +3103,16 @@ Pokud se specifikátor formátu d použije bez dalších specifikátorů vlastn
         <target state="translated">proměnná typu discard</target>
         <note />
       </trans-unit>
+      <trans-unit id="embedded">
+        <source>embedded</source>
+        <target state="new">embedded</target>
+        <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
+      </trans-unit>
+      <trans-unit id="external">
+        <source>external</source>
+        <target state="new">external</target>
+        <note>External means "external source", meaning source files that are not part of the current solution</note>
+      </trans-unit>
       <trans-unit id="from_metadata">
         <source>from metadata</source>
         <target state="translated">z metadat</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf
index 8400578b06720..42e2d37adb679 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf
@@ -470,6 +470,16 @@ Stellen Sie sicher, dass Sie den Bezeichner "tt" für Sprachen verwenden, für d
         <target state="translated">Typ in "{0}" konvertieren</target>
         <note />
       </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
+        <source>Could not find portable PDB on disk or embedded.</source>
+        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
+        <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
+        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
         <source>Create and assign field '{0}'</source>
         <target state="translated">Feld "{0}" erstellen und zuweisen</target>
@@ -550,6 +560,11 @@ Stellen Sie sicher, dass Sie den Bezeichner "tt" für Sprachen verwenden, für d
         <target state="translated">Fehler beim Erstellen der CodeFixProvider-Instanz "{0}".</target>
         <note />
       </trans-unit>
+      <trans-unit id="Error_reading_PDB_0">
+        <source>Error reading PDB: '{0}'</source>
+        <target state="new">Error reading PDB: '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Example">
         <source>Example:</source>
         <target state="translated">Beispiel:</target>
@@ -615,6 +630,26 @@ Stellen Sie sicher, dass Sie den Bezeichner "tt" für Sprachen verwenden, für d
         <target state="translated">Dokument wird formatiert</target>
         <note />
       </trans-unit>
+      <trans-unit id="Found_PDB_file_at_0">
+        <source>Found PDB file at '{0}'</source>
+        <target state="new">Found PDB file at '{0}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server">
+        <source>Found PDB on symbol server.</source>
+        <target state="new">Found PDB on symbol server.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
+        <source>Found PDB on symbol server but could not read file.</source>
+        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_embedded_PDB_file">
+        <source>Found embedded PDB file.</source>
+        <target state="new">Found embedded PDB file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
         <target state="new">Generate abstract method '{0}'</target>
@@ -1035,6 +1070,11 @@ Stellen Sie sicher, dass Sie den Bezeichner "tt" für Sprachen verwenden, für d
         <target state="translated">Das Verschieben von {0} erfordert einen Neustart der Anwendung.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigating_to_symbol_0_from_1">
+        <source>Navigating to symbol '{0}' from '{1}'.</source>
+        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Nested_quantifier_0">
         <source>Nested quantifier {0}</source>
         <target state="translated">Geschachtelter Quantifizierer {0}.</target>
@@ -1045,6 +1085,11 @@ Stellen Sie sicher, dass Sie den Bezeichner "tt" für Sprachen verwenden, für d
         <target state="translated">Kein gemeinsamer Stammknoten für Extraktion.</target>
         <note />
       </trans-unit>
+      <trans-unit id="No_source_document_info_found_in_PDB">
+        <source>No source document info found in PDB.</source>
+        <target state="new">No source document info found in PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
         <source>No valid location to insert method call.</source>
         <target state="translated">Keine gültige Position zum Einfügen eines Methodenaufrufs.</target>
@@ -2315,6 +2360,16 @@ Positive Lookbehindassertionen mit Nullbreite werden normalerweise am Anfang reg
         <target state="translated">Zugriffsmodifizierer sortieren</target>
         <note />
       </trans-unit>
+      <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
+        <source>Source code language information was not found in PDB.</source>
+        <target state="new">Source code language information was not found in PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Source_is_a_reference_assembly">
+        <source>Source is a reference assembly, not enough information to find PDB.</source>
+        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
         <source>Split into consecutive '{0}' statements</source>
         <target state="translated">In aufeinanderfolgende {0}-Anweisungen teilen</target>
@@ -2340,6 +2395,11 @@ Positive Lookbehindassertionen mit Nullbreite werden normalerweise am Anfang reg
         <target state="translated">Der Wechsel zwischen einer Lambda- und einer lokalen Funktion erfordert einen Neustart der Anwendung.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Symbol_found_in_assembly_path_0">
+        <source>Symbol found in assembly path '{0}'</source>
+        <target state="new">Symbol found in assembly path '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
         <source>TODO: free unmanaged resources (unmanaged objects) and override finalizer</source>
         <target state="translated">TODO: Nicht verwaltete Ressourcen (nicht verwaltete Objekte) freigeben und Finalizer überschreiben</target>
@@ -2365,6 +2425,16 @@ Positive Lookbehindassertionen mit Nullbreite werden normalerweise am Anfang reg
         <target state="translated">Die Auswahl enthält einen lokalen Funktionsaufruf ohne Deklaration.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Timeout_SourceLink">
+        <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Timeout_symbol_server">
+        <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
         <source>Too many | in (?()|)</source>
         <target state="translated">Zu viele |-Zeichen in (?()|).</target>
@@ -2665,6 +2735,46 @@ Positive Lookbehindassertionen mit Nullbreite werden normalerweise am Anfang reg
         <target state="translated">{0} - {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB">
+        <source>'{0}' found in embedded PDB.</source>
+        <target state="new">'{0}' found in embedded PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
+        <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
+        <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
+        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
+        <source>'{0}' found in embedded PDB and found cached source file.</source>
+        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location">
+        <source>'{0}' found in original location.</source>
+        <target state="new">'{0}' found in original location.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location_but_checksum_failed">
+        <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink">
+        <source>'{0}' found via SourceLink.</source>
+        <target state="new">'{0}' found via SourceLink.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
+        <source>'{0}' found via SourceLink but couldn't read temp file.</source>
+        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="_0_is_not_null_here">
         <source>'{0}' is not null here.</source>
         <target state="translated">"{0}" ist hier nicht NULL.</target>
@@ -2993,6 +3103,16 @@ Bei Verwendung des Formatbezeichners "d" ohne weitere benutzerdefinierte Formatb
         <target state="translated">Ausschussvariable</target>
         <note />
       </trans-unit>
+      <trans-unit id="embedded">
+        <source>embedded</source>
+        <target state="new">embedded</target>
+        <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
+      </trans-unit>
+      <trans-unit id="external">
+        <source>external</source>
+        <target state="new">external</target>
+        <note>External means "external source", meaning source files that are not part of the current solution</note>
+      </trans-unit>
       <trans-unit id="from_metadata">
         <source>from metadata</source>
         <target state="translated">aus Metadaten</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf
index c57a6c46a6ab6..276f61e8b8af0 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf
@@ -470,6 +470,16 @@ Asegúrese de usar el especificador "tt" para los idiomas para los que es necesa
         <target state="translated">Convertir tipo en "{0}"</target>
         <note />
       </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
+        <source>Could not find portable PDB on disk or embedded.</source>
+        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
+        <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
+        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
         <source>Create and assign field '{0}'</source>
         <target state="translated">Crear y asignar campo "{0}"</target>
@@ -550,6 +560,11 @@ Asegúrese de usar el especificador "tt" para los idiomas para los que es necesa
         <target state="translated">Error al crear la instancia de CodeFixProvider "{0}"</target>
         <note />
       </trans-unit>
+      <trans-unit id="Error_reading_PDB_0">
+        <source>Error reading PDB: '{0}'</source>
+        <target state="new">Error reading PDB: '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Example">
         <source>Example:</source>
         <target state="translated">Ejemplo:</target>
@@ -615,6 +630,26 @@ Asegúrese de usar el especificador "tt" para los idiomas para los que es necesa
         <target state="translated">Aplicando formato al documento</target>
         <note />
       </trans-unit>
+      <trans-unit id="Found_PDB_file_at_0">
+        <source>Found PDB file at '{0}'</source>
+        <target state="new">Found PDB file at '{0}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server">
+        <source>Found PDB on symbol server.</source>
+        <target state="new">Found PDB on symbol server.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
+        <source>Found PDB on symbol server but could not read file.</source>
+        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_embedded_PDB_file">
+        <source>Found embedded PDB file.</source>
+        <target state="new">Found embedded PDB file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
         <target state="new">Generate abstract method '{0}'</target>
@@ -1035,6 +1070,11 @@ Asegúrese de usar el especificador "tt" para los idiomas para los que es necesa
         <target state="translated">Para mover {0} es necesario reiniciar la aplicación.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigating_to_symbol_0_from_1">
+        <source>Navigating to symbol '{0}' from '{1}'.</source>
+        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Nested_quantifier_0">
         <source>Nested quantifier {0}</source>
         <target state="translated">Cuantificador anidado {0}</target>
@@ -1045,6 +1085,11 @@ Asegúrese de usar el especificador "tt" para los idiomas para los que es necesa
         <target state="translated">No hay nodo raíz común para la extracción.</target>
         <note />
       </trans-unit>
+      <trans-unit id="No_source_document_info_found_in_PDB">
+        <source>No source document info found in PDB.</source>
+        <target state="new">No source document info found in PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
         <source>No valid location to insert method call.</source>
         <target state="translated">No hay ninguna ubicación válida para insertar una llamada de método.</target>
@@ -2315,6 +2360,16 @@ Las aserciones de búsqueda retrasada (lookbehind) positivas de ancho cero se us
         <target state="translated">Ordenar modificadores de accesibilidad</target>
         <note />
       </trans-unit>
+      <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
+        <source>Source code language information was not found in PDB.</source>
+        <target state="new">Source code language information was not found in PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Source_is_a_reference_assembly">
+        <source>Source is a reference assembly, not enough information to find PDB.</source>
+        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
         <source>Split into consecutive '{0}' statements</source>
         <target state="translated">Dividir en instrucciones "{0}" consecutivas</target>
@@ -2340,6 +2395,11 @@ Las aserciones de búsqueda retrasada (lookbehind) positivas de ancho cero se us
         <target state="translated">Para cambiar entre una expresión lambda y una función local, es necesario reiniciar la aplicación.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Symbol_found_in_assembly_path_0">
+        <source>Symbol found in assembly path '{0}'</source>
+        <target state="new">Symbol found in assembly path '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
         <source>TODO: free unmanaged resources (unmanaged objects) and override finalizer</source>
         <target state="translated">TODO: liberar los recursos no administrados (objetos no administrados) y reemplazar el finalizador</target>
@@ -2365,6 +2425,16 @@ Las aserciones de búsqueda retrasada (lookbehind) positivas de ancho cero se us
         <target state="translated">La selección contiene una llamada a una función local sin la declaración correspondiente.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Timeout_SourceLink">
+        <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Timeout_symbol_server">
+        <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
         <source>Too many | in (?()|)</source>
         <target state="translated">Demasiados | en (?()|)</target>
@@ -2665,6 +2735,46 @@ Las aserciones de búsqueda retrasada (lookbehind) positivas de ancho cero se us
         <target state="translated">{0} - {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB">
+        <source>'{0}' found in embedded PDB.</source>
+        <target state="new">'{0}' found in embedded PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
+        <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
+        <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
+        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
+        <source>'{0}' found in embedded PDB and found cached source file.</source>
+        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location">
+        <source>'{0}' found in original location.</source>
+        <target state="new">'{0}' found in original location.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location_but_checksum_failed">
+        <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink">
+        <source>'{0}' found via SourceLink.</source>
+        <target state="new">'{0}' found via SourceLink.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
+        <source>'{0}' found via SourceLink but couldn't read temp file.</source>
+        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="_0_is_not_null_here">
         <source>'{0}' is not null here.</source>
         <target state="translated">"{0}" no es NULL aquí.</target>
@@ -2993,6 +3103,16 @@ Si el especificador de formato "d" se usa sin otros especificadores de formato p
         <target state="translated">descartar</target>
         <note />
       </trans-unit>
+      <trans-unit id="embedded">
+        <source>embedded</source>
+        <target state="new">embedded</target>
+        <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
+      </trans-unit>
+      <trans-unit id="external">
+        <source>external</source>
+        <target state="new">external</target>
+        <note>External means "external source", meaning source files that are not part of the current solution</note>
+      </trans-unit>
       <trans-unit id="from_metadata">
         <source>from metadata</source>
         <target state="translated">de metadatos</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf
index f98c7e68175ec..751ae795026bc 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf
@@ -470,6 +470,16 @@ Veillez à utiliser le spécificateur "tt" pour les langues où il est nécessai
         <target state="translated">Convertir le type en '{0}'</target>
         <note />
       </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
+        <source>Could not find portable PDB on disk or embedded.</source>
+        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
+        <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
+        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
         <source>Create and assign field '{0}'</source>
         <target state="translated">Créer et affecter le champ '{0}'</target>
@@ -550,6 +560,11 @@ Veillez à utiliser le spécificateur "tt" pour les langues où il est nécessai
         <target state="translated">Erreur lors de la création de l'instance de CodeFixProvider '{0}'</target>
         <note />
       </trans-unit>
+      <trans-unit id="Error_reading_PDB_0">
+        <source>Error reading PDB: '{0}'</source>
+        <target state="new">Error reading PDB: '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Example">
         <source>Example:</source>
         <target state="translated">Exemple :</target>
@@ -615,6 +630,26 @@ Veillez à utiliser le spécificateur "tt" pour les langues où il est nécessai
         <target state="translated">Mise en forme du document</target>
         <note />
       </trans-unit>
+      <trans-unit id="Found_PDB_file_at_0">
+        <source>Found PDB file at '{0}'</source>
+        <target state="new">Found PDB file at '{0}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server">
+        <source>Found PDB on symbol server.</source>
+        <target state="new">Found PDB on symbol server.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
+        <source>Found PDB on symbol server but could not read file.</source>
+        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_embedded_PDB_file">
+        <source>Found embedded PDB file.</source>
+        <target state="new">Found embedded PDB file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
         <target state="new">Generate abstract method '{0}'</target>
@@ -1035,6 +1070,11 @@ Veillez à utiliser le spécificateur "tt" pour les langues où il est nécessai
         <target state="translated">Le déplacement de {0} requiert le redémarrage de l’application.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigating_to_symbol_0_from_1">
+        <source>Navigating to symbol '{0}' from '{1}'.</source>
+        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Nested_quantifier_0">
         <source>Nested quantifier {0}</source>
         <target state="translated">Quantificateur imbriqué {0}</target>
@@ -1045,6 +1085,11 @@ Veillez à utiliser le spécificateur "tt" pour les langues où il est nécessai
         <target state="translated">Pas de nœud racine commun pour l'extraction.</target>
         <note />
       </trans-unit>
+      <trans-unit id="No_source_document_info_found_in_PDB">
+        <source>No source document info found in PDB.</source>
+        <target state="new">No source document info found in PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
         <source>No valid location to insert method call.</source>
         <target state="translated">Aucun emplacement valide pour l'insertion de l'appel de méthode.</target>
@@ -2315,6 +2360,16 @@ Les assertions arrière positives de largeur nulle sont généralement utilisée
         <target state="translated">Trier les modificateurs d'accessibilité</target>
         <note />
       </trans-unit>
+      <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
+        <source>Source code language information was not found in PDB.</source>
+        <target state="new">Source code language information was not found in PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Source_is_a_reference_assembly">
+        <source>Source is a reference assembly, not enough information to find PDB.</source>
+        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
         <source>Split into consecutive '{0}' statements</source>
         <target state="translated">Diviser en instructions '{0}' consécutives</target>
@@ -2340,6 +2395,11 @@ Les assertions arrière positives de largeur nulle sont généralement utilisée
         <target state="translated">Le passage d’une fonction lambda à une fonction locale requiert le redémarrage de l’application.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Symbol_found_in_assembly_path_0">
+        <source>Symbol found in assembly path '{0}'</source>
+        <target state="new">Symbol found in assembly path '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
         <source>TODO: free unmanaged resources (unmanaged objects) and override finalizer</source>
         <target state="translated">TODO: libérer les ressources non managées (objets non managés) et substituer le finaliseur</target>
@@ -2365,6 +2425,16 @@ Les assertions arrière positives de largeur nulle sont généralement utilisée
         <target state="translated">La sélection contient un appel de fonction locale sans sa déclaration.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Timeout_SourceLink">
+        <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Timeout_symbol_server">
+        <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
         <source>Too many | in (?()|)</source>
         <target state="translated">Trop de | dans (?()|)</target>
@@ -2665,6 +2735,46 @@ Les assertions arrière positives de largeur nulle sont généralement utilisée
         <target state="translated">{0} - {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB">
+        <source>'{0}' found in embedded PDB.</source>
+        <target state="new">'{0}' found in embedded PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
+        <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
+        <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
+        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
+        <source>'{0}' found in embedded PDB and found cached source file.</source>
+        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location">
+        <source>'{0}' found in original location.</source>
+        <target state="new">'{0}' found in original location.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location_but_checksum_failed">
+        <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink">
+        <source>'{0}' found via SourceLink.</source>
+        <target state="new">'{0}' found via SourceLink.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
+        <source>'{0}' found via SourceLink but couldn't read temp file.</source>
+        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="_0_is_not_null_here">
         <source>'{0}' is not null here.</source>
         <target state="translated">'{0}' n'a pas une valeur null ici.</target>
@@ -2993,6 +3103,16 @@ Si le spécificateur de format "d" est utilisé sans autres spécificateurs de f
         <target state="translated">discard</target>
         <note />
       </trans-unit>
+      <trans-unit id="embedded">
+        <source>embedded</source>
+        <target state="new">embedded</target>
+        <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
+      </trans-unit>
+      <trans-unit id="external">
+        <source>external</source>
+        <target state="new">external</target>
+        <note>External means "external source", meaning source files that are not part of the current solution</note>
+      </trans-unit>
       <trans-unit id="from_metadata">
         <source>from metadata</source>
         <target state="translated">à partir des métadonnées</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf
index e2c888350583c..ad7c9b888a68c 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf
@@ -470,6 +470,16 @@ Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessa
         <target state="translated">Converti il tipo in '{0}'</target>
         <note />
       </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
+        <source>Could not find portable PDB on disk or embedded.</source>
+        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
+        <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
+        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
         <source>Create and assign field '{0}'</source>
         <target state="translated">Crea e assegna il campo '{0}'</target>
@@ -550,6 +560,11 @@ Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessa
         <target state="translated">Si è verificato un errore durante la creazione dell'istanza di CodeFixProvider '{0}'</target>
         <note />
       </trans-unit>
+      <trans-unit id="Error_reading_PDB_0">
+        <source>Error reading PDB: '{0}'</source>
+        <target state="new">Error reading PDB: '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Example">
         <source>Example:</source>
         <target state="translated">Esempio:</target>
@@ -615,6 +630,26 @@ Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessa
         <target state="translated">Formattazione del documento</target>
         <note />
       </trans-unit>
+      <trans-unit id="Found_PDB_file_at_0">
+        <source>Found PDB file at '{0}'</source>
+        <target state="new">Found PDB file at '{0}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server">
+        <source>Found PDB on symbol server.</source>
+        <target state="new">Found PDB on symbol server.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
+        <source>Found PDB on symbol server but could not read file.</source>
+        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_embedded_PDB_file">
+        <source>Found embedded PDB file.</source>
+        <target state="new">Found embedded PDB file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
         <target state="new">Generate abstract method '{0}'</target>
@@ -1035,6 +1070,11 @@ Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessa
         <target state="translated">Se si sposta {0}, è necessario riavviare l'applicazione.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigating_to_symbol_0_from_1">
+        <source>Navigating to symbol '{0}' from '{1}'.</source>
+        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Nested_quantifier_0">
         <source>Nested quantifier {0}</source>
         <target state="translated">Quantificatore nidificato {0}</target>
@@ -1045,6 +1085,11 @@ Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessa
         <target state="translated">Non esiste un nodo radice comune per l'estrazione.</target>
         <note />
       </trans-unit>
+      <trans-unit id="No_source_document_info_found_in_PDB">
+        <source>No source document info found in PDB.</source>
+        <target state="new">No source document info found in PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
         <source>No valid location to insert method call.</source>
         <target state="translated">Non ci sono posizioni valide per inserire la chiamata a un metodo.</target>
@@ -2315,6 +2360,16 @@ Le asserzioni lookbehind positive di larghezza zero vengono usate in genere all'
         <target state="translated">Ordina i modificatori di accessibilità</target>
         <note />
       </trans-unit>
+      <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
+        <source>Source code language information was not found in PDB.</source>
+        <target state="new">Source code language information was not found in PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Source_is_a_reference_assembly">
+        <source>Source is a reference assembly, not enough information to find PDB.</source>
+        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
         <source>Split into consecutive '{0}' statements</source>
         <target state="translated">Dividi in istruzioni '{0}' consecutive</target>
@@ -2340,6 +2395,11 @@ Le asserzioni lookbehind positive di larghezza zero vengono usate in genere all'
         <target state="translated">Se si passa da un'espressione lambda a una funzione locale, è necessario riavviare l'applicazione.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Symbol_found_in_assembly_path_0">
+        <source>Symbol found in assembly path '{0}'</source>
+        <target state="new">Symbol found in assembly path '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
         <source>TODO: free unmanaged resources (unmanaged objects) and override finalizer</source>
         <target state="translated">TODO: liberare risorse non gestite (oggetti non gestiti) ed eseguire l'override del finalizzatore</target>
@@ -2365,6 +2425,16 @@ Le asserzioni lookbehind positive di larghezza zero vengono usate in genere all'
         <target state="translated">La selezione contiene una chiamata di funzione locale senza la relativa dichiarazione.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Timeout_SourceLink">
+        <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Timeout_symbol_server">
+        <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
         <source>Too many | in (?()|)</source>
         <target state="translated">Troppi | in (?()|)</target>
@@ -2665,6 +2735,46 @@ Le asserzioni lookbehind positive di larghezza zero vengono usate in genere all'
         <target state="translated">{0} - {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB">
+        <source>'{0}' found in embedded PDB.</source>
+        <target state="new">'{0}' found in embedded PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
+        <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
+        <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
+        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
+        <source>'{0}' found in embedded PDB and found cached source file.</source>
+        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location">
+        <source>'{0}' found in original location.</source>
+        <target state="new">'{0}' found in original location.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location_but_checksum_failed">
+        <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink">
+        <source>'{0}' found via SourceLink.</source>
+        <target state="new">'{0}' found via SourceLink.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
+        <source>'{0}' found via SourceLink but couldn't read temp file.</source>
+        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="_0_is_not_null_here">
         <source>'{0}' is not null here.</source>
         <target state="translated">'{0}' non è Null in questo punto.</target>
@@ -2993,6 +3103,16 @@ Se l'identificatore di formato "d" viene usato senza altri identificatori di for
         <target state="translated">variabile discard</target>
         <note />
       </trans-unit>
+      <trans-unit id="embedded">
+        <source>embedded</source>
+        <target state="new">embedded</target>
+        <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
+      </trans-unit>
+      <trans-unit id="external">
+        <source>external</source>
+        <target state="new">external</target>
+        <note>External means "external source", meaning source files that are not part of the current solution</note>
+      </trans-unit>
       <trans-unit id="from_metadata">
         <source>from metadata</source>
         <target state="translated">da metadati</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf
index ed91d088918e3..44a887be830c0 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf
@@ -470,6 +470,16 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">型を '{0}' に変換</target>
         <note />
       </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
+        <source>Could not find portable PDB on disk or embedded.</source>
+        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
+        <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
+        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
         <source>Create and assign field '{0}'</source>
         <target state="translated">フィールド '{0}' を作成して割り当てる</target>
@@ -550,6 +560,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">CodeFixProvider '{0}' のインスタンスの作成でエラーが発生しました</target>
         <note />
       </trans-unit>
+      <trans-unit id="Error_reading_PDB_0">
+        <source>Error reading PDB: '{0}'</source>
+        <target state="new">Error reading PDB: '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Example">
         <source>Example:</source>
         <target state="translated">例:</target>
@@ -615,6 +630,26 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">ドキュメントの書式設定</target>
         <note />
       </trans-unit>
+      <trans-unit id="Found_PDB_file_at_0">
+        <source>Found PDB file at '{0}'</source>
+        <target state="new">Found PDB file at '{0}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server">
+        <source>Found PDB on symbol server.</source>
+        <target state="new">Found PDB on symbol server.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
+        <source>Found PDB on symbol server but could not read file.</source>
+        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_embedded_PDB_file">
+        <source>Found embedded PDB file.</source>
+        <target state="new">Found embedded PDB file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
         <target state="new">Generate abstract method '{0}'</target>
@@ -1035,6 +1070,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">{0} を移動するには、アプリケーションを再起動する必要があります。</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigating_to_symbol_0_from_1">
+        <source>Navigating to symbol '{0}' from '{1}'.</source>
+        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Nested_quantifier_0">
         <source>Nested quantifier {0}</source>
         <target state="translated">入れ子になった量指定子 {0}</target>
@@ -1045,6 +1085,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">抽出するための一般的なルート ノードがありません。</target>
         <note />
       </trans-unit>
+      <trans-unit id="No_source_document_info_found_in_PDB">
+        <source>No source document info found in PDB.</source>
+        <target state="new">No source document info found in PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
         <source>No valid location to insert method call.</source>
         <target state="translated">メソッド呼び出しを挿入する有効な場所がありません。</target>
@@ -2315,6 +2360,16 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
         <target state="translated">アクセシビリティ修飾子を並べ替える</target>
         <note />
       </trans-unit>
+      <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
+        <source>Source code language information was not found in PDB.</source>
+        <target state="new">Source code language information was not found in PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Source_is_a_reference_assembly">
+        <source>Source is a reference assembly, not enough information to find PDB.</source>
+        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
         <source>Split into consecutive '{0}' statements</source>
         <target state="translated">連続する '{0}' ステートメントに分割</target>
@@ -2340,6 +2395,11 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
         <target state="translated">ラムダとローカル関数を切り替えるには、アプリケーションを再起動する必要があります。</target>
         <note />
       </trans-unit>
+      <trans-unit id="Symbol_found_in_assembly_path_0">
+        <source>Symbol found in assembly path '{0}'</source>
+        <target state="new">Symbol found in assembly path '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
         <source>TODO: free unmanaged resources (unmanaged objects) and override finalizer</source>
         <target state="translated">TODO: アンマネージド リソース (アンマネージド オブジェクト) を解放し、ファイナライザーをオーバーライドします</target>
@@ -2365,6 +2425,16 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
         <target state="translated">選択範囲に、宣言のないローカル関数呼び出しが含まれています。</target>
         <note />
       </trans-unit>
+      <trans-unit id="Timeout_SourceLink">
+        <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Timeout_symbol_server">
+        <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
         <source>Too many | in (?()|)</source>
         <target state="translated">(?()|) で | が多すぎます</target>
@@ -2665,6 +2735,46 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
         <target state="translated">{0} - {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB">
+        <source>'{0}' found in embedded PDB.</source>
+        <target state="new">'{0}' found in embedded PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
+        <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
+        <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
+        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
+        <source>'{0}' found in embedded PDB and found cached source file.</source>
+        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location">
+        <source>'{0}' found in original location.</source>
+        <target state="new">'{0}' found in original location.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location_but_checksum_failed">
+        <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink">
+        <source>'{0}' found via SourceLink.</source>
+        <target state="new">'{0}' found via SourceLink.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
+        <source>'{0}' found via SourceLink but couldn't read temp file.</source>
+        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="_0_is_not_null_here">
         <source>'{0}' is not null here.</source>
         <target state="translated">ここでは、'{0}' は null ではありません。</target>
@@ -2993,6 +3103,16 @@ If the "d" format specifier is used without other custom format specifiers, it's
         <target state="translated">破棄</target>
         <note />
       </trans-unit>
+      <trans-unit id="embedded">
+        <source>embedded</source>
+        <target state="new">embedded</target>
+        <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
+      </trans-unit>
+      <trans-unit id="external">
+        <source>external</source>
+        <target state="new">external</target>
+        <note>External means "external source", meaning source files that are not part of the current solution</note>
+      </trans-unit>
       <trans-unit id="from_metadata">
         <source>from metadata</source>
         <target state="translated">メタデータから</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf
index e632e98d0dd51..ebfa13a27f00a 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf
@@ -470,6 +470,16 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">형식을 '{0}'(으)로 변환</target>
         <note />
       </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
+        <source>Could not find portable PDB on disk or embedded.</source>
+        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
+        <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
+        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
         <source>Create and assign field '{0}'</source>
         <target state="translated">'{0}' 필드 만들기 및 할당</target>
@@ -550,6 +560,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">CodeFixProvider '{0}' 인스턴스를 만드는 동안 오류가 발생했습니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Error_reading_PDB_0">
+        <source>Error reading PDB: '{0}'</source>
+        <target state="new">Error reading PDB: '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Example">
         <source>Example:</source>
         <target state="translated">예:</target>
@@ -615,6 +630,26 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">문서 서식을 지정하는 중</target>
         <note />
       </trans-unit>
+      <trans-unit id="Found_PDB_file_at_0">
+        <source>Found PDB file at '{0}'</source>
+        <target state="new">Found PDB file at '{0}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server">
+        <source>Found PDB on symbol server.</source>
+        <target state="new">Found PDB on symbol server.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
+        <source>Found PDB on symbol server but could not read file.</source>
+        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_embedded_PDB_file">
+        <source>Found embedded PDB file.</source>
+        <target state="new">Found embedded PDB file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
         <target state="new">Generate abstract method '{0}'</target>
@@ -1035,6 +1070,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">{0}을(를) 이동하려면 애플리케이션을 다시 시작해야 합니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigating_to_symbol_0_from_1">
+        <source>Navigating to symbol '{0}' from '{1}'.</source>
+        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Nested_quantifier_0">
         <source>Nested quantifier {0}</source>
         <target state="translated">중첩 수량자 {0}입니다.</target>
@@ -1045,6 +1085,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">추출에 필요한 일반 루트 노드가 없습니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="No_source_document_info_found_in_PDB">
+        <source>No source document info found in PDB.</source>
+        <target state="new">No source document info found in PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
         <source>No valid location to insert method call.</source>
         <target state="translated">메서드 호출을 삽입할 유효한 위치가 없습니다.</target>
@@ -2315,6 +2360,16 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
         <target state="translated">접근성 한정자 정렬</target>
         <note />
       </trans-unit>
+      <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
+        <source>Source code language information was not found in PDB.</source>
+        <target state="new">Source code language information was not found in PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Source_is_a_reference_assembly">
+        <source>Source is a reference assembly, not enough information to find PDB.</source>
+        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
         <source>Split into consecutive '{0}' statements</source>
         <target state="translated">연속 '{0}' 문으로 분할</target>
@@ -2340,6 +2395,11 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
         <target state="translated">람다 함수와 로컬 함수 간에 전환하려면 애플리케이션을 다시 시작해야 합니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Symbol_found_in_assembly_path_0">
+        <source>Symbol found in assembly path '{0}'</source>
+        <target state="new">Symbol found in assembly path '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
         <source>TODO: free unmanaged resources (unmanaged objects) and override finalizer</source>
         <target state="translated">TODO: 비관리형 리소스(비관리형 개체)를 해제하고 종료자를 재정의합니다.</target>
@@ -2365,6 +2425,16 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
         <target state="translated">선언이 없는 로컬 함수 호출이 선택 영역에 있습니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Timeout_SourceLink">
+        <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Timeout_symbol_server">
+        <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
         <source>Too many | in (?()|)</source>
         <target state="translated">(?()|)에 |가 너무 많습니다.</target>
@@ -2665,6 +2735,46 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
         <target state="translated">{0} - {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB">
+        <source>'{0}' found in embedded PDB.</source>
+        <target state="new">'{0}' found in embedded PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
+        <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
+        <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
+        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
+        <source>'{0}' found in embedded PDB and found cached source file.</source>
+        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location">
+        <source>'{0}' found in original location.</source>
+        <target state="new">'{0}' found in original location.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location_but_checksum_failed">
+        <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink">
+        <source>'{0}' found via SourceLink.</source>
+        <target state="new">'{0}' found via SourceLink.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
+        <source>'{0}' found via SourceLink but couldn't read temp file.</source>
+        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="_0_is_not_null_here">
         <source>'{0}' is not null here.</source>
         <target state="translated">'{0}'은(는) 여기에서 null이 아닙니다.</target>
@@ -2993,6 +3103,16 @@ If the "d" format specifier is used without other custom format specifiers, it's
         <target state="translated">무시 항목</target>
         <note />
       </trans-unit>
+      <trans-unit id="embedded">
+        <source>embedded</source>
+        <target state="new">embedded</target>
+        <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
+      </trans-unit>
+      <trans-unit id="external">
+        <source>external</source>
+        <target state="new">external</target>
+        <note>External means "external source", meaning source files that are not part of the current solution</note>
+      </trans-unit>
       <trans-unit id="from_metadata">
         <source>from metadata</source>
         <target state="translated">메타데이터에서</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf
index ce3e2f93969db..49e4074b833bc 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf
@@ -470,6 +470,16 @@ Pamiętaj, aby nie używać specyfikatora „tt” dla wszystkich języków, w k
         <target state="translated">Konwertuj typ na „{0}”</target>
         <note />
       </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
+        <source>Could not find portable PDB on disk or embedded.</source>
+        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
+        <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
+        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
         <source>Create and assign field '{0}'</source>
         <target state="translated">Utwórz i przypisz pole „{0}”</target>
@@ -550,6 +560,11 @@ Pamiętaj, aby nie używać specyfikatora „tt” dla wszystkich języków, w k
         <target state="translated">Błąd podczas tworzenia wystąpienia elementu CodeFixProvider „{0}”</target>
         <note />
       </trans-unit>
+      <trans-unit id="Error_reading_PDB_0">
+        <source>Error reading PDB: '{0}'</source>
+        <target state="new">Error reading PDB: '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Example">
         <source>Example:</source>
         <target state="translated">Przykład:</target>
@@ -615,6 +630,26 @@ Pamiętaj, aby nie używać specyfikatora „tt” dla wszystkich języków, w k
         <target state="translated">Trwa formatowanie dokumentu...</target>
         <note />
       </trans-unit>
+      <trans-unit id="Found_PDB_file_at_0">
+        <source>Found PDB file at '{0}'</source>
+        <target state="new">Found PDB file at '{0}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server">
+        <source>Found PDB on symbol server.</source>
+        <target state="new">Found PDB on symbol server.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
+        <source>Found PDB on symbol server but could not read file.</source>
+        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_embedded_PDB_file">
+        <source>Found embedded PDB file.</source>
+        <target state="new">Found embedded PDB file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
         <target state="new">Generate abstract method '{0}'</target>
@@ -1035,6 +1070,11 @@ Pamiętaj, aby nie używać specyfikatora „tt” dla wszystkich języków, w k
         <target state="translated">Przeniesienie elementu {0} wymaga ponownego uruchomienia aplikacji.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigating_to_symbol_0_from_1">
+        <source>Navigating to symbol '{0}' from '{1}'.</source>
+        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Nested_quantifier_0">
         <source>Nested quantifier {0}</source>
         <target state="translated">Zagnieżdżony kwantyfikator {0}</target>
@@ -1045,6 +1085,11 @@ Pamiętaj, aby nie używać specyfikatora „tt” dla wszystkich języków, w k
         <target state="translated">Brak wspólnego węzła głównego do wyodrębnienia.</target>
         <note />
       </trans-unit>
+      <trans-unit id="No_source_document_info_found_in_PDB">
+        <source>No source document info found in PDB.</source>
+        <target state="new">No source document info found in PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
         <source>No valid location to insert method call.</source>
         <target state="translated">Brak prawidłowej lokalizacji dla wstawienia wywołania metody.</target>
@@ -2315,6 +2360,16 @@ Pozytywne asercje wsteczne o zerowej szerokości są zwykle używane na początk
         <target state="translated">Sortuj modyfikatory dostępności</target>
         <note />
       </trans-unit>
+      <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
+        <source>Source code language information was not found in PDB.</source>
+        <target state="new">Source code language information was not found in PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Source_is_a_reference_assembly">
+        <source>Source is a reference assembly, not enough information to find PDB.</source>
+        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
         <source>Split into consecutive '{0}' statements</source>
         <target state="translated">Podziel na kolejne instrukcje „{0}”</target>
@@ -2340,6 +2395,11 @@ Pozytywne asercje wsteczne o zerowej szerokości są zwykle używane na początk
         <target state="translated">Przełączenie między wyrażeniem lambda a funkcją lokalną wymaga ponownego uruchomienia aplikacji.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Symbol_found_in_assembly_path_0">
+        <source>Symbol found in assembly path '{0}'</source>
+        <target state="new">Symbol found in assembly path '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
         <source>TODO: free unmanaged resources (unmanaged objects) and override finalizer</source>
         <target state="translated">TODO: Zwolnić niezarządzane zasoby (niezarządzane obiekty) i przesłonić finalizator</target>
@@ -2365,6 +2425,16 @@ Pozytywne asercje wsteczne o zerowej szerokości są zwykle używane na początk
         <target state="translated">Zaznaczenie zawiera wywołanie funkcji lokalnej bez jego deklaracji.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Timeout_SourceLink">
+        <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Timeout_symbol_server">
+        <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
         <source>Too many | in (?()|)</source>
         <target state="translated">Zbyt wiele znaków | w wyrażeniu (?()|)</target>
@@ -2665,6 +2735,46 @@ Pozytywne asercje wsteczne o zerowej szerokości są zwykle używane na początk
         <target state="translated">{0} - {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB">
+        <source>'{0}' found in embedded PDB.</source>
+        <target state="new">'{0}' found in embedded PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
+        <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
+        <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
+        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
+        <source>'{0}' found in embedded PDB and found cached source file.</source>
+        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location">
+        <source>'{0}' found in original location.</source>
+        <target state="new">'{0}' found in original location.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location_but_checksum_failed">
+        <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink">
+        <source>'{0}' found via SourceLink.</source>
+        <target state="new">'{0}' found via SourceLink.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
+        <source>'{0}' found via SourceLink but couldn't read temp file.</source>
+        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="_0_is_not_null_here">
         <source>'{0}' is not null here.</source>
         <target state="translated">Element „{0}” nie ma wartości null w tym miejscu.</target>
@@ -2993,6 +3103,16 @@ Jeśli specyfikator formatu „d” zostanie użyty bez innych indywidualnych sp
         <target state="translated">odrzuć</target>
         <note />
       </trans-unit>
+      <trans-unit id="embedded">
+        <source>embedded</source>
+        <target state="new">embedded</target>
+        <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
+      </trans-unit>
+      <trans-unit id="external">
+        <source>external</source>
+        <target state="new">external</target>
+        <note>External means "external source", meaning source files that are not part of the current solution</note>
+      </trans-unit>
       <trans-unit id="from_metadata">
         <source>from metadata</source>
         <target state="translated">z metadanych</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf
index 7fabf52e97781..20478d1f97b63 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf
@@ -470,6 +470,16 @@ Verifique se o especificador "tt" foi usado para idiomas para os quais é necess
         <target state="translated">Converter o tipo em '{0}'</target>
         <note />
       </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
+        <source>Could not find portable PDB on disk or embedded.</source>
+        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
+        <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
+        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
         <source>Create and assign field '{0}'</source>
         <target state="translated">Criar e atribuir o campo '{0}'</target>
@@ -550,6 +560,11 @@ Verifique se o especificador "tt" foi usado para idiomas para os quais é necess
         <target state="translated">Erro ao criar instância de CodeFixProvider '{0}'</target>
         <note />
       </trans-unit>
+      <trans-unit id="Error_reading_PDB_0">
+        <source>Error reading PDB: '{0}'</source>
+        <target state="new">Error reading PDB: '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Example">
         <source>Example:</source>
         <target state="translated">Exemplo:</target>
@@ -615,6 +630,26 @@ Verifique se o especificador "tt" foi usado para idiomas para os quais é necess
         <target state="translated">Formatando documento</target>
         <note />
       </trans-unit>
+      <trans-unit id="Found_PDB_file_at_0">
+        <source>Found PDB file at '{0}'</source>
+        <target state="new">Found PDB file at '{0}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server">
+        <source>Found PDB on symbol server.</source>
+        <target state="new">Found PDB on symbol server.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
+        <source>Found PDB on symbol server but could not read file.</source>
+        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_embedded_PDB_file">
+        <source>Found embedded PDB file.</source>
+        <target state="new">Found embedded PDB file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
         <target state="new">Generate abstract method '{0}'</target>
@@ -1035,6 +1070,11 @@ Verifique se o especificador "tt" foi usado para idiomas para os quais é necess
         <target state="translated">Mover {0} requer reiniciar o aplicativo.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigating_to_symbol_0_from_1">
+        <source>Navigating to symbol '{0}' from '{1}'.</source>
+        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Nested_quantifier_0">
         <source>Nested quantifier {0}</source>
         <target state="translated">Quantificador aninhado {0}</target>
@@ -1045,6 +1085,11 @@ Verifique se o especificador "tt" foi usado para idiomas para os quais é necess
         <target state="translated">Nenhum nó de raiz comum para extração.</target>
         <note />
       </trans-unit>
+      <trans-unit id="No_source_document_info_found_in_PDB">
+        <source>No source document info found in PDB.</source>
+        <target state="new">No source document info found in PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
         <source>No valid location to insert method call.</source>
         <target state="translated">Não há nenhum local válido para inserir a chamada de método.</target>
@@ -2315,6 +2360,16 @@ As declarações de lookbehind positivas de largura zero normalmente são usadas
         <target state="translated">Classificar modificadores de acessibilidade</target>
         <note />
       </trans-unit>
+      <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
+        <source>Source code language information was not found in PDB.</source>
+        <target state="new">Source code language information was not found in PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Source_is_a_reference_assembly">
+        <source>Source is a reference assembly, not enough information to find PDB.</source>
+        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
         <source>Split into consecutive '{0}' statements</source>
         <target state="translated">Dividir em instruções '{0}' consecutivas</target>
@@ -2340,6 +2395,11 @@ As declarações de lookbehind positivas de largura zero normalmente são usadas
         <target state="translated">Alternar entre um lambda e uma função local requer a reinicialização do aplicativo.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Symbol_found_in_assembly_path_0">
+        <source>Symbol found in assembly path '{0}'</source>
+        <target state="new">Symbol found in assembly path '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
         <source>TODO: free unmanaged resources (unmanaged objects) and override finalizer</source>
         <target state="new">TODO: free unmanaged resources (unmanaged objects) and override finalizer</target>
@@ -2365,6 +2425,16 @@ As declarações de lookbehind positivas de largura zero normalmente são usadas
         <target state="translated">A seleção contém uma chamada de função local sem sua declaração.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Timeout_SourceLink">
+        <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Timeout_symbol_server">
+        <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
         <source>Too many | in (?()|)</source>
         <target state="translated">Muitos | em (?()|)</target>
@@ -2665,6 +2735,46 @@ As declarações de lookbehind positivas de largura zero normalmente são usadas
         <target state="translated">{0} - {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB">
+        <source>'{0}' found in embedded PDB.</source>
+        <target state="new">'{0}' found in embedded PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
+        <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
+        <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
+        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
+        <source>'{0}' found in embedded PDB and found cached source file.</source>
+        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location">
+        <source>'{0}' found in original location.</source>
+        <target state="new">'{0}' found in original location.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location_but_checksum_failed">
+        <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink">
+        <source>'{0}' found via SourceLink.</source>
+        <target state="new">'{0}' found via SourceLink.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
+        <source>'{0}' found via SourceLink but couldn't read temp file.</source>
+        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="_0_is_not_null_here">
         <source>'{0}' is not null here.</source>
         <target state="translated">'{0}' não é nulo aqui.</target>
@@ -2993,6 +3103,16 @@ Se o especificador de formato "d" for usado sem outros especificadores de format
         <target state="translated">discard</target>
         <note />
       </trans-unit>
+      <trans-unit id="embedded">
+        <source>embedded</source>
+        <target state="new">embedded</target>
+        <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
+      </trans-unit>
+      <trans-unit id="external">
+        <source>external</source>
+        <target state="new">external</target>
+        <note>External means "external source", meaning source files that are not part of the current solution</note>
+      </trans-unit>
       <trans-unit id="from_metadata">
         <source>from metadata</source>
         <target state="translated">de metadados</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf
index 7a188854f2763..7f4407dc96737 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf
@@ -470,6 +470,16 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">Преобразовать тип в "{0}"</target>
         <note />
       </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
+        <source>Could not find portable PDB on disk or embedded.</source>
+        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
+        <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
+        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
         <source>Create and assign field '{0}'</source>
         <target state="translated">Создать и назначить поле "{0}"</target>
@@ -550,6 +560,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">Ошибка при создании экземпляра CodeFixProvider "{0}".</target>
         <note />
       </trans-unit>
+      <trans-unit id="Error_reading_PDB_0">
+        <source>Error reading PDB: '{0}'</source>
+        <target state="new">Error reading PDB: '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Example">
         <source>Example:</source>
         <target state="translated">Пример:</target>
@@ -615,6 +630,26 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">Форматирование документа</target>
         <note />
       </trans-unit>
+      <trans-unit id="Found_PDB_file_at_0">
+        <source>Found PDB file at '{0}'</source>
+        <target state="new">Found PDB file at '{0}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server">
+        <source>Found PDB on symbol server.</source>
+        <target state="new">Found PDB on symbol server.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
+        <source>Found PDB on symbol server but could not read file.</source>
+        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_embedded_PDB_file">
+        <source>Found embedded PDB file.</source>
+        <target state="new">Found embedded PDB file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
         <target state="new">Generate abstract method '{0}'</target>
@@ -1035,6 +1070,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">Для перемещения {0} требуется перезапустить приложение.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigating_to_symbol_0_from_1">
+        <source>Navigating to symbol '{0}' from '{1}'.</source>
+        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Nested_quantifier_0">
         <source>Nested quantifier {0}</source>
         <target state="translated">Вложенный квантификатор {0}</target>
@@ -1045,6 +1085,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">Нет стандартного корневого узла для извлечения.</target>
         <note />
       </trans-unit>
+      <trans-unit id="No_source_document_info_found_in_PDB">
+        <source>No source document info found in PDB.</source>
+        <target state="new">No source document info found in PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
         <source>No valid location to insert method call.</source>
         <target state="translated">Отсутствует допустимое расположение для вставки вызова метода.</target>
@@ -2315,6 +2360,16 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
         <target state="translated">Сортировать модификаторы доступности</target>
         <note />
       </trans-unit>
+      <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
+        <source>Source code language information was not found in PDB.</source>
+        <target state="new">Source code language information was not found in PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Source_is_a_reference_assembly">
+        <source>Source is a reference assembly, not enough information to find PDB.</source>
+        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
         <source>Split into consecutive '{0}' statements</source>
         <target state="translated">Разделить на последовательные операторы "{0}"</target>
@@ -2340,6 +2395,11 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
         <target state="translated">Для переключения между лямбда-выражением и локальной функцией требуется перезапустить приложение.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Symbol_found_in_assembly_path_0">
+        <source>Symbol found in assembly path '{0}'</source>
+        <target state="new">Symbol found in assembly path '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
         <source>TODO: free unmanaged resources (unmanaged objects) and override finalizer</source>
         <target state="translated">TODO: освободить неуправляемые ресурсы (неуправляемые объекты) и переопределить метод завершения</target>
@@ -2365,6 +2425,16 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
         <target state="translated">Выделенный фрагмент содержит вызов локальной функции без ее объявления.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Timeout_SourceLink">
+        <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Timeout_symbol_server">
+        <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
         <source>Too many | in (?()|)</source>
         <target state="translated">Слишком много операторов "|" в "(?()|)"</target>
@@ -2665,6 +2735,46 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
         <target state="translated">{0} - {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB">
+        <source>'{0}' found in embedded PDB.</source>
+        <target state="new">'{0}' found in embedded PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
+        <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
+        <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
+        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
+        <source>'{0}' found in embedded PDB and found cached source file.</source>
+        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location">
+        <source>'{0}' found in original location.</source>
+        <target state="new">'{0}' found in original location.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location_but_checksum_failed">
+        <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink">
+        <source>'{0}' found via SourceLink.</source>
+        <target state="new">'{0}' found via SourceLink.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
+        <source>'{0}' found via SourceLink but couldn't read temp file.</source>
+        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="_0_is_not_null_here">
         <source>'{0}' is not null here.</source>
         <target state="translated">Здесь "{0}" имеет значение, отличное от NULL.</target>
@@ -2993,6 +3103,16 @@ If the "d" format specifier is used without other custom format specifiers, it's
         <target state="translated">отменить</target>
         <note />
       </trans-unit>
+      <trans-unit id="embedded">
+        <source>embedded</source>
+        <target state="new">embedded</target>
+        <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
+      </trans-unit>
+      <trans-unit id="external">
+        <source>external</source>
+        <target state="new">external</target>
+        <note>External means "external source", meaning source files that are not part of the current solution</note>
+      </trans-unit>
       <trans-unit id="from_metadata">
         <source>from metadata</source>
         <target state="translated">из метаданных</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf
index 03643f457100e..f7c69013300f7 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf
@@ -470,6 +470,16 @@ AM ve PM arasındaki farkın korunmasının gerekli olduğu diller için "tt" be
         <target state="translated">Türü '{0}' olarak dönüştür</target>
         <note />
       </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
+        <source>Could not find portable PDB on disk or embedded.</source>
+        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
+        <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
+        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
         <source>Create and assign field '{0}'</source>
         <target state="translated">'{0}' alanını oluştur ve ata</target>
@@ -550,6 +560,11 @@ AM ve PM arasındaki farkın korunmasının gerekli olduğu diller için "tt" be
         <target state="translated">'{0}' CodeFixProvider örneği oluşturulurken hata oluştu</target>
         <note />
       </trans-unit>
+      <trans-unit id="Error_reading_PDB_0">
+        <source>Error reading PDB: '{0}'</source>
+        <target state="new">Error reading PDB: '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Example">
         <source>Example:</source>
         <target state="translated">Örnek:</target>
@@ -615,6 +630,26 @@ AM ve PM arasındaki farkın korunmasının gerekli olduğu diller için "tt" be
         <target state="translated">Belge biçimlendiriliyor</target>
         <note />
       </trans-unit>
+      <trans-unit id="Found_PDB_file_at_0">
+        <source>Found PDB file at '{0}'</source>
+        <target state="new">Found PDB file at '{0}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server">
+        <source>Found PDB on symbol server.</source>
+        <target state="new">Found PDB on symbol server.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
+        <source>Found PDB on symbol server but could not read file.</source>
+        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_embedded_PDB_file">
+        <source>Found embedded PDB file.</source>
+        <target state="new">Found embedded PDB file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
         <target state="new">Generate abstract method '{0}'</target>
@@ -1035,6 +1070,11 @@ AM ve PM arasındaki farkın korunmasının gerekli olduğu diller için "tt" be
         <target state="translated">{0} öğesinin taşınması uygulamanın yeniden başlatılmasını gerektirir.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigating_to_symbol_0_from_1">
+        <source>Navigating to symbol '{0}' from '{1}'.</source>
+        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Nested_quantifier_0">
         <source>Nested quantifier {0}</source>
         <target state="translated">İç içe geçmiş niceleyici {0}</target>
@@ -1045,6 +1085,11 @@ AM ve PM arasındaki farkın korunmasının gerekli olduğu diller için "tt" be
         <target state="translated">Ayıklama için ortak kök düğümü yok.</target>
         <note />
       </trans-unit>
+      <trans-unit id="No_source_document_info_found_in_PDB">
+        <source>No source document info found in PDB.</source>
+        <target state="new">No source document info found in PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
         <source>No valid location to insert method call.</source>
         <target state="translated">Metot çağrısının ekleneceği geçerli konum yok.</target>
@@ -2315,6 +2360,16 @@ Sıfır genişlikli pozitif geri yönlü onaylamalar genellikle normal ifadeleri
         <target state="translated">Erişilebilirlik değiştiricilerini sırala</target>
         <note />
       </trans-unit>
+      <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
+        <source>Source code language information was not found in PDB.</source>
+        <target state="new">Source code language information was not found in PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Source_is_a_reference_assembly">
+        <source>Source is a reference assembly, not enough information to find PDB.</source>
+        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
         <source>Split into consecutive '{0}' statements</source>
         <target state="translated">Ardışık '{0}' deyimlerine ayır</target>
@@ -2340,6 +2395,11 @@ Sıfır genişlikli pozitif geri yönlü onaylamalar genellikle normal ifadeleri
         <target state="translated">Bir lambda ve yerel bir işlev arasında geçiş yapılması, uygulamanın yeniden başlatılmasını gerektirir.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Symbol_found_in_assembly_path_0">
+        <source>Symbol found in assembly path '{0}'</source>
+        <target state="new">Symbol found in assembly path '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
         <source>TODO: free unmanaged resources (unmanaged objects) and override finalizer</source>
         <target state="translated">TODO: yönetilmeyen kaynakları (yönetilmeyen nesneleri) serbest bırakın ve sonlandırıcıyı geçersiz kılın</target>
@@ -2365,6 +2425,16 @@ Sıfır genişlikli pozitif geri yönlü onaylamalar genellikle normal ifadeleri
         <target state="translated">Seçim, bildirimi olmadan bir yerel işlev çağrısı içeriyor.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Timeout_SourceLink">
+        <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Timeout_symbol_server">
+        <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
         <source>Too many | in (?()|)</source>
         <target state="translated">Çok fazla | içinde (?) (|)</target>
@@ -2665,6 +2735,46 @@ Sıfır genişlikli pozitif geri yönlü onaylamalar genellikle normal ifadeleri
         <target state="translated">{0} - {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB">
+        <source>'{0}' found in embedded PDB.</source>
+        <target state="new">'{0}' found in embedded PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
+        <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
+        <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
+        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
+        <source>'{0}' found in embedded PDB and found cached source file.</source>
+        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location">
+        <source>'{0}' found in original location.</source>
+        <target state="new">'{0}' found in original location.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location_but_checksum_failed">
+        <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink">
+        <source>'{0}' found via SourceLink.</source>
+        <target state="new">'{0}' found via SourceLink.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
+        <source>'{0}' found via SourceLink but couldn't read temp file.</source>
+        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="_0_is_not_null_here">
         <source>'{0}' is not null here.</source>
         <target state="translated">'{0}' burada null değil.</target>
@@ -2993,6 +3103,16 @@ If the "d" format specifier is used without other custom format specifiers, it's
         <target state="translated">at</target>
         <note />
       </trans-unit>
+      <trans-unit id="embedded">
+        <source>embedded</source>
+        <target state="new">embedded</target>
+        <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
+      </trans-unit>
+      <trans-unit id="external">
+        <source>external</source>
+        <target state="new">external</target>
+        <note>External means "external source", meaning source files that are not part of the current solution</note>
+      </trans-unit>
       <trans-unit id="from_metadata">
         <source>from metadata</source>
         <target state="translated">meta verilerden</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf
index c1a837e7a92a7..a3567a2002967 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf
@@ -470,6 +470,16 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">将类型转换为“{0}”</target>
         <note />
       </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
+        <source>Could not find portable PDB on disk or embedded.</source>
+        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
+        <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
+        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
         <source>Create and assign field '{0}'</source>
         <target state="translated">创建字段 "{0}" 并赋值</target>
@@ -550,6 +560,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">创建 CodeFixProvider“{0}”的实例时出错</target>
         <note />
       </trans-unit>
+      <trans-unit id="Error_reading_PDB_0">
+        <source>Error reading PDB: '{0}'</source>
+        <target state="new">Error reading PDB: '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Example">
         <source>Example:</source>
         <target state="translated">示例:</target>
@@ -615,6 +630,26 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">设置文档格式</target>
         <note />
       </trans-unit>
+      <trans-unit id="Found_PDB_file_at_0">
+        <source>Found PDB file at '{0}'</source>
+        <target state="new">Found PDB file at '{0}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server">
+        <source>Found PDB on symbol server.</source>
+        <target state="new">Found PDB on symbol server.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
+        <source>Found PDB on symbol server but could not read file.</source>
+        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_embedded_PDB_file">
+        <source>Found embedded PDB file.</source>
+        <target state="new">Found embedded PDB file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
         <target state="new">Generate abstract method '{0}'</target>
@@ -1035,6 +1070,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">移动 {0} 要求重启应用程序。</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigating_to_symbol_0_from_1">
+        <source>Navigating to symbol '{0}' from '{1}'.</source>
+        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Nested_quantifier_0">
         <source>Nested quantifier {0}</source>
         <target state="translated">嵌套限定符 {0}</target>
@@ -1045,6 +1085,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">没有可用于提取的公共根节点。</target>
         <note />
       </trans-unit>
+      <trans-unit id="No_source_document_info_found_in_PDB">
+        <source>No source document info found in PDB.</source>
+        <target state="new">No source document info found in PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
         <source>No valid location to insert method call.</source>
         <target state="translated">没有插入方法调用的有效位置。</target>
@@ -2315,6 +2360,16 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
         <target state="translated">对可访问性修饰符排序</target>
         <note />
       </trans-unit>
+      <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
+        <source>Source code language information was not found in PDB.</source>
+        <target state="new">Source code language information was not found in PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Source_is_a_reference_assembly">
+        <source>Source is a reference assembly, not enough information to find PDB.</source>
+        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
         <source>Split into consecutive '{0}' statements</source>
         <target state="translated">拆分为连续的 "{0}" 语句</target>
@@ -2340,6 +2395,11 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
         <target state="translated">在 lambda 和本地函数之间切换需要重启应用程序。</target>
         <note />
       </trans-unit>
+      <trans-unit id="Symbol_found_in_assembly_path_0">
+        <source>Symbol found in assembly path '{0}'</source>
+        <target state="new">Symbol found in assembly path '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
         <source>TODO: free unmanaged resources (unmanaged objects) and override finalizer</source>
         <target state="translated">TODO: 释放未托管的资源(未托管的对象)并重写终结器</target>
@@ -2365,6 +2425,16 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
         <target state="translated">所选内容包含不带声明的本地函数调用。</target>
         <note />
       </trans-unit>
+      <trans-unit id="Timeout_SourceLink">
+        <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Timeout_symbol_server">
+        <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
         <source>Too many | in (?()|)</source>
         <target state="translated">(?()|) 中的 | 太多</target>
@@ -2665,6 +2735,46 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
         <target state="translated">{0} - {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB">
+        <source>'{0}' found in embedded PDB.</source>
+        <target state="new">'{0}' found in embedded PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
+        <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
+        <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
+        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
+        <source>'{0}' found in embedded PDB and found cached source file.</source>
+        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location">
+        <source>'{0}' found in original location.</source>
+        <target state="new">'{0}' found in original location.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location_but_checksum_failed">
+        <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink">
+        <source>'{0}' found via SourceLink.</source>
+        <target state="new">'{0}' found via SourceLink.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
+        <source>'{0}' found via SourceLink but couldn't read temp file.</source>
+        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="_0_is_not_null_here">
         <source>'{0}' is not null here.</source>
         <target state="translated">“{0}”在此处不为 null。</target>
@@ -2993,6 +3103,16 @@ If the "d" format specifier is used without other custom format specifiers, it's
         <target state="translated">放弃</target>
         <note />
       </trans-unit>
+      <trans-unit id="embedded">
+        <source>embedded</source>
+        <target state="new">embedded</target>
+        <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
+      </trans-unit>
+      <trans-unit id="external">
+        <source>external</source>
+        <target state="new">external</target>
+        <note>External means "external source", meaning source files that are not part of the current solution</note>
+      </trans-unit>
       <trans-unit id="from_metadata">
         <source>from metadata</source>
         <target state="translated">从元数据</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf
index c6005c0beac52..4b1b6c5456124 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf
@@ -470,6 +470,16 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">將類型轉換為 '{0}'</target>
         <note />
       </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
+        <source>Could not find portable PDB on disk or embedded.</source>
+        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
+        <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
+        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
         <source>Create and assign field '{0}'</source>
         <target state="translated">建立並指派欄位 '{0}'</target>
@@ -550,6 +560,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">建立 CodeFixProvider '{0}' 的執行個體時發生錯誤</target>
         <note />
       </trans-unit>
+      <trans-unit id="Error_reading_PDB_0">
+        <source>Error reading PDB: '{0}'</source>
+        <target state="new">Error reading PDB: '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Example">
         <source>Example:</source>
         <target state="translated">範例:</target>
@@ -615,6 +630,26 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">正在將文件格式化</target>
         <note />
       </trans-unit>
+      <trans-unit id="Found_PDB_file_at_0">
+        <source>Found PDB file at '{0}'</source>
+        <target state="new">Found PDB file at '{0}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server">
+        <source>Found PDB on symbol server.</source>
+        <target state="new">Found PDB on symbol server.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
+        <source>Found PDB on symbol server but could not read file.</source>
+        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Found_embedded_PDB_file">
+        <source>Found embedded PDB file.</source>
+        <target state="new">Found embedded PDB file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
         <target state="new">Generate abstract method '{0}'</target>
@@ -1035,6 +1070,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">移動 {0} 需要重新啟動應用程式。</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigating_to_symbol_0_from_1">
+        <source>Navigating to symbol '{0}' from '{1}'.</source>
+        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Nested_quantifier_0">
         <source>Nested quantifier {0}</source>
         <target state="translated">巢狀數量詞 {0}</target>
@@ -1045,6 +1085,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="translated">沒有根節點可供擷取。</target>
         <note />
       </trans-unit>
+      <trans-unit id="No_source_document_info_found_in_PDB">
+        <source>No source document info found in PDB.</source>
+        <target state="new">No source document info found in PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
         <source>No valid location to insert method call.</source>
         <target state="translated">沒有可插入方法呼叫的有效位置。</target>
@@ -2315,6 +2360,16 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
         <target state="translated">排序協助工具修飾元</target>
         <note />
       </trans-unit>
+      <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
+        <source>Source code language information was not found in PDB.</source>
+        <target state="new">Source code language information was not found in PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Source_is_a_reference_assembly">
+        <source>Source is a reference assembly, not enough information to find PDB.</source>
+        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
         <source>Split into consecutive '{0}' statements</source>
         <target state="translated">分割成連續的 '{0}' 陳述式</target>
@@ -2340,6 +2395,11 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
         <target state="translated">在 Lambda 運算式和本機函式之間切換需要重新啟動應用程式。</target>
         <note />
       </trans-unit>
+      <trans-unit id="Symbol_found_in_assembly_path_0">
+        <source>Symbol found in assembly path '{0}'</source>
+        <target state="new">Symbol found in assembly path '{0}'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
         <source>TODO: free unmanaged resources (unmanaged objects) and override finalizer</source>
         <target state="translated">TODO: 釋出非受控資源 (非受控物件) 並覆寫完成項</target>
@@ -2365,6 +2425,16 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
         <target state="translated">選取範圍包含區域函式呼叫，但不含其宣告。</target>
         <note />
       </trans-unit>
+      <trans-unit id="Timeout_SourceLink">
+        <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Timeout_symbol_server">
+        <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
+        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
         <source>Too many | in (?()|)</source>
         <target state="translated">(?()|) 中太多 |</target>
@@ -2665,6 +2735,46 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
         <target state="translated">{0} - {1}</target>
         <note />
       </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB">
+        <source>'{0}' found in embedded PDB.</source>
+        <target state="new">'{0}' found in embedded PDB.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
+        <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
+        <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
+        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
+        <source>'{0}' found in embedded PDB and found cached source file.</source>
+        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location">
+        <source>'{0}' found in original location.</source>
+        <target state="new">'{0}' found in original location.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_in_original_location_but_checksum_failed">
+        <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
+        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink">
+        <source>'{0}' found via SourceLink.</source>
+        <target state="new">'{0}' found via SourceLink.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
+        <source>'{0}' found via SourceLink but couldn't read temp file.</source>
+        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="_0_is_not_null_here">
         <source>'{0}' is not null here.</source>
         <target state="translated">'{0}' 在此不是 null。</target>
@@ -2993,6 +3103,16 @@ If the "d" format specifier is used without other custom format specifiers, it's
         <target state="translated">捨棄</target>
         <note />
       </trans-unit>
+      <trans-unit id="embedded">
+        <source>embedded</source>
+        <target state="new">embedded</target>
+        <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
+      </trans-unit>
+      <trans-unit id="external">
+        <source>external</source>
+        <target state="new">external</target>
+        <note>External means "external source", meaning source files that are not part of the current solution</note>
+      </trans-unit>
       <trans-unit id="from_metadata">
         <source>from metadata</source>
         <target state="translated">來自中繼資料</target>
diff --git a/src/VisualStudio/Core/Def/PdbSourceDocument/PdbSourceDocumentOutputWindowLogger.cs b/src/VisualStudio/Core/Def/PdbSourceDocument/PdbSourceDocumentOutputWindowLogger.cs
new file mode 100644
index 0000000000000..9a677e60834d1
--- /dev/null
+++ b/src/VisualStudio/Core/Def/PdbSourceDocument/PdbSourceDocumentOutputWindowLogger.cs
@@ -0,0 +1,119 @@
+// 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.Immutable;
+using System.Composition;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
+using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.PdbSourceDocument;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
+using Microsoft.VisualStudio.Shell;
+using Microsoft.VisualStudio.Shell.Interop;
+using Roslyn.Utilities;
+
+namespace Microsoft.VisualStudio.LanguageServices.PdbSourceDocument
+{
+    [Export(typeof(IPdbSourceDocumentLogger)), Shared]
+    internal sealed class PdbSourceDocumentOutputWindowLogger : IPdbSourceDocumentLogger, IDisposable
+    {
+        private static readonly Guid s_outputPaneGuid = new Guid("f543e896-2e9c-48b8-8fac-d1d5030b4b89");
+        private IVsOutputWindowPane? _outputPane;
+
+        private readonly IThreadingContext _threadingContext;
+        private readonly AsyncBatchingWorkQueue<string> _logItemsQueue;
+        private readonly IServiceProvider _serviceProvider;
+
+        private readonly CancellationTokenSource _cancellationTokenSource = new();
+
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public PdbSourceDocumentOutputWindowLogger(SVsServiceProvider serviceProvider, IThreadingContext threadingContext, IAsynchronousOperationListenerProvider listenerProvider)
+        {
+            _serviceProvider = serviceProvider;
+            _threadingContext = threadingContext;
+
+            var asyncListener = listenerProvider.GetListener(nameof(PdbSourceDocumentOutputWindowLogger));
+
+            _logItemsQueue = new AsyncBatchingWorkQueue<string>(
+                TimeSpan.FromMilliseconds(TaggerConstants.NearImmediateDelay),
+                ProcessLogMessagesAsync,
+                asyncListener,
+                _cancellationTokenSource.Token);
+        }
+
+        private async ValueTask ProcessLogMessagesAsync(ImmutableArray<string> messages, CancellationToken cancellationToken)
+        {
+            await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+
+            foreach (var message in messages)
+            {
+                var pane = GetPane();
+                if (pane == null)
+                {
+                    return;
+                }
+
+                if (pane is IVsOutputWindowPaneNoPump noPumpPane)
+                {
+                    noPumpPane.OutputStringNoPump(message + Environment.NewLine);
+                }
+                else
+                {
+                    pane.OutputStringThreadSafe(message + Environment.NewLine);
+                }
+            }
+        }
+
+        public async Task ClearAsync()
+        {
+            await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync();
+
+            GetPane()?.Clear();
+        }
+
+        public void Log(string value)
+        {
+            _logItemsQueue.AddWork(value);
+        }
+
+        private IVsOutputWindowPane? GetPane()
+        {
+            _threadingContext.ThrowIfNotOnUIThread();
+
+            if (_outputPane == null)
+            {
+                var outputWindow = (IVsOutputWindow)_serviceProvider.GetService(typeof(SVsOutputWindow));
+
+                _outputPane = TryCreateOutputPane(outputWindow);
+            }
+
+            return _outputPane;
+        }
+
+        private IVsOutputWindowPane? TryCreateOutputPane(IVsOutputWindow outputWindow)
+        {
+            _threadingContext.ThrowIfNotOnUIThread();
+
+            var paneGuid = s_outputPaneGuid;
+
+            if (ErrorHandler.Succeeded(outputWindow.CreatePane(ref paneGuid, ServicesVSResources.Navigate_to_external_sources, fInitVisible: 1, fClearWithSolution: 1)) &&
+                ErrorHandler.Succeeded(outputWindow.GetPane(ref paneGuid, out var pane)))
+            {
+                return pane;
+            }
+
+            return null;
+        }
+
+        void IDisposable.Dispose()
+        {
+            _cancellationTokenSource.Cancel();
+        }
+    }
+}
diff --git a/src/VisualStudio/Core/Def/PdbSourceDocument/SourceLinkService.cs b/src/VisualStudio/Core/Def/PdbSourceDocument/SourceLinkService.cs
index 3ee480ca0f0b8..b6ec09ea25b7a 100644
--- a/src/VisualStudio/Core/Def/PdbSourceDocument/SourceLinkService.cs
+++ b/src/VisualStudio/Core/Def/PdbSourceDocument/SourceLinkService.cs
@@ -21,16 +21,21 @@ internal class SourceLinkService : ISourceLinkService
     {
         private readonly IDebuggerSymbolLocatorService _debuggerSymbolLocatorService;
         private readonly IDebuggerSourceLinkService _debuggerSourceLinkService;
+        private readonly IPdbSourceDocumentLogger? _logger;
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public SourceLinkService(IDebuggerSymbolLocatorService debuggerSymbolLocatorService, IDebuggerSourceLinkService debuggerSourceLinkService)
+        public SourceLinkService(
+            IDebuggerSymbolLocatorService debuggerSymbolLocatorService,
+            IDebuggerSourceLinkService debuggerSourceLinkService,
+            [Import(AllowDefault = true)] IPdbSourceDocumentLogger? logger)
         {
             _debuggerSymbolLocatorService = debuggerSymbolLocatorService;
             _debuggerSourceLinkService = debuggerSourceLinkService;
+            _logger = logger;
         }
 
-        public async Task<PdbFilePathResult?> GetPdbFilePathAsync(string dllPath, PEReader peReader, IPdbSourceDocumentLogger? logger, CancellationToken cancellationToken)
+        public async Task<PdbFilePathResult?> GetPdbFilePathAsync(string dllPath, PEReader peReader, CancellationToken cancellationToken)
         {
             var hasCodeViewEntry = false;
             uint timeStamp = 0;
@@ -66,29 +71,34 @@ public SourceLinkService(IDebuggerSymbolLocatorService debuggerSymbolLocatorServ
             var flags = SymbolLocatorSearchFlags.None; // TODO: Add option to specify ForceMsftSymbolServer and ForceNuGetSymbolServer: https://github.com/dotnet/roslyn/issues/55834
             var result = await _debuggerSymbolLocatorService.LocateSymbolFileAsync(pdbInfo, flags, progress: null, cancellationToken).ConfigureAwait(false);
 
-            // TODO: Logging: https://github.com/dotnet/roslyn/issues/57352
             if (result.Found && result.SymbolFilePath is not null)
             {
-                return new PdbFilePathResult(
-                    result.SymbolFilePath,
-                    result.Status,
-                    result.Log,
-                    result.IsPortablePdb);
+                return new PdbFilePathResult(result.SymbolFilePath);
+            }
+            else if (_logger is not null)
+            {
+                // We log specific info from the debugger if there is a failure, but the caller will log general failure
+                // information otherwise
+                _logger.Log(result.Status);
+                _logger.Log(result.Log);
             }
 
             return null;
         }
 
-        public async Task<SourceFilePathResult?> GetSourceFilePathAsync(string url, string relativePath, IPdbSourceDocumentLogger? logger, CancellationToken cancellationToken)
+        public async Task<SourceFilePathResult?> GetSourceFilePathAsync(string url, string relativePath, CancellationToken cancellationToken)
         {
             var result = await _debuggerSourceLinkService.GetSourceLinkAsync(url, relativePath, allowInteractiveLogin: false, cancellationToken).ConfigureAwait(false);
 
-            // TODO: Logging: https://github.com/dotnet/roslyn/issues/57352
             if (result.Status == SourceLinkResultStatus.Succeeded && result.Path is not null)
             {
-                return new SourceFilePathResult(
-                    result.Path,
-                    result.Log);
+                return new SourceFilePathResult(result.Path);
+            }
+            else if (_logger is not null && result.Log is not null)
+            {
+                // We log specific info from the debugger if there is a failure, but the caller will log general failure
+                // information otherwise.
+                _logger.Log(result.Log);
             }
 
             return null;
diff --git a/src/VisualStudio/Core/Def/ServicesVSResources.resx b/src/VisualStudio/Core/Def/ServicesVSResources.resx
index 99f0bf3cdc283..6a1d1178d5642 100644
--- a/src/VisualStudio/Core/Def/ServicesVSResources.resx
+++ b/src/VisualStudio/Core/Def/ServicesVSResources.resx
@@ -1893,6 +1893,9 @@ Additional information: {1}</value>
   <data name="Sort_usings" xml:space="preserve">
     <value>Sort usings</value>
   </data>
+  <data name="Navigate_to_external_sources" xml:space="preserve">
+    <value>Navigate to External Sources</value>
+  </data>
   <data name="Automatically_open_stack_trace_explorer_on_focus" xml:space="preserve">
     <value>Automatically open Stack Trace Explorer on focus</value>
     <comment>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</comment>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
index a1a2fba8caef9..df778c63825d8 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
@@ -807,6 +807,11 @@
         <target state="translated">Přejít na {0}</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigate_to_external_sources">
+        <source>Navigate to External Sources</source>
+        <target state="new">Navigate to External Sources</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Never">
         <source>Never</source>
         <target state="translated">Nikdy</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
index 17acfefd75459..e685b1c144ccc 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
@@ -807,6 +807,11 @@
         <target state="translated">Zu "{0}" navigieren</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigate_to_external_sources">
+        <source>Navigate to External Sources</source>
+        <target state="new">Navigate to External Sources</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Never">
         <source>Never</source>
         <target state="translated">Nie</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
index e66e54489d3ff..5565e745ace81 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
@@ -807,6 +807,11 @@
         <target state="translated">Navegar a "{0}"</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigate_to_external_sources">
+        <source>Navigate to External Sources</source>
+        <target state="new">Navigate to External Sources</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Never">
         <source>Never</source>
         <target state="translated">Nunca</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
index 2adcc0cc2a0b5..e348189b66c9b 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
@@ -807,6 +807,11 @@
         <target state="translated">Accéder à « {0} »</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigate_to_external_sources">
+        <source>Navigate to External Sources</source>
+        <target state="new">Navigate to External Sources</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Never">
         <source>Never</source>
         <target state="translated">Jamais</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
index c216ff9049a8c..a3ebd3f58a5d6 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
@@ -807,6 +807,11 @@
         <target state="translated">Passa a '{0}'</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigate_to_external_sources">
+        <source>Navigate to External Sources</source>
+        <target state="new">Navigate to External Sources</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Never">
         <source>Never</source>
         <target state="translated">Mai</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
index 98dace0bb8d25..faee62cd5097f 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
@@ -807,6 +807,11 @@
         <target state="translated">'{0}' に移動する</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigate_to_external_sources">
+        <source>Navigate to External Sources</source>
+        <target state="new">Navigate to External Sources</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Never">
         <source>Never</source>
         <target state="translated">行わない</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
index fd05aa83fe9f1..06edf212428cb 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
@@ -807,6 +807,11 @@
         <target state="translated">'{0}'(으)로 이동</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigate_to_external_sources">
+        <source>Navigate to External Sources</source>
+        <target state="new">Navigate to External Sources</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Never">
         <source>Never</source>
         <target state="translated">안 함 </target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
index 0ddba4e985aaa..39888b6f8488a 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
@@ -807,6 +807,11 @@
         <target state="translated">Przejdź do pozycji „{0}”</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigate_to_external_sources">
+        <source>Navigate to External Sources</source>
+        <target state="new">Navigate to External Sources</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Never">
         <source>Never</source>
         <target state="translated">Nigdy</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
index 9add1988505a2..dd99807fd6fff 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
@@ -807,6 +807,11 @@
         <target state="translated">Navegar até '{0}'</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigate_to_external_sources">
+        <source>Navigate to External Sources</source>
+        <target state="new">Navigate to External Sources</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Never">
         <source>Never</source>
         <target state="translated">Nunca</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
index 9c7d557275eb6..7c068c8957bc7 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
@@ -807,6 +807,11 @@
         <target state="translated">Перейти к {0}</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigate_to_external_sources">
+        <source>Navigate to External Sources</source>
+        <target state="new">Navigate to External Sources</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Never">
         <source>Never</source>
         <target state="translated">Никогда </target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
index 4e4a8c8afc9bc..7882300342bf9 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
@@ -807,6 +807,11 @@
         <target state="translated">'{0}' öğesine git</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigate_to_external_sources">
+        <source>Navigate to External Sources</source>
+        <target state="new">Navigate to External Sources</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Never">
         <source>Never</source>
         <target state="translated">Hiçbir zaman</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
index cce00152d85db..0951bb542085b 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
@@ -807,6 +807,11 @@
         <target state="translated">导航到“{0}”</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigate_to_external_sources">
+        <source>Navigate to External Sources</source>
+        <target state="new">Navigate to External Sources</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Never">
         <source>Never</source>
         <target state="translated">从不</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
index baddfc2a38ded..a595d1d5b8f43 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
@@ -807,6 +807,11 @@
         <target state="translated">瀏覽至 '{0}'</target>
         <note />
       </trans-unit>
+      <trans-unit id="Navigate_to_external_sources">
+        <source>Navigate to External Sources</source>
+        <target state="new">Navigate to External Sources</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Never">
         <source>Never</source>
         <target state="translated">永不</target>
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/FunctionId.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/FunctionId.cs
index 081c383687dcb..627d278bb27a6 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/FunctionId.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/FunctionId.cs
@@ -534,5 +534,7 @@ internal enum FunctionId
         NavigateTo_CacheItemsMiss = 510,
 
         AssetService_Perf = 520,
+
+        NavigateToExternalSources = 531,
     }
 }

From 9ff9adee8066e387cfdd349f0e62f7abba97dd37 Mon Sep 17 00:00:00 2001
From: Shen Chen <shech@microsoft.com>
Date: Tue, 4 Jan 2022 20:45:41 -0800
Subject: [PATCH 230/444] Update config files

---
 eng/Versions.props          | 4 ++--
 eng/config/PublishData.json | 7 ++++---
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/eng/Versions.props b/eng/Versions.props
index f0ffd74e8c5fe..a805334356202 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -6,9 +6,9 @@
   -->
   <PropertyGroup>
     <MajorVersion>4</MajorVersion>
-    <MinorVersion>1</MinorVersion>
+    <MinorVersion>2</MinorVersion>
     <PatchVersion>0</PatchVersion>
-    <PreReleaseVersionLabel>3</PreReleaseVersionLabel>
+    <PreReleaseVersionLabel>1</PreReleaseVersionLabel>
     <VersionPrefix>$(MajorVersion).$(MinorVersion).$(PatchVersion)</VersionPrefix>
     <!--
       By default the assembly version in official builds is "$(MajorVersion).$(MinorVersion).0.0".
diff --git a/eng/config/PublishData.json b/eng/config/PublishData.json
index d075f634eae0b..ebf02b67bf5e5 100644
--- a/eng/config/PublishData.json
+++ b/eng/config/PublishData.json
@@ -210,7 +210,8 @@
       "channels": [],
       "vsBranch": "rel/d17.1",
       "vsMajorVersion": 17,
-      "insertionTitlePrefix": "[d17.1p2]"
+      "insertionCreateDraftPR": true,
+      "insertionTitlePrefix": "[d17.1p3]"
     },
     "main-vs-deps": {
       "nugetKind": [
@@ -222,8 +223,8 @@
       "channels": [],
       "vsBranch": "main",
       "vsMajorVersion": 17,
-      "insertionCreateDraftPR": false,
-      "insertionTitlePrefix": "[d17.1p3]"
+      "insertionCreateDraftPR": true,
+      "insertionTitlePrefix": "[d17.2p1]"
     },
     "main": {
       "nugetKind": [

From dfadb8b6dadf2d32f4e061a8af06f580dc0eebfd 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: Tue, 4 Jan 2022 21:58:41 -0800
Subject: [PATCH 231/444] Remove FileTextLoaderOptions (#58596)

---
 .../Core/Portable/Workspace/FileTextLoader.cs | 49 +++++--------------
 .../CoreTest/SolutionTests/SolutionTests.cs   | 20 +++++---
 2 files changed, 25 insertions(+), 44 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/FileTextLoader.cs b/src/Workspaces/Core/Portable/Workspace/FileTextLoader.cs
index c36c00aa2ae9c..40bd368fd8c6f 100644
--- a/src/Workspaces/Core/Portable/Workspace/FileTextLoader.cs
+++ b/src/Workspaces/Core/Portable/Workspace/FileTextLoader.cs
@@ -3,50 +3,18 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
-using System.Collections.Immutable;
-using System.Composition;
 using System.Diagnostics;
 using System.IO;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
-using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Internal.Log;
-using Microsoft.CodeAnalysis.Options;
-using Microsoft.CodeAnalysis.Options.Providers;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis
 {
-    internal static class FileTextLoaderOptions
-    {
-        /// <summary>
-        /// Hidden registry key to control maximum size of a text file we will read into memory. 
-        /// we have this option to reduce a chance of OOM when user adds massive size files to the solution.
-        /// Default threshold is 100MB which came from some internal data on big files and some discussion.
-        /// 
-        /// User can override default value by setting DWORD value on FileLengthThreshold in 
-        /// "[VS HIVE]\Roslyn\Internal\Performance\Text"
-        /// </summary>
-        internal static readonly Option<long> FileLengthThreshold = new(nameof(FileTextLoaderOptions), nameof(FileLengthThreshold), defaultValue: 100 * 1024 * 1024,
-            storageLocation: new LocalUserProfileStorageLocation(@"Roslyn\Internal\Performance\Text\FileLengthThreshold"));
-    }
-
-    [ExportSolutionOptionProvider, Shared]
-    internal class FileTextLoaderOptionsProvider : IOptionProvider
-    {
-        [ImportingConstructor]
-        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public FileTextLoaderOptionsProvider()
-        {
-        }
-
-        public ImmutableArray<IOption> Options { get; } = ImmutableArray.Create<IOption>(
-            FileTextLoaderOptions.FileLengthThreshold);
-    }
-
     [DebuggerDisplay("{GetDebuggerDisplay(), nq}")]
     public class FileTextLoader : TextLoader
     {
@@ -82,6 +50,12 @@ public FileTextLoader(string path, Encoding? defaultEncoding)
             DefaultEncoding = defaultEncoding;
         }
 
+        /// <summary>
+        /// We have this limit on file size to reduce a chance of OOM when user adds massive files to the solution (often by accident).
+        /// The threshold is 100MB which came from some internal data on big files and some discussion.
+        /// </summary>
+        internal virtual int MaxFileLength => 100 * 1024 * 1024;
+
         internal sealed override string FilePath => Path;
 
         protected virtual SourceText CreateText(Stream stream, Workspace workspace)
@@ -97,7 +71,7 @@ protected virtual SourceText CreateText(Stream stream, Workspace workspace)
         /// <exception cref="InvalidDataException"></exception>
         public override async Task<TextAndVersion> LoadTextAndVersionAsync(Workspace workspace, DocumentId documentId, CancellationToken cancellationToken)
         {
-            ValidateFileLength(workspace, Path);
+            ValidateFileLength(Path);
 
             var prevLastWriteTime = FileUtilities.GetFileTimeStamp(Path);
 
@@ -201,7 +175,7 @@ public override async Task<TextAndVersion> LoadTextAndVersionAsync(Workspace wor
         /// <exception cref="InvalidDataException"></exception>
         internal override TextAndVersion LoadTextAndVersionSynchronously(Workspace workspace, DocumentId documentId, CancellationToken cancellationToken)
         {
-            ValidateFileLength(workspace, Path);
+            ValidateFileLength(Path);
 
             var prevLastWriteTime = FileUtilities.GetFileTimeStamp(Path);
 
@@ -232,7 +206,7 @@ internal override TextAndVersion LoadTextAndVersionSynchronously(Workspace works
         private string GetDebuggerDisplay()
             => nameof(Path) + " = " + Path;
 
-        private static void ValidateFileLength(Workspace workspace, string path)
+        private void ValidateFileLength(string path)
         {
             // Validate file length is under our threshold. 
             // Otherwise, rather than reading the content into the memory, we will throw
@@ -242,8 +216,7 @@ private static void ValidateFileLength(Workspace workspace, string path)
             // check this (http://source.roslyn.io/#Microsoft.CodeAnalysis.Workspaces/Workspace/Solution/TextDocumentState.cs,132)
             // to see how workspace deal with exception from FileTextLoader. other consumer can handle the exception differently
             var fileLength = FileUtilities.GetFileLength(path);
-            var threshold = workspace.Options.GetOption(FileTextLoaderOptions.FileLengthThreshold);
-            if (fileLength > threshold)
+            if (fileLength > MaxFileLength)
             {
                 // log max file length which will log to VS telemetry in VS host
                 Logger.Log(FunctionId.FileTextLoader_FileLengthThresholdExceeded, KeyValueLogMessage.Create(m =>
@@ -252,7 +225,7 @@ private static void ValidateFileLength(Workspace workspace, string path)
                     m["Ext"] = PathUtilities.GetExtension(path);
                 }));
 
-                var message = string.Format(WorkspacesResources.File_0_size_of_1_exceeds_maximum_allowed_size_of_2, path, fileLength, threshold);
+                var message = string.Format(WorkspacesResources.File_0_size_of_1_exceeds_maximum_allowed_size_of_2, path, fileLength, MaxFileLength);
                 throw new InvalidDataException(message);
             }
         }
diff --git a/src/Workspaces/CoreTest/SolutionTests/SolutionTests.cs b/src/Workspaces/CoreTest/SolutionTests/SolutionTests.cs
index 4ec50961078f4..63fd6e05e3255 100644
--- a/src/Workspaces/CoreTest/SolutionTests/SolutionTests.cs
+++ b/src/Workspaces/CoreTest/SolutionTests/SolutionTests.cs
@@ -2661,22 +2661,30 @@ public void TestProjectCompletenessWithMultipleProjects()
             Assert.True(transitivelyDependsOnNormalProjects.HasSuccessfullyLoadedAsync().Result);
         }
 
+        private class TestSmallFileTextLoader : FileTextLoader
+        {
+            public TestSmallFileTextLoader(string path, Encoding encoding)
+                : base(path, encoding)
+            {
+            }
+
+            // set max file length to 1 byte
+            internal override int MaxFileLength => 1;
+        }
+
         [Fact]
         public async Task TestMassiveFileSize()
         {
-            // set max file length to 1 bytes
-            var maxLength = 1;
             var workspace = new AdhocWorkspace();
-            workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options
-                .WithChangedOption(FileTextLoaderOptions.FileLengthThreshold, maxLength)));
 
             using var root = new TempRoot();
             var file = root.CreateFile(prefix: "massiveFile", extension: ".cs").WriteAllText("hello");
 
-            var loader = new FileTextLoader(file.Path, Encoding.UTF8);
+            var loader = new TestSmallFileTextLoader(file.Path, Encoding.UTF8);
+
             var textLength = FileUtilities.GetFileLength(file.Path);
 
-            var expected = string.Format(WorkspacesResources.File_0_size_of_1_exceeds_maximum_allowed_size_of_2, file.Path, textLength, maxLength);
+            var expected = string.Format(WorkspacesResources.File_0_size_of_1_exceeds_maximum_allowed_size_of_2, file.Path, textLength, 1);
             var exceptionThrown = false;
 
             try

From a9cdf7f0091ce8f0abecdd78eea693fb9043330b 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, 5 Jan 2022 07:39:16 -0800
Subject: [PATCH 232/444] Call InitializeTelemetrySession on background thread
 (#58399)

---
 .../VisualStudioWorkspaceImpl.cs              | 20 +++++++++++++++++++
 src/VisualStudio/Core/Def/RoslynPackage.cs    | 10 ----------
 2 files changed, 20 insertions(+), 10 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
index 3005c1111fee6..438705020b740 100644
--- a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
+++ b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
@@ -19,11 +19,13 @@
 using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Shared.Utilities;
+using Microsoft.CodeAnalysis.Telemetry;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.ComponentModelHost;
 using Microsoft.VisualStudio.Composition;
@@ -33,11 +35,14 @@
 using Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem.MetadataReferences;
 using Microsoft.VisualStudio.LanguageServices.Implementation.TaskList;
 using Microsoft.VisualStudio.LanguageServices.Implementation.Venus;
+using Microsoft.VisualStudio.LanguageServices.Telemetry;
 using Microsoft.VisualStudio.LanguageServices.Utilities;
 using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Shell.Interop;
+using Microsoft.VisualStudio.Telemetry;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Projection;
+using Microsoft.VisualStudio.Threading;
 using Roslyn.Utilities;
 using VSLangProj;
 using VSLangProj140;
@@ -197,6 +202,12 @@ public async Task InitializeUIAffinitizedServicesAsync(IAsyncServiceProvider asy
             // Create services that are bound to the UI thread
             await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(_threadingContext.DisposalToken);
 
+            // Fetch the session synchronously on the UI thread; if this doesn't happen before we try using this on
+            // the background thread then we will experience hangs like we see in this bug:
+            // https://devdiv.visualstudio.com/DefaultCollection/DevDiv/_workitems?_a=edit&id=190808 or
+            // https://devdiv.visualstudio.com/DevDiv/_workitems?id=296981&_a=edit
+            var telemetrySession = TelemetryService.DefaultSession;
+
             var solutionClosingContext = UIContext.FromUIContextGuid(VSConstants.UICONTEXT.SolutionClosing_guid);
             solutionClosingContext.UIContextChanged += (_, e) => _solutionClosing = e.Activated;
 
@@ -215,6 +226,15 @@ public async Task InitializeUIAffinitizedServicesAsync(IAsyncServiceProvider asy
             await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(_threadingContext.DisposalToken);
 
             openFileTracker.ProcessQueuedWorkOnUIThread();
+
+            // Switch to a background thread to avoid loading option providers on UI thread (telemetry is reading options).
+            await TaskScheduler.Default;
+
+            var telemetryService = (VisualStudioWorkspaceTelemetryService)Services.GetRequiredService<IWorkspaceTelemetryService>();
+            telemetryService.InitializeTelemetrySession(telemetrySession);
+
+            Logger.Log(FunctionId.Run_Environment,
+                KeyValueLogMessage.Create(m => m["Version"] = FileVersionInfo.GetVersionInfo(typeof(VisualStudioWorkspace).Assembly.Location).FileVersion));
         }
 
         public void QueueCheckForFilesBeingOpen(ImmutableArray<string> newFileNames)
diff --git a/src/VisualStudio/Core/Def/RoslynPackage.cs b/src/VisualStudio/Core/Def/RoslynPackage.cs
index 20b0357de6aca..3b8914b47e096 100644
--- a/src/VisualStudio/Core/Def/RoslynPackage.cs
+++ b/src/VisualStudio/Core/Def/RoslynPackage.cs
@@ -157,16 +157,6 @@ protected override async Task InitializeAsync(CancellationToken cancellationToke
 
             _workspace = this.ComponentModel.GetService<VisualStudioWorkspace>();
 
-            // Fetch the session synchronously on the UI thread; if this doesn't happen before we try using this on
-            // the background thread then we will experience hangs like we see in this bug:
-            // https://devdiv.visualstudio.com/DefaultCollection/DevDiv/_workitems?_a=edit&id=190808 or
-            // https://devdiv.visualstudio.com/DevDiv/_workitems?id=296981&_a=edit
-            var telemetryService = (VisualStudioWorkspaceTelemetryService)_workspace.Services.GetRequiredService<IWorkspaceTelemetryService>();
-            telemetryService.InitializeTelemetrySession(TelemetryService.DefaultSession);
-
-            Logger.Log(FunctionId.Run_Environment,
-                KeyValueLogMessage.Create(m => m["Version"] = FileVersionInfo.GetVersionInfo(typeof(VisualStudioWorkspace).Assembly.Location).FileVersion));
-
             InitializeColors();
 
             // load some services that have to be loaded in UI thread

From c5d67281f30fcd0b8a22dc72cc431af75ff2cb55 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, 5 Jan 2022 10:08:12 -0800
Subject: [PATCH 233/444] Add truly synchronous indentation service interface
 for F# (#57600)

* Add truly synchronous indentation service interface for F#

* Options
---
 .../Editor/IFSharpIndentationService.cs       | 23 +++++++++--
 .../FSharpSynchronousIndentationService.cs    | 39 +++++++++++++++----
 ....CodeAnalysis.ExternalAccess.FSharp.csproj |  8 ++++
 3 files changed, 58 insertions(+), 12 deletions(-)

diff --git a/src/Tools/ExternalAccess/FSharp/Editor/IFSharpIndentationService.cs b/src/Tools/ExternalAccess/FSharp/Editor/IFSharpIndentationService.cs
index 12ac13bb95008..ac191619f1ea6 100644
--- a/src/Tools/ExternalAccess/FSharp/Editor/IFSharpIndentationService.cs
+++ b/src/Tools/ExternalAccess/FSharp/Editor/IFSharpIndentationService.cs
@@ -2,9 +2,11 @@
 // 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.Threading;
+using Microsoft.CodeAnalysis.Text;
+using Microsoft.CodeAnalysis.Formatting;
+using Microsoft.CodeAnalysis.Host;
+using System;
 
 namespace Microsoft.CodeAnalysis.ExternalAccess.FSharp.Editor
 {
@@ -20,7 +22,7 @@ namespace Microsoft.CodeAnalysis.ExternalAccess.FSharp.Editor
     /// current line.  With this tuple, both forms can be expressed, and the implementor does not
     /// have to convert from one to the other.
     /// </summary>
-    internal struct FSharpIndentationResult
+    internal readonly struct FSharpIndentationResult
     {
         /// <summary>
         /// The base position in the document that the indent should be relative to.  This position
@@ -33,13 +35,14 @@ internal struct FSharpIndentationResult
         /// </summary>
         public int Offset { get; }
 
-        public FSharpIndentationResult(int basePosition, int offset) : this()
+        public FSharpIndentationResult(int basePosition, int offset)
         {
             BasePosition = basePosition;
             Offset = offset;
         }
     }
 
+    [Obsolete("Use IFSharpIndentationService instead")]
     internal interface IFSharpSynchronousIndentationService
     {
         /// <summary>
@@ -50,4 +53,16 @@ internal interface IFSharpSynchronousIndentationService
         /// </summary>
         FSharpIndentationResult? GetDesiredIndentation(Document document, int lineNumber, CancellationToken cancellationToken);
     }
+
+    internal interface IFSharpIndentationService
+    {
+        /// <summary>
+        /// Determines the desired indentation of a given line.  May return <see langword="null"/> if the
+        /// no automatic indentation is desired.  May also return <see langword="null"/> if the line in
+        /// question is not blank and thus indentation should be deferred to the formatting command handler to handle.
+        /// </summary>
+        FSharpIndentationResult? GetDesiredIndentation(HostLanguageServices services, SourceText text, DocumentId documentId, string path, int lineNumber, FSharpIndentationOptions options);
+    }
+
+    internal readonly record struct FSharpIndentationOptions(int TabSize, FormattingOptions.IndentStyle IndentStyle);
 }
diff --git a/src/Tools/ExternalAccess/FSharp/Internal/Editor/FSharpSynchronousIndentationService.cs b/src/Tools/ExternalAccess/FSharp/Internal/Editor/FSharpSynchronousIndentationService.cs
index 5b6a8b349d7b2..ace8ede5fb0a5 100644
--- a/src/Tools/ExternalAccess/FSharp/Internal/Editor/FSharpSynchronousIndentationService.cs
+++ b/src/Tools/ExternalAccess/FSharp/Internal/Editor/FSharpSynchronousIndentationService.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System;
 using System.Composition;
 using System.Threading;
@@ -11,6 +9,7 @@
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Indentation;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.ExternalAccess.FSharp.Internal.Editor
 {
@@ -18,26 +17,50 @@ namespace Microsoft.CodeAnalysis.ExternalAccess.FSharp.Internal.Editor
     [ExportLanguageService(typeof(IIndentationService), LanguageNames.FSharp)]
     internal class FSharpSynchronousIndentationService : IIndentationService
     {
-        private readonly IFSharpSynchronousIndentationService _service;
+#pragma warning disable CS0618 // Type or member is obsolete
+        private readonly IFSharpSynchronousIndentationService? _legacyService;
+#pragma warning restore
+        private readonly IFSharpIndentationService? _service;
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public FSharpSynchronousIndentationService(IFSharpSynchronousIndentationService service)
+        public FSharpSynchronousIndentationService(
+            [Import(AllowDefault = true)] IFSharpSynchronousIndentationService? legacyService,
+            [Import(AllowDefault = true)] IFSharpIndentationService? service)
         {
+            Contract.ThrowIfTrue(service == null && legacyService == null);
+
+            _legacyService = legacyService;
             _service = service;
         }
 
         public IndentationResult GetIndentation(Document document, int lineNumber, FormattingOptions.IndentStyle indentStyle, CancellationToken cancellationToken)
         {
-            var result = _service.GetDesiredIndentation(document, lineNumber, cancellationToken);
-            if (result.HasValue)
+            // all F# documents should have a file path
+            if (document.FilePath == null)
+            {
+                return default;
+            }
+
+            FSharpIndentationResult? result;
+            if (_service != null)
             {
-                return new IndentationResult(result.Value.BasePosition, result.Value.Offset);
+                var text = document.GetTextSynchronously(cancellationToken);
+                var documentOptions = document.GetOptionsAsync(cancellationToken).WaitAndGetResult(cancellationToken);
+
+                var options = new FSharpIndentationOptions(
+                    TabSize: documentOptions.GetOption(FormattingOptions.TabSize, LanguageNames.FSharp),
+                    IndentStyle: indentStyle);
+
+                result = _service.GetDesiredIndentation(document.Project.LanguageServices, text, document.Id, document.FilePath, lineNumber, options);
             }
             else
             {
-                return default;
+                Contract.ThrowIfNull(_legacyService);
+                result = _legacyService.GetDesiredIndentation(document, lineNumber, cancellationToken);
             }
+
+            return result.HasValue ? new IndentationResult(result.Value.BasePosition, result.Value.Offset) : default;
         }
     }
 }
diff --git a/src/Tools/ExternalAccess/FSharp/Microsoft.CodeAnalysis.ExternalAccess.FSharp.csproj b/src/Tools/ExternalAccess/FSharp/Microsoft.CodeAnalysis.ExternalAccess.FSharp.csproj
index b22126a4415dc..3d8e45905efa5 100644
--- a/src/Tools/ExternalAccess/FSharp/Microsoft.CodeAnalysis.ExternalAccess.FSharp.csproj
+++ b/src/Tools/ExternalAccess/FSharp/Microsoft.CodeAnalysis.ExternalAccess.FSharp.csproj
@@ -14,6 +14,10 @@
       https://github.com/Microsoft/visualfsharp
     </PackageDescription>
   </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="..\..\..\Compilers\Core\Portable\InternalUtilities\IsExternalInit.cs" Link="Internal\Utilities\IsExternalInit.cs" />
+  </ItemGroup>
   
   <ItemGroup>
     <!--
@@ -58,4 +62,8 @@
     </EmbeddedResource>
   </ItemGroup>
 
+  <ItemGroup>
+    <Folder Include="Internal\Utilities\" />
+  </ItemGroup>
+
 </Project>

From 156a779af39d280700dcd9ce0e04b86b30a637f1 Mon Sep 17 00:00:00 2001
From: Jared Parsons <jaredpparsons@gmail.com>
Date: Wed, 5 Jan 2022 10:17:52 -0800
Subject: [PATCH 234/444] Fix flaky compiler server test (#58638)

The test failure logs have the following exception:

```
Keep alive timeout is: -1 milliseconds.
Attempt to open named pipe '02ebce08-7'
Attempt to connect named pipe '02ebce08-7'
Error Error: 'TimeoutException' 'The operation has timed out.' occurred during 'Connecting to server timed out after 1000 ms'
Stack trace:
   at System.IO.Pipes.NamedPipeClientStream.ConnectInternal(Int32 timeout, CancellationToken cancellationToken, Int32 startTime)
   at System.IO.Pipes.NamedPipeClientStream.<>c__DisplayClass20_0.<ConnectAsync>b__0()
   at System.Threading.Tasks.Task.InnerInvoke()
   at System.Threading.Tasks.Task.<>c.<.cctor>b__271_0(Object obj)
   at System.Threading.ExecutionContext.RunFromThreadPoolDispatchLoop(Thread threadPoolThread, ExecutionContext executionContext, ContextCallback callback, Object state)
--- End of stack trace from previous location ---
   at System.Threading.ExecutionContext.RunFromThreadPoolDispatchLoop(Thread threadPoolThread, ExecutionContext executionContext, ContextCallback callback, Object state)
   at System.Threading.Tasks.Task.ExecuteWithThreadLocal(Task& currentTaskSlot, Thread threadPoolThread)
--- End of stack trace from previous location ---
   at Microsoft.CodeAnalysis.CommandLine.BuildServerConnection.TryConnectToServerAsync(String pipeName, Int32 timeoutMs, ICompilerServerLogger logger, CancellationToken cancellationToken) in /_/src/Compilers/Shared/BuildServerConnection.cs:line 376
```

That error reveals that the test is using the one second timeout value
for connecting to the server. That is our standard production value but
in test code we need to use `Timeout.Infinite`. The reason is that test
machines can be under load and that can delay the amount of time it
takes for the test to run and can lead to it exceeding the timeout
value.

Fixed the timeout.

closes #57837
---
 .../Server/VBCSCompiler/BuildServerController.cs          | 8 ++++----
 .../Server/VBCSCompilerTests/VBCSCompilerServerTests.cs   | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/Compilers/Server/VBCSCompiler/BuildServerController.cs b/src/Compilers/Server/VBCSCompiler/BuildServerController.cs
index 4c1f2ca3ddc87..b92314bd29344 100644
--- a/src/Compilers/Server/VBCSCompiler/BuildServerController.cs
+++ b/src/Compilers/Server/VBCSCompiler/BuildServerController.cs
@@ -151,14 +151,14 @@ internal static int CreateAndRunServer(
             return controller.RunServer(pipeName, compilerServerHost, clientConnectionHost, listener, keepAlive, cancellationToken);
         }
 
-        internal int RunShutdown(string pipeName, CancellationToken cancellationToken = default) =>
-            RunShutdownAsync(pipeName, waitForProcess: true, cancellationToken).GetAwaiter().GetResult();
+        internal int RunShutdown(string pipeName, int? timeoutOverride = null, CancellationToken cancellationToken = default) =>
+            RunShutdownAsync(pipeName, waitForProcess: true, timeoutOverride, cancellationToken).GetAwaiter().GetResult();
 
-        internal async Task<int> RunShutdownAsync(string pipeName, bool waitForProcess, CancellationToken cancellationToken = default)
+        internal async Task<int> RunShutdownAsync(string pipeName, bool waitForProcess, int? timeoutOverride, CancellationToken cancellationToken = default)
         {
             var success = await BuildServerConnection.RunServerShutdownRequestAsync(
                 pipeName,
-                timeoutOverride: null,
+                timeoutOverride,
                 waitForProcess: waitForProcess,
                 _logger,
                 cancellationToken).ConfigureAwait(false);
diff --git a/src/Compilers/Server/VBCSCompilerTests/VBCSCompilerServerTests.cs b/src/Compilers/Server/VBCSCompilerTests/VBCSCompilerServerTests.cs
index 73941972e48e5..f16131c698c1f 100644
--- a/src/Compilers/Server/VBCSCompilerTests/VBCSCompilerServerTests.cs
+++ b/src/Compilers/Server/VBCSCompilerTests/VBCSCompilerServerTests.cs
@@ -57,7 +57,7 @@ public ShutdownTests(ITestOutputHelper testOutputHelper)
             private Task<int> RunShutdownAsync(string pipeName, bool waitForProcess = true, CancellationToken cancellationToken = default(CancellationToken))
             {
                 var appSettings = new NameValueCollection();
-                return new BuildServerController(appSettings, Logger).RunShutdownAsync(pipeName, waitForProcess, cancellationToken);
+                return new BuildServerController(appSettings, Logger).RunShutdownAsync(pipeName, waitForProcess, Timeout.Infinite, cancellationToken);
             }
 
             [Fact]

From 5a4330a1ec207794883bfe3cb876882054262a66 Mon Sep 17 00:00:00 2001
From: Rikki Gibson <rigibson@microsoft.com>
Date: Wed, 5 Jan 2022 10:38:28 -0800
Subject: [PATCH 235/444] Fix a few param-nullchecking parsing bugs

---
 .../CSharp/Portable/Parser/LanguageParser.cs  | 18 +++-
 .../Syntax/Parsing/DeclarationParsingTests.cs | 92 +++++++++++++++++++
 2 files changed, 105 insertions(+), 5 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
index 6d44f7e2a1545..f7d79759155c8 100644
--- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
+++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
@@ -4406,6 +4406,10 @@ private ParameterSyntax ParseParameter()
                         else
                         {
                             exclamationExclamation = MergeTokens(exclamationExclamation, this.EatToken(SyntaxKind.ExclamationToken), SyntaxKind.ExclamationExclamationToken);
+                            if (this.CurrentToken.Kind == SyntaxKind.EqualsToken)
+                            {
+                                equals = this.EatToken(SyntaxKind.EqualsToken);
+                            }
                         }
                     }
                     else if (this.CurrentToken.Kind == SyntaxKind.OpenBracketToken && this.PeekToken(1).Kind == SyntaxKind.CloseBracketToken)
@@ -4415,6 +4419,10 @@ private ParameterSyntax ParseParameter()
                         var close = this.EatToken();
                         open = this.AddError(open, ErrorCode.ERR_BadArraySyntax);
                         name = AddTrailingSkippedSyntax(name, SyntaxList.List(open, close));
+                        if (this.CurrentToken.Kind == SyntaxKind.EqualsToken)
+                        {
+                            equals = this.EatToken(SyntaxKind.EqualsToken);
+                        }
                     }
                 }
                 else
@@ -4423,12 +4431,12 @@ private ParameterSyntax ParseParameter()
                     // .Identifier has the kind ArgListKeyword.
                     type = null;
                     name = this.EatToken(SyntaxKind.ArgListKeyword);
+                    if (this.CurrentToken.Kind == SyntaxKind.EqualsToken)
+                    {
+                        equals = this.EatToken(SyntaxKind.EqualsToken);
+                    }
                 }
 
-                if (this.CurrentToken.Kind == SyntaxKind.EqualsToken)
-                {
-                    equals = this.EatToken(SyntaxKind.EqualsToken);
-                }
                 if (exclamationExclamation != null)
                 {
                     exclamationExclamation = (exclamationExclamation.Kind != SyntaxKind.ExclamationExclamationToken)
@@ -13619,7 +13627,7 @@ internal TNode ConsumeUnexpectedTokens<TNode>(TNode node) where TNode : CSharpSy
 
         private SyntaxToken MergeTokens(SyntaxToken s1, SyntaxToken s2, SyntaxKind kind)
         {
-            if (s1.GetTrailingTriviaWidth() == 0 && s2.GetLeadingTriviaWidth() == 0)
+            if (!s1.ContainsDiagnostics && !s2.ContainsDiagnostics && s1.GetTrailingTriviaWidth() == 0 && s2.GetLeadingTriviaWidth() == 0)
             {
                 s1 = SyntaxFactory.Token(s1.GetLeadingTrivia(), kind, s2.GetTrailingTrivia());
             }
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs
index 6d98f3a528743..be3b1b5f4e127 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs
@@ -7272,6 +7272,44 @@ public void TestMethodDeclarationNullValidation()
             }
         }
 
+        [Fact]
+        public void TestMethodDeclarationNullValidation_SingleExclamation()
+        {
+            UsingStatement(@"void M(string name!) { }", options: TestOptions.RegularPreview,
+                // (1,20): error CS1003: Syntax error, '!' expected
+                // void M(string name!) { }
+                Diagnostic(ErrorCode.ERR_SyntaxError, ")").WithArguments("!", ")").WithLocation(1, 20));
+
+            N(SyntaxKind.LocalFunctionStatement);
+            {
+                N(SyntaxKind.PredefinedType);
+                {
+                    N(SyntaxKind.VoidKeyword);
+                }
+                N(SyntaxKind.IdentifierToken, "M");
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.StringKeyword);
+                        }
+                        N(SyntaxKind.IdentifierToken, "name");
+                        M(SyntaxKind.ExclamationExclamationToken);
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
+
         [Fact]
         public void TestOptParamMethodDeclarationWithNullValidation()
         {
@@ -7764,6 +7802,60 @@ public void TestNullCheckedArgWithSpaceAfterEquals()
             }
         }
 
+        [Fact]
+        public void TestMethodDeclarationNullValidation_ExtraEquals()
+        {
+            UsingStatement(@"void M(string name!!= = null) { }", options: TestOptions.RegularPreview,
+                // (1,23): error CS1525: Invalid expression term '='
+                // void M(string name!!= = null) { }
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "=").WithArguments("=").WithLocation(1, 23));
+
+            N(SyntaxKind.LocalFunctionStatement);
+            {
+                N(SyntaxKind.PredefinedType);
+                {
+                    N(SyntaxKind.VoidKeyword);
+                }
+                N(SyntaxKind.IdentifierToken, "M");
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.StringKeyword);
+                        }
+                        N(SyntaxKind.IdentifierToken, "name");
+                        N(SyntaxKind.ExclamationExclamationToken);
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.SimpleAssignmentExpression);
+                            {
+                                M(SyntaxKind.IdentifierName);
+                                {
+                                    M(SyntaxKind.IdentifierToken);
+                                }
+                                N(SyntaxKind.EqualsToken);
+                                N(SyntaxKind.NullLiteralExpression);
+                                {
+                                    N(SyntaxKind.NullKeyword);
+                                }
+                            }
+                        }
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
+
         [Fact]
         public void TestNullCheckedMethod()
         {

From 92fa50939180398ee5bb3160c89b5a073d67047c Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Wed, 5 Jan 2022 12:39:59 -0800
Subject: [PATCH 236/444] Unify !! parsing logic in one location

---
 .../CSharp/Portable/CSharpResources.resx      |   3 +
 .../CSharp/Portable/Errors/ErrorCode.cs       |   1 +
 .../CSharp/Portable/Parser/LanguageParser.cs  | 218 ++++++++----------
 .../Portable/xlf/CSharpResources.cs.xlf       |   5 +
 .../Portable/xlf/CSharpResources.de.xlf       |   5 +
 .../Portable/xlf/CSharpResources.es.xlf       |   5 +
 .../Portable/xlf/CSharpResources.fr.xlf       |   5 +
 .../Portable/xlf/CSharpResources.it.xlf       |   5 +
 .../Portable/xlf/CSharpResources.ja.xlf       |   5 +
 .../Portable/xlf/CSharpResources.ko.xlf       |   5 +
 .../Portable/xlf/CSharpResources.pl.xlf       |   5 +
 .../Portable/xlf/CSharpResources.pt-BR.xlf    |   5 +
 .../Portable/xlf/CSharpResources.ru.xlf       |   5 +
 .../Portable/xlf/CSharpResources.tr.xlf       |   5 +
 .../Portable/xlf/CSharpResources.zh-Hans.xlf  |   5 +
 .../Portable/xlf/CSharpResources.zh-Hant.xlf  |   5 +
 16 files changed, 166 insertions(+), 121 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/CSharpResources.resx b/src/Compilers/CSharp/Portable/CSharpResources.resx
index a2d8a9e377099..edb28238cd7c3 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.resx
+++ b/src/Compilers/CSharp/Portable/CSharpResources.resx
@@ -6938,4 +6938,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="WRN_LowerCaseTypeName_Title" xml:space="preserve">
     <value>The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</value>
   </data>
+  <data name="ERR_DefaultParameterValueNotAllowed" xml:space="preserve">
+    <value>Default parameter value not allowed here</value>
+  </data>
 </root>
diff --git a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
index 7d18a53a3ea6a..8dd9bfa88775a 100644
--- a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
+++ b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
@@ -2013,6 +2013,7 @@ internal enum ErrorCode
         WRN_NullCheckedHasDefaultNull = 8993,
         ERR_NullCheckingOnByRefParameter = 8994,
         WRN_NullCheckingOnNullableType = 8995,
+        ERR_DefaultParameterValueNotAllowed = 8996,
 
         #endregion
 
diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
index f7d79759155c8..334841720488d 100644
--- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
+++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
@@ -4386,78 +4386,110 @@ private ParameterSyntax ParseParameter()
                 this.ParseParameterModifiers(modifiers);
 
                 TypeSyntax type;
-                SyntaxToken name;
-                SyntaxToken exclamationExclamation = null;
-                SyntaxToken equals = null;
-                if (this.CurrentToken.Kind != SyntaxKind.ArgListKeyword)
-                {
-                    type = this.ParseType(mode: ParseTypeMode.Parameter);
-                    name = this.ParseIdentifierToken();
-                    if (this.CurrentToken.Kind == SyntaxKind.ExclamationToken)
-                    {
-                        exclamationExclamation = this.EatToken();
-                        if (this.CurrentToken.Kind == SyntaxKind.ExclamationEqualsToken)
-                        {
-                            var exclamationEquals = this.EatToken();
-                            var exclamation2 = SyntaxFactory.Token(exclamationEquals.GetLeadingTrivia(), SyntaxKind.ExclamationToken, null);
-                            exclamationExclamation = MergeTokens(exclamationExclamation, exclamation2, SyntaxKind.ExclamationExclamationToken);
-                            equals = SyntaxFactory.Token(null, SyntaxKind.EqualsToken, exclamationEquals.GetTrailingTrivia());
-                        }
-                        else
-                        {
-                            exclamationExclamation = MergeTokens(exclamationExclamation, this.EatToken(SyntaxKind.ExclamationToken), SyntaxKind.ExclamationExclamationToken);
-                            if (this.CurrentToken.Kind == SyntaxKind.EqualsToken)
-                            {
-                                equals = this.EatToken(SyntaxKind.EqualsToken);
-                            }
-                        }
-                    }
-                    else if (this.CurrentToken.Kind == SyntaxKind.OpenBracketToken && this.PeekToken(1).Kind == SyntaxKind.CloseBracketToken)
-                    {
-                        // When the user type "int goo[]", give them a useful error
-                        var open = this.EatToken();
-                        var close = this.EatToken();
-                        open = this.AddError(open, ErrorCode.ERR_BadArraySyntax);
-                        name = AddTrailingSkippedSyntax(name, SyntaxList.List(open, close));
-                        if (this.CurrentToken.Kind == SyntaxKind.EqualsToken)
-                        {
-                            equals = this.EatToken(SyntaxKind.EqualsToken);
-                        }
-                    }
-                }
-                else
+                SyntaxToken identifier;
+                if (this.CurrentToken.Kind == SyntaxKind.ArgListKeyword)
                 {
                     // We store an __arglist parameter as a parameter with null type and whose 
                     // .Identifier has the kind ArgListKeyword.
                     type = null;
-                    name = this.EatToken(SyntaxKind.ArgListKeyword);
-                    if (this.CurrentToken.Kind == SyntaxKind.EqualsToken)
-                    {
-                        equals = this.EatToken(SyntaxKind.EqualsToken);
-                    }
+                    identifier = this.EatToken(SyntaxKind.ArgListKeyword);
+                }
+                else
+                {
+                    type = this.ParseType(mode: ParseTypeMode.Parameter);
+                    identifier = this.ParseIdentifierToken();
                 }
 
-                if (exclamationExclamation != null)
+                ParseParameterRest(ref identifier, out var exclamationExclamationToken, out var equalsValueClause);
+                return _syntaxFactory.Parameter(attributes, modifiers.ToList(), type, identifier, exclamationExclamationToken, equalsValueClause);
+            }
+            finally
+            {
+                _pool.Free(modifiers);
+            }
+        }
+
+#nullable enable
+
+        /// <summary>
+        /// Parses out a parameter once the type and identifier of it has been parsed out already.
+        /// </summary>
+        private void ParseParameterRest(bool equalsValueLegal, ref SyntaxToken identifier, out SyntaxToken? exclamationExclamationToken, out EqualsValueClauseSyntax? equalsValueClause)
+        {
+            exclamationExclamationToken = null;
+
+            // When the user type "int goo[]", give them a useful error
+            if (this.CurrentToken.Kind is SyntaxKind.OpenBracketToken && this.PeekToken(1).Kind is SyntaxKind.CloseBracketToken)
+            {
+                identifier = AddTrailingSkippedSyntax(identifier, SyntaxList.List(
+                    this.AddError(this.EatToken(), ErrorCode.ERR_BadArraySyntax),
+                    this.EatToken()));
+            }
+
+            if (this.CurrentToken.Kind is not SyntaxKind.ExclamationToken)
+            {
+                equalsValueClause = tryParseParameterInitializer(equalsValueLegal, equalsToken: null);
+                return;
+            }
+
+            // We have seen at least !
+            //
+            // We can potentially merge that with an immediately following !! or an immediately following !=
+            // All other cases are in error.
+            var exclamationToken = this.EatToken();
+            if (exclamationToken.GetTrailingTriviaWidth() == 0 &&
+                this.CurrentToken.GetLeadingTriviaWidth() == 0 &&
+                this.CurrentToken.Kind is SyntaxKind.ExclamationToken or SyntaxKind.ExclamationEqualsToken)
+            {
+                if (this.CurrentToken.Kind is SyntaxKind.ExclamationToken)
                 {
-                    exclamationExclamation = (exclamationExclamation.Kind != SyntaxKind.ExclamationExclamationToken)
-                        ? ConvertToMissingWithTrailingTrivia(exclamationExclamation, SyntaxKind.ExclamationExclamationToken)
-                        : CheckFeatureAvailability(exclamationExclamation, MessageID.IDS_ParameterNullChecking);
+                    var secondExclamation = this.EatToken();
+                    exclamationExclamationToken = SyntaxFactory.Token(exclamationToken.GetLeadingTrivia(), SyntaxKind.ExclamationExclamationToken, secondExclamation.GetTrailingTrivia());
+                    equalsValueClause = tryParseParameterInitializer(equalsValueLegal, equalsToken: null);
                 }
-                EqualsValueClauseSyntax def = null;
-                if (!(equals is null))
+                else
                 {
-                    var value = this.ParseExpressionCore();
-                    def = _syntaxFactory.EqualsValueClause(equals, value: value);
-                    def = CheckFeatureAvailability(def, MessageID.IDS_FeatureOptionalParameter);
+                    Debug.Assert(this.CurrentToken.Kind == SyntaxKind.ExclamationEqualsToken);
+                    var exclamationEquals = this.EatToken();
+                    exclamationExclamationToken = SyntaxFactory.Token(exclamationToken.GetLeadingTrivia(), SyntaxKind.ExclamationExclamationToken, trailing: null);
+                    equalsValueClause = tryParseParameterInitializer(
+                        equalsValueLegal, equalsToken: SyntaxFactory.Token(leading: null, SyntaxKind.EqualsToken, exclamationEquals.GetTrailingTrivia()));
                 }
-                return _syntaxFactory.Parameter(attributes, modifiers.ToList(), type, name, exclamationExclamation, def);
             }
-            finally
+            else
             {
-                _pool.Free(modifiers);
+                // We had ! followed by something bogus (like a comma/close paren).  Or it was followed by another !,
+                // but they were not directly touching.  Given an appropriate error that `!!` was expected and continue.
+
+                exclamationExclamationToken = WithAdditionalDiagnostics(exclamationToken, this.GetExpectedTokenError(SyntaxKind.ExclamationExclamationToken, exclamationToken.Kind));
+                equalsValueClause = tryParseParameterInitializer(equalsValueLegal, equalsToken: null);
+            }
+
+            if (exclamationExclamationToken != null)
+                exclamationExclamationToken = CheckFeatureAvailability(exclamationExclamationToken, MessageID.IDS_ParameterNullChecking);
+
+            return;
+
+            EqualsValueClauseSyntax? tryParseParameterInitializer(bool equalsValueLegal, SyntaxToken? equalsToken)
+            {
+                if (equalsToken == null)
+                {
+                    equalsToken = this.TryEatToken(SyntaxKind.EqualsToken);
+                    if (equalsToken == null)
+                        return null;
+                }
+
+                if (!equalsValueLegal)
+                    equalsToken = AddError(equalsToken, ErrorCode.ERR_EqualsValueNotAllowed);
+
+                var expression = this.ParseExpressionCore();
+                var equalsValueClause = _syntaxFactory.EqualsValueClause(equalsToken, expression);
+                return CheckFeatureAvailability(equalsValueClause, MessageID.IDS_FeatureOptionalParameter);
             }
         }
 
+#nullable restore
+
         private static bool IsParameterModifier(SyntaxKind kind, bool isFunctionPointerParameter = false)
         {
             switch (kind)
@@ -12896,42 +12928,12 @@ LambdaExpressionSyntax parseLambdaExpressionWorker()
                 }
                 else
                 {
-                    var name = this.ParseIdentifierToken();
-                    SyntaxToken arrow, exclamationExclamation;
-                    // Case x!! =>
-                    if (this.CurrentToken.Kind == SyntaxKind.ExclamationToken)
-                    {
-                        exclamationExclamation = this.EatToken();
-                        if (this.CurrentToken.Kind == SyntaxKind.ExclamationEqualsToken)
-                        {
-                            var exclamationEquals = this.EatToken();
-                            var exclamation2 = SyntaxFactory.Token(exclamationEquals.GetLeadingTrivia(), SyntaxKind.ExclamationToken, null);
-                            exclamationExclamation = MergeTokens(exclamationExclamation, exclamation2, SyntaxKind.ExclamationExclamationToken);
-
-                            var equals = SyntaxFactory.Token(null, SyntaxKind.EqualsToken, exclamationEquals.GetTrailingTrivia());
-                            var greaterThan = this.EatToken(SyntaxKind.GreaterThanToken);
-                            arrow = MergeTokens(equals, greaterThan, SyntaxKind.EqualsGreaterThanToken);
-                        }
-                        else
-                        {
-                            exclamationExclamation = MergeTokens(exclamationExclamation, this.EatToken(SyntaxKind.ExclamationToken), SyntaxKind.ExclamationExclamationToken);
-                            arrow = this.EatToken(SyntaxKind.EqualsGreaterThanToken);
-                        }
-                    }
-                    // Case x=>, x =>
-                    else
-                    {
-                        arrow = this.EatToken(SyntaxKind.EqualsGreaterThanToken);
-                        exclamationExclamation = null;
-                    }
+                    var identifier = this.ParseIdentifierToken();
 
-                    if (exclamationExclamation != null)
-                    {
-                        exclamationExclamation = (exclamationExclamation.Kind != SyntaxKind.ExclamationExclamationToken)
-                            ? ConvertToMissingWithTrailingTrivia(exclamationExclamation, SyntaxKind.ExclamationExclamationToken)
-                            : CheckFeatureAvailability(exclamationExclamation, MessageID.IDS_ParameterNullChecking);
-                    }
+                    ParseParameterRest(equalsValueLegal: false, ref identifier, out var exclamationExclamationToken, out var equalsValueClause);
 
+                    // Case x=>, x =>
+                    var arrow = this.EatToken(SyntaxKind.EqualsGreaterThanToken);
                     if (arrow != null)
                     {
                         arrow = (arrow.Kind != SyntaxKind.EqualsGreaterThanToken)
@@ -12940,8 +12942,7 @@ LambdaExpressionSyntax parseLambdaExpressionWorker()
                     }
 
                     var parameter = _syntaxFactory.Parameter(
-                        attributeLists: default, modifiers: default,
-                        type: null, identifier: name, exclamationExclamationToken: exclamationExclamation, @default: null);
+                        attributeLists: default, modifiers: default, type: null, identifier, exclamationExclamationToken, equalsValueClause);
                     var (block, expression) = ParseLambdaBody();
                     return _syntaxFactory.SimpleLambdaExpression(
                         attributes, modifiers, parameter, arrow, block, expression);
@@ -13064,19 +13065,9 @@ private ParameterSyntax ParseLambdaParameter()
                 paramType = ParseType(ParseTypeMode.Parameter);
             }
 
-            SyntaxToken paramName = this.ParseIdentifierToken();
-            SyntaxToken exclamationExclamation = null;
-            if (this.CurrentToken.Kind == SyntaxKind.ExclamationToken)
-            {
-                exclamationExclamation = MergeTokens(this.EatToken(SyntaxKind.ExclamationToken), this.EatToken(SyntaxKind.ExclamationToken), SyntaxKind.ExclamationExclamationToken);
-            }
-            if (exclamationExclamation != null)
-            {
-                exclamationExclamation = (exclamationExclamation.Kind != SyntaxKind.ExclamationExclamationToken)
-                    ? ConvertToMissingWithTrailingTrivia(exclamationExclamation, SyntaxKind.ExclamationExclamationToken)
-                    : CheckFeatureAvailability(exclamationExclamation, MessageID.IDS_ParameterNullChecking);
-            }
-            var parameter = _syntaxFactory.Parameter(attributes, modifiers.ToList(), paramType, paramName, exclamationExclamation, null);
+            var identifier = this.ParseIdentifierToken();
+            ParseParameterRest(equalsValueLegal: false, ref identifier, out var exclamationExclamationToken, out var equalsValueClause);
+            var parameter = _syntaxFactory.Parameter(attributes, modifiers.ToList(), paramType, identifier, exclamationExclamationToken, equalsValueClause);
             _pool.Free(modifiers);
             return parameter;
         }
@@ -13624,20 +13615,5 @@ internal TNode ConsumeUnexpectedTokens<TNode>(TNode node) where TNode : CSharpSy
             node = this.AddTrailingSkippedSyntax(node, trailingTrash.Node);
             return node;
         }
-
-        private SyntaxToken MergeTokens(SyntaxToken s1, SyntaxToken s2, SyntaxKind kind)
-        {
-            if (!s1.ContainsDiagnostics && !s2.ContainsDiagnostics && s1.GetTrailingTriviaWidth() == 0 && s2.GetLeadingTriviaWidth() == 0)
-            {
-                s1 = SyntaxFactory.Token(s1.GetLeadingTrivia(), kind, s2.GetTrailingTrivia());
-            }
-            else
-            {
-                s2 = this.AddError(s2, ErrorCode.ERR_InvalidExprTerm, s2.Text);
-                s1 = AddTrailingSkippedSyntax(s1, s2);
-            }
-
-            return s1;
-        }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
index 4dc96dd386ae2..8f2664b901ac0 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
@@ -347,6 +347,11 @@
         <target state="translated">Není k dispozici žádný cílový typ pro výchozí literál.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
+        <source>Default parameter value not allowed here</source>
+        <target state="new">Default parameter value not allowed here</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">Výchozí literál default není platný jako vzor. Podle potřeby použijte jiný literál (například 0 nebo null). Pokud chcete, aby odpovídalo vše, použijte vzor discard „_“.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
index 0a1f31f89a18a..5c68bb77132d9 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
@@ -347,6 +347,11 @@
         <target state="translated">Für das Standardliteral ist kein Zieltyp vorhanden.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
+        <source>Default parameter value not allowed here</source>
+        <target state="new">Default parameter value not allowed here</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">Ein Standardliteral "default" ist als Muster ungültig. Verwenden Sie ggf. ein anderes Literal (z. B. 0 oder "null"). Verwenden Sie zum Abgleich aller Elemente ein discard-Muster "_".</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
index 5c52bac5afa6b..165d84094465d 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
@@ -347,6 +347,11 @@
         <target state="translated">No hay ningún tipo de destino para el literal predeterminado.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
+        <source>Default parameter value not allowed here</source>
+        <target state="new">Default parameter value not allowed here</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">Un literal predeterminado "default" no es válido como patrón. Use otro literal (por ejemplo, "0" o "null") según corresponda. Para hacer coincidir todo, use un patrón de descarte "_".</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
index 2b392f5e2785a..c2c5cf1791f08 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
@@ -347,6 +347,11 @@
         <target state="translated">Il n'existe aucun type cible pour le littéral par défaut.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
+        <source>Default parameter value not allowed here</source>
+        <target state="new">Default parameter value not allowed here</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">Un littéral par défaut 'default' est non valide en tant que modèle. Utilisez un autre littéral (par exemple, '0' ou 'null') selon le cas. Pour correspondre à tout, utilisez un modèle d'abandon '_'.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
index 7d59f370dd547..fe27897cb9abe 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
@@ -347,6 +347,11 @@
         <target state="translated">Non esiste alcun tipo di destinazione per il valore letterale predefinito.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
+        <source>Default parameter value not allowed here</source>
+        <target state="new">Default parameter value not allowed here</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">Non è possibile usare un valore letterale predefinito 'default' come criterio. Usare un altro valore letterale, ad esempio '0' o 'null'. Per abbinare tutto, usare un criterio di rimozione '_'.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
index 7e90412db3885..69609cb89e48b 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
@@ -347,6 +347,11 @@
         <target state="translated">既定のリテラルのターゲット型がありません。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
+        <source>Default parameter value not allowed here</source>
+        <target state="new">Default parameter value not allowed here</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">既定のリテラル 'default' はパターンとして無効です。必要に応じて別のリテラル (例: '0' または 'null') をご使用ください。すべてと一致させるには、破棄パターン '_' をご使用ください。</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
index 0efe3191f37f8..14d220a03d319 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
@@ -347,6 +347,11 @@
         <target state="translated">기본 리터럴의 대상 형식이 없습니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
+        <source>Default parameter value not allowed here</source>
+        <target state="new">Default parameter value not allowed here</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">기본 리터럴 'default'가 패턴으로 유효하지 않습니다. 다른 리터럴(예: '0' 또는 'null')을 적절하게 사용하세요. 모두 일치시키려면 무시 패턴 '_'을 사용하세요.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
index 2f856498d1a40..475596107502f 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
@@ -347,6 +347,11 @@
         <target state="translated">Brak typu docelowego dla literału domyślnego.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
+        <source>Default parameter value not allowed here</source>
+        <target state="new">Default parameter value not allowed here</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">Domyślny literał „default” nie jest prawidłowy jako wzorzec. Użyj innego odpowiedniego literału (np. „0” lub „null”). Aby dopasować wszystko, użyj wzorca odrzucania „_”.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
index be8b3c36d676d..cc335293db3f4 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
@@ -347,6 +347,11 @@
         <target state="translated">Não há um tipo de destino para o literal padrão.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
+        <source>Default parameter value not allowed here</source>
+        <target state="new">Default parameter value not allowed here</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">Um literal padrão 'default' não é válido como um padrão. Use outro literal (por exemplo, '0' ou 'null') conforme o necessário. Para corresponder a tudo, use um padrão de descarte '_'.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
index 060db145dfa6e..dc7b7338690b7 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
@@ -347,6 +347,11 @@
         <target state="translated">Отсутствует целевой тип для литерала по умолчанию.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
+        <source>Default parameter value not allowed here</source>
+        <target state="new">Default parameter value not allowed here</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">Литерал по умолчанию "default" недопустимо использовать в качестве шаблона. Используйте другой литерал (например, "0" или "null") по мере необходимости. Чтобы задать полное совпадение, используйте шаблон отмены "_".</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
index 83cb76209ee3f..8a774ebcf2cf6 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
@@ -347,6 +347,11 @@
         <target state="translated">Varsayılan değişmez değer için hedef tür yok.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
+        <source>Default parameter value not allowed here</source>
+        <target state="new">Default parameter value not allowed here</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">'default' varsayılan sabit değeri bir desen olarak geçerli değil. Uygun olan başka bir sabit değeri (ör. '0' veya 'null') kullanın. Tüm öğeleri eşleştirmek için '_' atma desenini kullanın.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
index de52f51125798..44b701eae7378 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
@@ -347,6 +347,11 @@
         <target state="translated">default 字面量缺少目标类型。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
+        <source>Default parameter value not allowed here</source>
+        <target state="new">Default parameter value not allowed here</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">默认字面量“default”不能作为模式使用。请使用其他更适合的字面量（如“0”或“null”）。若要匹配任何输入，请使用放弃模式“_”。</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
index 49532a745b040..b4ee58d24cc73 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
@@ -347,6 +347,11 @@
         <target state="translated">預設常值沒有目標類型。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
+        <source>Default parameter value not allowed here</source>
+        <target state="new">Default parameter value not allowed here</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">預設常值 'default' 作為模式無效。請使用另一個適當的常值 (例如 '0' 或 'null')。若要比對所有項目，請使用捨棄模式 '_'。</target>

From d801fa2733ad3729ee04275e8732f0fd87c064d4 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Wed, 5 Jan 2022 14:15:44 -0800
Subject: [PATCH 237/444] In progress

---
 .../CSharp/Portable/CSharpResources.resx      |   3 -
 .../CSharp/Portable/Errors/ErrorCode.cs       |   1 -
 .../CSharp/Portable/Parser/LanguageParser.cs  | 142 +++++++-----
 .../Parsing/LambdaParameterParsingTests.cs    | 207 ++++++++++++++++++
 4 files changed, 295 insertions(+), 58 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/CSharpResources.resx b/src/Compilers/CSharp/Portable/CSharpResources.resx
index edb28238cd7c3..a2d8a9e377099 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.resx
+++ b/src/Compilers/CSharp/Portable/CSharpResources.resx
@@ -6938,7 +6938,4 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="WRN_LowerCaseTypeName_Title" xml:space="preserve">
     <value>The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</value>
   </data>
-  <data name="ERR_DefaultParameterValueNotAllowed" xml:space="preserve">
-    <value>Default parameter value not allowed here</value>
-  </data>
 </root>
diff --git a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
index 8dd9bfa88775a..7d18a53a3ea6a 100644
--- a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
+++ b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
@@ -2013,7 +2013,6 @@ internal enum ErrorCode
         WRN_NullCheckedHasDefaultNull = 8993,
         ERR_NullCheckingOnByRefParameter = 8994,
         WRN_NullCheckingOnNullableType = 8995,
-        ERR_DefaultParameterValueNotAllowed = 8996,
 
         #endregion
 
diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
index 334841720488d..0543a56b06dfc 100644
--- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
+++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
@@ -4400,7 +4400,12 @@ private ParameterSyntax ParseParameter()
                     identifier = this.ParseIdentifierToken();
                 }
 
-                ParseParameterRest(ref identifier, out var exclamationExclamationToken, out var equalsValueClause);
+                ParseParameterRest(ref identifier, out var exclamationExclamationToken, out var equalsToken);
+
+                EqualsValueClauseSyntax equalsValueClause = null;
+                if (equalsToken != null)
+                    equalsValueClause = CheckFeatureAvailability(_syntaxFactory.EqualsValueClause(equalsToken, this.ParseExpressionCore()), MessageID.IDS_FeatureOptionalParameter);
+
                 return _syntaxFactory.Parameter(attributes, modifiers.ToList(), type, identifier, exclamationExclamationToken, equalsValueClause);
             }
             finally
@@ -4412,9 +4417,12 @@ private ParameterSyntax ParseParameter()
 #nullable enable
 
         /// <summary>
-        /// Parses out a parameter once the type and identifier of it has been parsed out already.
+        /// Parses out the remainder of a parameter once the type and identifier of it has been parsed out already.
         /// </summary>
-        private void ParseParameterRest(bool equalsValueLegal, ref SyntaxToken identifier, out SyntaxToken? exclamationExclamationToken, out EqualsValueClauseSyntax? equalsValueClause)
+        private void ParseParameterRest(
+            ref SyntaxToken identifier,
+            out SyntaxToken? exclamationExclamationToken,
+            out SyntaxToken? equalsToken)
         {
             exclamationExclamationToken = null;
 
@@ -4428,7 +4436,7 @@ private void ParseParameterRest(bool equalsValueLegal, ref SyntaxToken identifie
 
             if (this.CurrentToken.Kind is not SyntaxKind.ExclamationToken)
             {
-                equalsValueClause = tryParseParameterInitializer(equalsValueLegal, equalsToken: null);
+                equalsToken = this.TryEatToken(SyntaxKind.EqualsToken);
                 return;
             }
 
@@ -4437,23 +4445,21 @@ private void ParseParameterRest(bool equalsValueLegal, ref SyntaxToken identifie
             // We can potentially merge that with an immediately following !! or an immediately following !=
             // All other cases are in error.
             var exclamationToken = this.EatToken();
-            if (exclamationToken.GetTrailingTriviaWidth() == 0 &&
-                this.CurrentToken.GetLeadingTriviaWidth() == 0 &&
+            if (NoTriviaBetween(exclamationToken, this.CurrentToken) &&
                 this.CurrentToken.Kind is SyntaxKind.ExclamationToken or SyntaxKind.ExclamationEqualsToken)
             {
                 if (this.CurrentToken.Kind is SyntaxKind.ExclamationToken)
                 {
                     var secondExclamation = this.EatToken();
                     exclamationExclamationToken = SyntaxFactory.Token(exclamationToken.GetLeadingTrivia(), SyntaxKind.ExclamationExclamationToken, secondExclamation.GetTrailingTrivia());
-                    equalsValueClause = tryParseParameterInitializer(equalsValueLegal, equalsToken: null);
+                    equalsToken = this.TryEatToken(SyntaxKind.EqualsToken);
                 }
                 else
                 {
                     Debug.Assert(this.CurrentToken.Kind == SyntaxKind.ExclamationEqualsToken);
                     var exclamationEquals = this.EatToken();
                     exclamationExclamationToken = SyntaxFactory.Token(exclamationToken.GetLeadingTrivia(), SyntaxKind.ExclamationExclamationToken, trailing: null);
-                    equalsValueClause = tryParseParameterInitializer(
-                        equalsValueLegal, equalsToken: SyntaxFactory.Token(leading: null, SyntaxKind.EqualsToken, exclamationEquals.GetTrailingTrivia()));
+                    equalsToken = SyntaxFactory.Token(leading: null, SyntaxKind.EqualsToken, exclamationEquals.GetTrailingTrivia());
                 }
             }
             else
@@ -4462,33 +4468,17 @@ private void ParseParameterRest(bool equalsValueLegal, ref SyntaxToken identifie
                 // but they were not directly touching.  Given an appropriate error that `!!` was expected and continue.
 
                 exclamationExclamationToken = WithAdditionalDiagnostics(exclamationToken, this.GetExpectedTokenError(SyntaxKind.ExclamationExclamationToken, exclamationToken.Kind));
-                equalsValueClause = tryParseParameterInitializer(equalsValueLegal, equalsToken: null);
+                equalsToken = this.TryEatToken(SyntaxKind.EqualsToken);
             }
 
             if (exclamationExclamationToken != null)
                 exclamationExclamationToken = CheckFeatureAvailability(exclamationExclamationToken, MessageID.IDS_ParameterNullChecking);
-
-            return;
-
-            EqualsValueClauseSyntax? tryParseParameterInitializer(bool equalsValueLegal, SyntaxToken? equalsToken)
-            {
-                if (equalsToken == null)
-                {
-                    equalsToken = this.TryEatToken(SyntaxKind.EqualsToken);
-                    if (equalsToken == null)
-                        return null;
-                }
-
-                if (!equalsValueLegal)
-                    equalsToken = AddError(equalsToken, ErrorCode.ERR_EqualsValueNotAllowed);
-
-                var expression = this.ParseExpressionCore();
-                var equalsValueClause = _syntaxFactory.EqualsValueClause(equalsToken, expression);
-                return CheckFeatureAvailability(equalsValueClause, MessageID.IDS_FeatureOptionalParameter);
-            }
         }
 
-#nullable restore
+        private static bool NoTriviaBetween(SyntaxToken token1, SyntaxToken token2)
+            => token1.GetTrailingTriviaWidth() == 0 && token2.GetLeadingTriviaWidth() == 0;
+
+#nullable disable
 
         private static bool IsParameterModifier(SyntaxKind kind, bool isFunctionPointerParameter = false)
         {
@@ -10581,7 +10571,7 @@ private ExpressionSyntax ParseExpressionContinued(ExpressionSyntax leftOperand,
                     && (this.PeekToken(1).Kind == SyntaxKind.GreaterThanToken || this.PeekToken(1).Kind == SyntaxKind.GreaterThanEqualsToken))
                 {
                     // check to see if they really are adjacent
-                    if (this.CurrentToken.GetTrailingTriviaWidth() == 0 && this.PeekToken(1).GetLeadingTriviaWidth() == 0)
+                    if (NoTriviaBetween(this.CurrentToken, this.PeekToken(1)))
                     {
                         if (this.PeekToken(1).Kind == SyntaxKind.GreaterThanToken)
                         {
@@ -11579,12 +11569,13 @@ bool isParenVarCommaSyntax()
                         {
                             return true;
                         }
+
+                        var token3 = this.PeekToken(3);
                         // ( x!! , [...]
                         // https://github.com/dotnet/roslyn/issues/58335: https://github.com/dotnet/roslyn/pull/46520#discussion_r466650228
                         if (after.Kind == SyntaxKind.ExclamationToken
-                            && this.PeekToken(3).Kind == SyntaxKind.ExclamationToken
-                            && after.GetTrailingTriviaWidth() == 0
-                            && this.PeekToken(3).GetLeadingTriviaWidth() == 0
+                            && token3.Kind == SyntaxKind.ExclamationToken
+                            && NoTriviaBetween(after, token3)
                             && this.PeekToken(4).Kind == SyntaxKind.CommaToken)
                         {
                             return true;
@@ -11655,8 +11646,7 @@ private bool ScanExplicitlyTypedLambda(Precedence precedence)
                     }
                     if (this.CurrentToken.Kind == SyntaxKind.ExclamationToken
                         && this.PeekToken(1).Kind == SyntaxKind.ExclamationToken
-                        && this.CurrentToken.GetTrailingTriviaWidth() == 0
-                        && this.PeekToken(1).GetLeadingTriviaWidth() == 0)
+                        && NoTriviaBetween(this.CurrentToken, this.PeekToken(1)))
                     {
                         this.EatToken();
                         this.EatToken();
@@ -11895,28 +11885,44 @@ private bool IsPossibleLambdaExpression(Precedence precedence)
                 return false;
             }
 
-            SyntaxKind token1 = this.PeekToken(1).Kind;
-            if (token1 == SyntaxKind.EqualsGreaterThanToken)
+            var token1 = this.PeekToken(1);
+
+            // x => 
+            //
+            // Def a lambda.
+            if (token1.Kind == SyntaxKind.EqualsGreaterThanToken)
             {
                 return true;
             }
-            if (token1 == SyntaxKind.ExclamationToken
-                && this.PeekToken(2).Kind == SyntaxKind.ExclamationToken
-                && this.PeekToken(3).Kind == SyntaxKind.EqualsGreaterThanToken)
+
+            var token2 = this.PeekToken(2);
+            var token3 = this.PeekToken(3);
+
+            // x!! =>
+            //
+            // Def a lambda (though possibly has errors).
+            if (token1.Kind == SyntaxKind.ExclamationToken
+                && token2.Kind == SyntaxKind.ExclamationToken
+                && token3.Kind == SyntaxKind.EqualsGreaterThanToken
+                && NoTriviaBetween(token1, token2))
             {
                 return true;
             }
 
             // Broken case but error will be added in lambda function (!=>).
-            if (token1 == SyntaxKind.ExclamationEqualsToken && this.PeekToken(2).Kind == SyntaxKind.GreaterThanToken)
+            if (token1.Kind == SyntaxKind.ExclamationEqualsToken &&
+                token2.Kind == SyntaxKind.GreaterThanToken &&
+                NoTriviaBetween(token1, token2))
             {
                 return true;
             }
 
             // Broken case but error will be added in lambda function (!!=>).
-            if (token1 == SyntaxKind.ExclamationToken
-                && this.PeekToken(2).Kind == SyntaxKind.ExclamationEqualsToken
-                && this.PeekToken(3).Kind == SyntaxKind.GreaterThanToken)
+            if (token1.Kind == SyntaxKind.ExclamationToken
+                && token2.Kind == SyntaxKind.ExclamationEqualsToken
+                && token3.Kind == SyntaxKind.GreaterThanToken
+                && NoTriviaBetween(token1, token2)
+                && NoTriviaBetween(token2, token3))
             {
                 return true;
             }
@@ -12930,19 +12936,27 @@ LambdaExpressionSyntax parseLambdaExpressionWorker()
                 {
                     var identifier = this.ParseIdentifierToken();
 
-                    ParseParameterRest(equalsValueLegal: false, ref identifier, out var exclamationExclamationToken, out var equalsValueClause);
+                    ParseParameterRest(ref identifier, out var exclamationExclamationToken, out var equalsToken);
 
-                    // Case x=>, x =>
-                    var arrow = this.EatToken(SyntaxKind.EqualsGreaterThanToken);
-                    if (arrow != null)
+                    SyntaxToken arrow;
+                    if (equalsToken != null)
                     {
-                        arrow = (arrow.Kind != SyntaxKind.EqualsGreaterThanToken)
-                            ? ConvertToMissingWithTrailingTrivia(arrow, SyntaxKind.EqualsGreaterThanToken)
-                            : CheckFeatureAvailability(arrow, MessageID.IDS_FeatureLambda);
+                        var greaterThan = this.EatToken();
+                        Debug.Assert(greaterThan.Kind == SyntaxKind.GreaterThanToken);
+                        Debug.Assert(greaterThan.GetLeadingTriviaWidth() == 0);
+                        arrow = SyntaxFactory.Token(equalsToken.GetLeadingTrivia(), SyntaxKind.EqualsGreaterThanToken, greaterThan.GetTrailingTrivia());
                     }
+                    else
+                    {
+                        // Case x=>, x =>
+                        arrow = this.EatToken(SyntaxKind.EqualsGreaterThanToken);
+                    }
+
+                    if (arrow != null)
+                        arrow = CheckFeatureAvailability(arrow, MessageID.IDS_FeatureLambda);
 
                     var parameter = _syntaxFactory.Parameter(
-                        attributeLists: default, modifiers: default, type: null, identifier, exclamationExclamationToken, equalsValueClause);
+                        attributeLists: default, modifiers: default, type: null, identifier, exclamationExclamationToken, @default: null);
                     var (block, expression) = ParseLambdaBody();
                     return _syntaxFactory.SimpleLambdaExpression(
                         attributes, modifiers, parameter, arrow, block, expression);
@@ -13066,7 +13080,27 @@ private ParameterSyntax ParseLambdaParameter()
             }
 
             var identifier = this.ParseIdentifierToken();
-            ParseParameterRest(equalsValueLegal: false, ref identifier, out var exclamationExclamationToken, out var equalsValueClause);
+            ParseParameterRest(ref identifier, out var exclamationExclamationToken, out var equalsToken);
+
+            // This should never be non-null.  That indicates while we were scanning for potential lambdas, we saw an
+            // `=` sign in the parameter list and allowed it.  No existing lambda scanning should succeed on that, and
+            // it would be extremely difficult to even support as that would require arbitrary expr parsing during
+            // lookahead.  Many tests are added though so if that ever changes we will hit this and immediately
+            // have to address what to do here.
+            Debug.Assert(equalsToken == null);
+            if (equalsToken != null)
+            {
+                equalsToken = AddError(equalsToken, ErrorCode.ERR_UnexpectedToken, equalsToken.ToString());
+                if (exclamationExclamationToken != null)
+                {
+                    exclamationExclamationToken = AddTrailingSkippedSyntax(exclamationExclamationToken, equalsToken);
+                }
+                else
+                {
+                    identifier = AddTrailingSkippedSyntax(identifier, equalsToken);
+                }
+            }
+
             var parameter = _syntaxFactory.Parameter(attributes, modifiers.ToList(), paramType, identifier, exclamationExclamationToken, equalsValueClause);
             _pool.Free(modifiers);
             return parameter;
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
index 63f1721dfc3ff..34a03beb0eecf 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
@@ -1820,6 +1820,213 @@ public void TestNullCheckedSyntaxCorrection9()
             }
         }
 
+        [Fact]
+        public void TestBracesAfterSimpleLambdaName()
+        {
+            UsingDeclaration("Func<string[], string> func0 = x[] => x;", options: TestOptions.RegularPreview,
+                    // (1,34): error CS0443: Syntax error; value expected
+                    // Func<string[], string> func0 = x[] => x;
+                    Diagnostic(ErrorCode.ERR_ValueExpected, "]").WithLocation(1, 34),
+                    // (1,36): error CS1003: Syntax error, ',' expected
+                    // Func<string[], string> func0 = x[] => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 36));
+            EOF();
+        }
+
+        [Fact]
+        public void TestBracesAfterParenthesizedLambdaName()
+        {
+            UsingDeclaration("Func<string[], string> func0 = (x[]) => x;", options: TestOptions.RegularPreview,
+                    // (1,36): error CS1001: Identifier expected
+                    // Func<string[], string> func0 = (x[]) => x;
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, ")").WithLocation(1, 36));
+            EOF();
+        }
+
+        [Fact]
+        public void TestBracesAfterParenthesizedLambdaTypeAndName()
+        {
+            UsingDeclaration("Func<string[], string> func0 = (string x[]) => x;", options: TestOptions.RegularPreview,
+                    // (1,33): error CS1525: Invalid expression term 'string'
+                    // Func<string[], string> func0 = (string x[]) => x;
+                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "string").WithArguments("string").WithLocation(1, 33),
+                    // (1,40): error CS1026: ) expected
+                    // Func<string[], string> func0 = (string x[]) => x;
+                    Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 40),
+                    // (1,40): error CS1003: Syntax error, ',' expected
+                    // Func<string[], string> func0 = (string x[]) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 40));
+            EOF();
+        }
+
+        [Fact]
+        public void TestDefaultValueSimpleLambda()
+        {
+            UsingDeclaration("Func<string, string> func0 = x = null => x;", options: TestOptions.RegularPreview,
+                    // (1,39): error CS1003: Syntax error, ',' expected
+                    // Func<string, string> func0 = x = null => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 39));
+            EOF();
+        }
+
+        [Fact]
+        public void TestDefaultValueParenthesizedLamda1()
+        {
+            UsingDeclaration("Func<string, string> func0 = (x = null) => x;", options: TestOptions.RegularPreview,
+                    // (1,41): error CS1003: Syntax error, ',' expected
+                    // Func<string, string> func0 = (x = null) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 41));
+            EOF();
+        }
+
+        [Fact]
+        public void TestDefaultValueParenthesizedLamda2()
+        {
+            UsingDeclaration("Func<string, string> func0 = (y, x = null) => x;", options: TestOptions.RegularPreview,
+                    // (1,44): error CS1003: Syntax error, ',' expected
+                    // Func<string, string> func0 = (y, x = null) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 44));
+            EOF();
+        }
+
+        [Fact]
+        public void TestDefaultValueParenthesizedLamdaWithType1()
+        {
+            UsingDeclaration("Func<string, string> func0 = (string x = null) => x;", options: TestOptions.RegularPreview,
+                    // (1,31): error CS1525: Invalid expression term 'string'
+                    // Func<string, string> func0 = (string x = null) => x;
+                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "string").WithArguments("string").WithLocation(1, 31),
+                    // (1,38): error CS1026: ) expected
+                    // Func<string, string> func0 = (string x = null) => x;
+                    Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 38),
+                    // (1,38): error CS1003: Syntax error, ',' expected
+                    // Func<string, string> func0 = (string x = null) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 38));
+            EOF();
+        }
+
+        [Fact]
+        public void TestDefaultValueParenthesizedLamdaWithType2()
+        {
+            UsingDeclaration("Func<string, string> func0 = (string y, string x = null) => x;", options: TestOptions.RegularPreview,
+                    // (1,41): error CS1525: Invalid expression term 'string'
+                    // Func<string, string> func0 = (string y, string x = null) => x;
+                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "string").WithArguments("string").WithLocation(1, 41),
+                    // (1,48): error CS1026: ) expected
+                    // Func<string, string> func0 = (string y, string x = null) => x;
+                    Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 48),
+                    // (1,48): error CS1003: Syntax error, ',' expected
+                    // Func<string, string> func0 = (string y, string x = null) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 48));
+            EOF();
+        }
+
+        [Fact]
+        public void TestNullCheckedDefaultValueSimpleLambda()
+        {
+            UsingDeclaration("Func<string, string> func0 = x!! = null => x;", options: TestOptions.RegularPreview,
+                    // (1,41): error CS1003: Syntax error, ',' expected
+                    // Func<string, string> func0 = x!! = null => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 41));
+            EOF();
+        }
+
+        [Fact]
+        public void TestNullCheckedDefaultValueParenthesizedLamda1()
+        {
+            UsingDeclaration("Func<string, string> func0 = (x!! = null) => x;", options: TestOptions.RegularPreview,
+                    // (1,43): error CS1003: Syntax error, ',' expected
+                    // Func<string, string> func0 = (x!! = null) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 43));
+            EOF();
+        }
+
+        [Fact]
+        public void TestNullCheckedDefaultValueParenthesizedLamda2()
+        {
+            UsingDeclaration("Func<string, string> func0 = (y, x!! = null) => x;", options: TestOptions.RegularPreview,
+                    // (1,46): error CS1003: Syntax error, ',' expected
+                    // Func<string, string> func0 = (y, x!! = null) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 46));
+            EOF();
+        }
+
+        [Fact]
+        public void TestNullCheckedDefaultValueParenthesizedLamdaWithType1()
+        {
+            UsingDeclaration("Func<string, string> func0 = (string x!! = null) => x;", options: TestOptions.RegularPreview,
+                    // (1,31): error CS1525: Invalid expression term 'string'
+                    // Func<string, string> func0 = (string x!! = null) => x;
+                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "string").WithArguments("string").WithLocation(1, 31),
+                    // (1,38): error CS1026: ) expected
+                    // Func<string, string> func0 = (string x!! = null) => x;
+                    Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 38),
+                    // (1,38): error CS1003: Syntax error, ',' expected
+                    // Func<string, string> func0 = (string x!! = null) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 38));
+            EOF();
+        }
+
+        [Fact]
+        public void TestNullCheckedDefaultValueParenthesizedLamdaWithType2()
+        {
+            UsingDeclaration("Func<string, string> func0 = (string y, string x!! = null) => x;", options: TestOptions.RegularPreview,
+                // (1,41): error CS1525: Invalid expression term 'string'
+                // Func<string, string> func0 = (string y, string x!! = null) => x;
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "string").WithArguments("string").WithLocation(1, 41),
+                // (1,48): error CS1026: ) expected
+                // Func<string, string> func0 = (string y, string x!! = null) => x;
+                Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 48),
+                // (1,48): error CS1003: Syntax error, ',' expected
+                // Func<string, string> func0 = (string y, string x!! = null) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 48));
+            EOF();
+        }
+
+        [Fact]
+        public void TestNullCheckedSpaceBetweenSimpleLambda()
+        {
+            UsingDeclaration("Func<string, string> func0 = x! ! => x;", options: TestOptions.RegularPreview);
+            EOF();
+        }
+
+        [Fact]
+        public void TestNullCheckedSpaceBetweenParenthesizedLamda1()
+        {
+            UsingDeclaration("Func<string, string> func0 = (x! !) => x;", options: TestOptions.RegularPreview);
+            EOF();
+        }
+
+        [Fact]
+        public void TestNullCheckedSpaceBetweenParenthesizedLamda2()
+        {
+            UsingDeclaration("Func<string, string> func0 = (y, x! !) => x;", options: TestOptions.RegularPreview);
+            EOF();
+        }
+
+        [Fact]
+        public void TestNullCheckedSpaceBetweenLamdaWithType1()
+        {
+            UsingDeclaration("Func<string, string> func0 = (string x! !) => x;", options: TestOptions.RegularPreview,
+                    // (1,31): error CS1525: Invalid expression term 'string'
+                    // Func<string, string> func0 = (string x! !) => x;
+                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "string").WithArguments("string").WithLocation(1, 31),
+                    // (1,38): error CS1026: ) expected
+                    // Func<string, string> func0 = (string x! !) => x;
+                    Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 38),
+                    // (1,38): error CS1003: Syntax error, ',' expected
+                    // Func<string, string> func0 = (string x! !) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 38));
+            EOF();
+        }
+
+        [Fact]
+        public void TestNullCheckedSpaceBetweenLamdaWithType2()
+        {
+            UsingDeclaration("Func<string, string> func0 = (string y, string x! !) => x;", options: TestOptions.RegularPreview);
+            EOF();
+        }
+
         [Fact]
         public void AsyncAwaitInLambda()
         {

From c2c0ad92810556e81c5385ccbb2948c2920be348 Mon Sep 17 00:00:00 2001
From: Rikki Gibson <rigibson@microsoft.com>
Date: Wed, 5 Jan 2022 14:34:23 -0800
Subject: [PATCH 238/444] Move off deprecated Mac queue (#58639)

---
 azure-pipelines.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index eec4412e96951..86e5e62c4fc27 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -149,7 +149,7 @@ jobs:
     buildJobName: Build_Unix_Debug
     testArtifactName: Transport_Artifacts_Unix_Debug
     configuration: Debug
-    testArguments: --testCoreClr --helixQueueName OSX.1014.Amd64.Open
+    testArguments: --testCoreClr --helixQueueName OSX.1015.Amd64.Open
 
 - template: eng/common/templates/jobs/source-build.yml
 

From 134249cf8afd86602fce1010fda59b6275c06efd Mon Sep 17 00:00:00 2001
From: Chris Sienkiewicz <chsienki@microsoft.com>
Date: Wed, 5 Jan 2022 14:53:16 -0800
Subject: [PATCH 239/444] Fix null reference in SyntaxInputNode (#58649)

* Ensure we don't try and remove transform table entries if filter table failed.
---
 .../SyntaxAwareGeneratorTests.cs              | 52 +++++++++++++++++++
 .../SourceGeneration/Nodes/SyntaxInputNode.cs | 10 ++--
 2 files changed, 57 insertions(+), 5 deletions(-)

diff --git a/src/Compilers/CSharp/Test/Semantic/SourceGeneration/SyntaxAwareGeneratorTests.cs b/src/Compilers/CSharp/Test/Semantic/SourceGeneration/SyntaxAwareGeneratorTests.cs
index 025bb613231dc..ce8de0cfc2d46 100644
--- a/src/Compilers/CSharp/Test/Semantic/SourceGeneration/SyntaxAwareGeneratorTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/SourceGeneration/SyntaxAwareGeneratorTests.cs
@@ -13,6 +13,7 @@
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Text;
+using Roslyn.Test.Utilities;
 using Roslyn.Test.Utilities.TestGenerators;
 using Xunit;
 
@@ -1159,6 +1160,57 @@ class D
                     output => Assert.Equal(("fieldE", IncrementalStepRunReason.Removed), output)));
         }
 
+        [Fact]
+        [WorkItem(58647, "https://github.com/dotnet/roslyn/issues/58647")]
+        public void IncrementalGenerator_With_Syntax_Filter_Removed_Tree_Add_New_Generator()
+        {
+            var source1 = @"
+#pragma warning disable CS0414
+class C 
+{
+    string fieldA = null; 
+    string fieldB = null;
+    string fieldC = null;
+}";
+
+            var source2 = @"
+#pragma warning disable CS0414
+class D
+{
+    string fieldD = null; 
+    string fieldE = null;
+}
+";
+
+            var parseOptions = TestOptions.RegularPreview;
+            Compilation compilation = CreateCompilation(new[] { source1, source2 }, options: TestOptions.DebugDll, parseOptions: parseOptions);
+            compilation.VerifyDiagnostics();
+
+            var testGenerator = new PipelineCallbackGenerator(context =>
+            {
+                var source = context.SyntaxProvider.CreateSyntaxProvider((c, _) => c is FieldDeclarationSyntax fds, (c, _) => ((FieldDeclarationSyntax)c.Node).Declaration.Variables[0].Identifier.ValueText);
+                context.RegisterSourceOutput(source, (spc, fieldName) =>
+                {
+                });
+            });
+
+            var testGenerator2 = new PipelineCallbackGenerator2(context =>
+            {
+                var source = context.SyntaxProvider.CreateSyntaxProvider((c, _) => c is FieldDeclarationSyntax fds, (c, _) => ((FieldDeclarationSyntax)c.Node).Declaration.Variables[0].Identifier.ValueText);
+                context.RegisterSourceOutput(source, (spc, fieldName) =>
+                {
+                });
+            });
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new[] { new IncrementalGeneratorWrapper(testGenerator) }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+
+            // remove the second tree, and add the new generator
+            compilation = compilation.RemoveSyntaxTrees(compilation.SyntaxTrees.Last());
+            driver = driver.AddGenerators(ImmutableArray.Create(testGenerator2.AsSourceGenerator()));
+            driver = driver.RunGenerators(compilation);
+        }
+
         [Fact]
         public void IncrementalGenerator_With_Syntax_Filter_Runs_Only_For_Changed_Trees()
         {
diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/SyntaxInputNode.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/SyntaxInputNode.cs
index 3899051a0353e..fbe9860abfe0c 100644
--- a/src/Compilers/Core/Portable/SourceGeneration/Nodes/SyntaxInputNode.cs
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/SyntaxInputNode.cs
@@ -74,13 +74,13 @@ public void VisitTree(Lazy<SyntaxNode> root, EntryState state, SemanticModel? mo
                 if (state == EntryState.Removed)
                 {
                     // mark both syntax *and* transform nodes removed
-                    _filterTable.TryRemoveEntries(TimeSpan.Zero, noInputStepsStepInfo, out ImmutableArray<SyntaxNode> removedNodes);
-
-                    for (int i = 0; i < removedNodes.Length; i++)
+                    if (_filterTable.TryRemoveEntries(TimeSpan.Zero, noInputStepsStepInfo, out ImmutableArray<SyntaxNode> removedNodes))
                     {
-                        _transformTable.TryRemoveEntries(TimeSpan.Zero, noInputStepsStepInfo);
+                        for (int i = 0; i < removedNodes.Length; i++)
+                        {
+                            _transformTable.TryRemoveEntries(TimeSpan.Zero, noInputStepsStepInfo);
+                        }
                     }
-
                 }
                 else
                 {

From 63799ac30c4746b3bd3135133c6f5409e7a231b2 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Wed, 5 Jan 2022 15:02:50 -0800
Subject: [PATCH 240/444] Code changes

---
 .../CSharp/Portable/Parser/LanguageParser.cs  | 132 +++---
 .../Portable/xlf/CSharpResources.cs.xlf       |   5 -
 .../Portable/xlf/CSharpResources.de.xlf       |   5 -
 .../Portable/xlf/CSharpResources.es.xlf       |   5 -
 .../Portable/xlf/CSharpResources.fr.xlf       |   5 -
 .../Portable/xlf/CSharpResources.it.xlf       |   5 -
 .../Portable/xlf/CSharpResources.ja.xlf       |   5 -
 .../Portable/xlf/CSharpResources.ko.xlf       |   5 -
 .../Portable/xlf/CSharpResources.pl.xlf       |   5 -
 .../Portable/xlf/CSharpResources.pt-BR.xlf    |   5 -
 .../Portable/xlf/CSharpResources.ru.xlf       |   5 -
 .../Portable/xlf/CSharpResources.tr.xlf       |   5 -
 .../Portable/xlf/CSharpResources.zh-Hans.xlf  |   5 -
 .../Portable/xlf/CSharpResources.zh-Hant.xlf  |   5 -
 .../Parsing/LambdaParameterParsingTests.cs    | 400 ++----------------
 15 files changed, 113 insertions(+), 484 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
index 0543a56b06dfc..6a9da5d306365 100644
--- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
+++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
@@ -14,6 +14,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax
 {
+    using Microsoft.CodeAnalysis.PooledObjects;
     using Microsoft.CodeAnalysis.Syntax.InternalSyntax;
 
     internal partial class LanguageParser : SyntaxParser
@@ -4402,6 +4403,9 @@ private ParameterSyntax ParseParameter()
 
                 ParseParameterRest(ref identifier, out var exclamationExclamationToken, out var equalsToken);
 
+                // If we didn't already consume an equals sign as part of !!=, then try to scan one out now.
+                equalsToken ??= TryEatToken(SyntaxKind.EqualsToken);
+
                 EqualsValueClauseSyntax equalsValueClause = null;
                 if (equalsToken != null)
                     equalsValueClause = CheckFeatureAvailability(_syntaxFactory.EqualsValueClause(equalsToken, this.ParseExpressionCore()), MessageID.IDS_FeatureOptionalParameter);
@@ -4417,7 +4421,9 @@ private ParameterSyntax ParseParameter()
 #nullable enable
 
         /// <summary>
-        /// Parses out the remainder of a parameter once the type and identifier of it has been parsed out already.
+        /// Parses out the remainder of a parameter once the type and identifier of it has been parsed out already.  If
+        /// the token is followed by <c>!!=</c> or <c>! !=</c>, then the final equals will be returned out through
+        /// <paramref name="equalsToken"/>.
         /// </summary>
         private void ParseParameterRest(
             ref SyntaxToken identifier,
@@ -4425,6 +4431,7 @@ private void ParseParameterRest(
             out SyntaxToken? equalsToken)
         {
             exclamationExclamationToken = null;
+            equalsToken = null;
 
             // When the user type "int goo[]", give them a useful error
             if (this.CurrentToken.Kind is SyntaxKind.OpenBracketToken && this.PeekToken(1).Kind is SyntaxKind.CloseBracketToken)
@@ -4434,47 +4441,76 @@ private void ParseParameterRest(
                     this.EatToken()));
             }
 
-            if (this.CurrentToken.Kind is not SyntaxKind.ExclamationToken)
+            if (this.CurrentToken.Kind is SyntaxKind.ExclamationEqualsToken)
             {
-                equalsToken = this.TryEatToken(SyntaxKind.EqualsToken);
-                return;
+                // split != into two tokens.
+                var exclamationEquals = this.EatToken();
+
+                // Report that the ! should have been !!
+                exclamationExclamationToken = WithAdditionalDiagnostics(
+                    SyntaxFactory.Token(exclamationEquals.GetLeadingTrivia(), SyntaxKind.ExclamationExclamationToken, "!", "!", trailing: null),
+                    this.GetExpectedTokenError(expected: SyntaxKind.ExclamationExclamationToken, actual: SyntaxKind.ExclamationToken));
+
+                // Return the split out `=` for the consumer to handle.
+                equalsToken = SyntaxFactory.Token(leading: null, SyntaxKind.EqualsToken, exclamationEquals.GetTrailingTrivia());
             }
 
-            // We have seen at least !
-            //
-            // We can potentially merge that with an immediately following !! or an immediately following !=
-            // All other cases are in error.
-            var exclamationToken = this.EatToken();
-            if (NoTriviaBetween(exclamationToken, this.CurrentToken) &&
-                this.CurrentToken.Kind is SyntaxKind.ExclamationToken or SyntaxKind.ExclamationEqualsToken)
+            if (this.CurrentToken.Kind is SyntaxKind.ExclamationToken)
             {
-                if (this.CurrentToken.Kind is SyntaxKind.ExclamationToken)
+                // We have seen at least !
+                //
+                // We can potentially merge that with an immediately following !! or an immediately following !=
+                // All other cases are in error.
+                var firstExclamation = this.EatToken();
+                if (this.CurrentToken.Kind is SyntaxKind.ExclamationToken or SyntaxKind.ExclamationEqualsToken)
                 {
-                    var secondExclamation = this.EatToken();
-                    exclamationExclamationToken = SyntaxFactory.Token(exclamationToken.GetLeadingTrivia(), SyntaxKind.ExclamationExclamationToken, secondExclamation.GetTrailingTrivia());
-                    equalsToken = this.TryEatToken(SyntaxKind.EqualsToken);
+                    if (this.CurrentToken.Kind is SyntaxKind.ExclamationToken)
+                    {
+                        // have two !'s in a row.  Merge them (reporting any errors if they cannot merge properly).
+                        exclamationExclamationToken = MergeAdjacent(firstExclamation, this.EatToken(), SyntaxKind.ExclamationExclamationToken);
+                    }
+                    else
+                    {
+                        Debug.Assert(this.CurrentToken.Kind == SyntaxKind.ExclamationEqualsToken);
+                        // split != into two tokens.
+                        var exclamationEquals = this.EatToken();
+
+                        exclamationExclamationToken = MergeAdjacent(
+                            firstExclamation,
+                            SyntaxFactory.Token(exclamationEquals.GetLeadingTrivia(), SyntaxKind.ExclamationToken, trailing: null),
+                            SyntaxKind.ExclamationExclamationToken);
+                        equalsToken = SyntaxFactory.Token(leading: null, SyntaxKind.EqualsToken, exclamationEquals.GetTrailingTrivia());
+                    }
                 }
                 else
                 {
-                    Debug.Assert(this.CurrentToken.Kind == SyntaxKind.ExclamationEqualsToken);
-                    var exclamationEquals = this.EatToken();
-                    exclamationExclamationToken = SyntaxFactory.Token(exclamationToken.GetLeadingTrivia(), SyntaxKind.ExclamationExclamationToken, trailing: null);
-                    equalsToken = SyntaxFactory.Token(leading: null, SyntaxKind.EqualsToken, exclamationEquals.GetTrailingTrivia());
+                    // Report that the ! should have been !!
+                    exclamationExclamationToken = WithAdditionalDiagnostics(
+                        SyntaxFactory.Token(firstExclamation.GetLeadingTrivia(), SyntaxKind.ExclamationExclamationToken, "!", "!", trailing: firstExclamation.GetTrailingTrivia())
+                        this.GetExpectedTokenError(expected: SyntaxKind.ExclamationExclamationToken, actual: firstExclamation.Kind));
                 }
             }
-            else
-            {
-                // We had ! followed by something bogus (like a comma/close paren).  Or it was followed by another !,
-                // but they were not directly touching.  Given an appropriate error that `!!` was expected and continue.
-
-                exclamationExclamationToken = WithAdditionalDiagnostics(exclamationToken, this.GetExpectedTokenError(SyntaxKind.ExclamationExclamationToken, exclamationToken.Kind));
-                equalsToken = this.TryEatToken(SyntaxKind.EqualsToken);
-            }
 
             if (exclamationExclamationToken != null)
                 exclamationExclamationToken = CheckFeatureAvailability(exclamationExclamationToken, MessageID.IDS_ParameterNullChecking);
         }
 
+        private SyntaxToken? MergeAdjacent(SyntaxToken t1, SyntaxToken t2, SyntaxKind kind)
+        {
+            if (t1.GetTrailingTriviaWidth() == 0 && t2.GetLeadingTriviaWidth() == 0)
+                return SyntaxFactory.Token(t1.GetLeadingTrivia(), kind, t2.GetTrailingTrivia());
+
+            var sb = PooledStringBuilder.GetInstance();
+            var writer = new System.IO.StringWriter(sb.Builder, System.Globalization.CultureInfo.InvariantCulture);
+            t1.WriteTo(writer, leading: false, trailing: true);
+            t2.WriteTo(writer, leading: true, trailing: false);
+            var text = sb.ToStringAndFree();
+
+            return WithAdditionalDiagnostics(
+                SyntaxFactory.Token(t1.GetLeadingTrivia(), kind, text, text, t2.GetTrailingTrivia()),
+                GetExpectedTokenError(kind, t1.Kind));
+        }
+
         private static bool NoTriviaBetween(SyntaxToken token1, SyntaxToken token2)
             => token1.GetTrailingTriviaWidth() == 0 && token2.GetLeadingTriviaWidth() == 0;
 
@@ -11575,7 +11611,6 @@ bool isParenVarCommaSyntax()
                         // https://github.com/dotnet/roslyn/issues/58335: https://github.com/dotnet/roslyn/pull/46520#discussion_r466650228
                         if (after.Kind == SyntaxKind.ExclamationToken
                             && token3.Kind == SyntaxKind.ExclamationToken
-                            && NoTriviaBetween(after, token3)
                             && this.PeekToken(4).Kind == SyntaxKind.CommaToken)
                         {
                             return true;
@@ -11645,8 +11680,7 @@ private bool ScanExplicitlyTypedLambda(Precedence precedence)
                         this.EatToken();
                     }
                     if (this.CurrentToken.Kind == SyntaxKind.ExclamationToken
-                        && this.PeekToken(1).Kind == SyntaxKind.ExclamationToken
-                        && NoTriviaBetween(this.CurrentToken, this.PeekToken(1)))
+                        && this.PeekToken(1).Kind == SyntaxKind.ExclamationToken)
                     {
                         this.EatToken();
                         this.EatToken();
@@ -11903,16 +11937,14 @@ private bool IsPossibleLambdaExpression(Precedence precedence)
             // Def a lambda (though possibly has errors).
             if (token1.Kind == SyntaxKind.ExclamationToken
                 && token2.Kind == SyntaxKind.ExclamationToken
-                && token3.Kind == SyntaxKind.EqualsGreaterThanToken
-                && NoTriviaBetween(token1, token2))
+                && token3.Kind == SyntaxKind.EqualsGreaterThanToken)
             {
                 return true;
             }
 
             // Broken case but error will be added in lambda function (!=>).
-            if (token1.Kind == SyntaxKind.ExclamationEqualsToken &&
-                token2.Kind == SyntaxKind.GreaterThanToken &&
-                NoTriviaBetween(token1, token2))
+            if (token1.Kind == SyntaxKind.ExclamationEqualsToken
+                && token2.Kind == SyntaxKind.GreaterThanToken)
             {
                 return true;
             }
@@ -11920,9 +11952,7 @@ private bool IsPossibleLambdaExpression(Precedence precedence)
             // Broken case but error will be added in lambda function (!!=>).
             if (token1.Kind == SyntaxKind.ExclamationToken
                 && token2.Kind == SyntaxKind.ExclamationEqualsToken
-                && token3.Kind == SyntaxKind.GreaterThanToken
-                && NoTriviaBetween(token1, token2)
-                && NoTriviaBetween(token2, token3))
+                && token3.Kind == SyntaxKind.GreaterThanToken)
             {
                 return true;
             }
@@ -12941,10 +12971,12 @@ LambdaExpressionSyntax parseLambdaExpressionWorker()
                     SyntaxToken arrow;
                     if (equalsToken != null)
                     {
+                        // we only get an equals token if we had !!=> or !=> (enforced by IsPossibleLambdaExpression).
+                        // So we must have a greater than token following.  If not, some invariant is badly broken.
+
                         var greaterThan = this.EatToken();
                         Debug.Assert(greaterThan.Kind == SyntaxKind.GreaterThanToken);
-                        Debug.Assert(greaterThan.GetLeadingTriviaWidth() == 0);
-                        arrow = SyntaxFactory.Token(equalsToken.GetLeadingTrivia(), SyntaxKind.EqualsGreaterThanToken, greaterThan.GetTrailingTrivia());
+                        arrow = MergeAdjacent(equalsToken, greaterThan, SyntaxKind.EqualsGreaterThanToken);
                     }
                     else
                     {
@@ -13083,25 +13115,11 @@ private ParameterSyntax ParseLambdaParameter()
             ParseParameterRest(ref identifier, out var exclamationExclamationToken, out var equalsToken);
 
             // This should never be non-null.  That indicates while we were scanning for potential lambdas, we saw an
-            // `=` sign in the parameter list and allowed it.  No existing lambda scanning should succeed on that, and
-            // it would be extremely difficult to even support as that would require arbitrary expr parsing during
-            // lookahead.  Many tests are added though so if that ever changes we will hit this and immediately
-            // have to address what to do here.
+            // `!!=` or `!=` sign in the parameter list and allowed it. However, that should never happen as
+            // ScanParenthesizedLambda only allows !! only.
             Debug.Assert(equalsToken == null);
-            if (equalsToken != null)
-            {
-                equalsToken = AddError(equalsToken, ErrorCode.ERR_UnexpectedToken, equalsToken.ToString());
-                if (exclamationExclamationToken != null)
-                {
-                    exclamationExclamationToken = AddTrailingSkippedSyntax(exclamationExclamationToken, equalsToken);
-                }
-                else
-                {
-                    identifier = AddTrailingSkippedSyntax(identifier, equalsToken);
-                }
-            }
 
-            var parameter = _syntaxFactory.Parameter(attributes, modifiers.ToList(), paramType, identifier, exclamationExclamationToken, equalsValueClause);
+            var parameter = _syntaxFactory.Parameter(attributes, modifiers.ToList(), paramType, identifier, exclamationExclamationToken, @default: null);
             _pool.Free(modifiers);
             return parameter;
         }
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
index 8f2664b901ac0..4dc96dd386ae2 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
@@ -347,11 +347,6 @@
         <target state="translated">Není k dispozici žádný cílový typ pro výchozí literál.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
-        <source>Default parameter value not allowed here</source>
-        <target state="new">Default parameter value not allowed here</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">Výchozí literál default není platný jako vzor. Podle potřeby použijte jiný literál (například 0 nebo null). Pokud chcete, aby odpovídalo vše, použijte vzor discard „_“.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
index 5c68bb77132d9..0a1f31f89a18a 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
@@ -347,11 +347,6 @@
         <target state="translated">Für das Standardliteral ist kein Zieltyp vorhanden.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
-        <source>Default parameter value not allowed here</source>
-        <target state="new">Default parameter value not allowed here</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">Ein Standardliteral "default" ist als Muster ungültig. Verwenden Sie ggf. ein anderes Literal (z. B. 0 oder "null"). Verwenden Sie zum Abgleich aller Elemente ein discard-Muster "_".</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
index 165d84094465d..5c52bac5afa6b 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
@@ -347,11 +347,6 @@
         <target state="translated">No hay ningún tipo de destino para el literal predeterminado.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
-        <source>Default parameter value not allowed here</source>
-        <target state="new">Default parameter value not allowed here</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">Un literal predeterminado "default" no es válido como patrón. Use otro literal (por ejemplo, "0" o "null") según corresponda. Para hacer coincidir todo, use un patrón de descarte "_".</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
index c2c5cf1791f08..2b392f5e2785a 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
@@ -347,11 +347,6 @@
         <target state="translated">Il n'existe aucun type cible pour le littéral par défaut.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
-        <source>Default parameter value not allowed here</source>
-        <target state="new">Default parameter value not allowed here</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">Un littéral par défaut 'default' est non valide en tant que modèle. Utilisez un autre littéral (par exemple, '0' ou 'null') selon le cas. Pour correspondre à tout, utilisez un modèle d'abandon '_'.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
index fe27897cb9abe..7d59f370dd547 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
@@ -347,11 +347,6 @@
         <target state="translated">Non esiste alcun tipo di destinazione per il valore letterale predefinito.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
-        <source>Default parameter value not allowed here</source>
-        <target state="new">Default parameter value not allowed here</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">Non è possibile usare un valore letterale predefinito 'default' come criterio. Usare un altro valore letterale, ad esempio '0' o 'null'. Per abbinare tutto, usare un criterio di rimozione '_'.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
index 69609cb89e48b..7e90412db3885 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
@@ -347,11 +347,6 @@
         <target state="translated">既定のリテラルのターゲット型がありません。</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
-        <source>Default parameter value not allowed here</source>
-        <target state="new">Default parameter value not allowed here</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">既定のリテラル 'default' はパターンとして無効です。必要に応じて別のリテラル (例: '0' または 'null') をご使用ください。すべてと一致させるには、破棄パターン '_' をご使用ください。</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
index 14d220a03d319..0efe3191f37f8 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
@@ -347,11 +347,6 @@
         <target state="translated">기본 리터럴의 대상 형식이 없습니다.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
-        <source>Default parameter value not allowed here</source>
-        <target state="new">Default parameter value not allowed here</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">기본 리터럴 'default'가 패턴으로 유효하지 않습니다. 다른 리터럴(예: '0' 또는 'null')을 적절하게 사용하세요. 모두 일치시키려면 무시 패턴 '_'을 사용하세요.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
index 475596107502f..2f856498d1a40 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
@@ -347,11 +347,6 @@
         <target state="translated">Brak typu docelowego dla literału domyślnego.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
-        <source>Default parameter value not allowed here</source>
-        <target state="new">Default parameter value not allowed here</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">Domyślny literał „default” nie jest prawidłowy jako wzorzec. Użyj innego odpowiedniego literału (np. „0” lub „null”). Aby dopasować wszystko, użyj wzorca odrzucania „_”.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
index cc335293db3f4..be8b3c36d676d 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
@@ -347,11 +347,6 @@
         <target state="translated">Não há um tipo de destino para o literal padrão.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
-        <source>Default parameter value not allowed here</source>
-        <target state="new">Default parameter value not allowed here</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">Um literal padrão 'default' não é válido como um padrão. Use outro literal (por exemplo, '0' ou 'null') conforme o necessário. Para corresponder a tudo, use um padrão de descarte '_'.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
index dc7b7338690b7..060db145dfa6e 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
@@ -347,11 +347,6 @@
         <target state="translated">Отсутствует целевой тип для литерала по умолчанию.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
-        <source>Default parameter value not allowed here</source>
-        <target state="new">Default parameter value not allowed here</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">Литерал по умолчанию "default" недопустимо использовать в качестве шаблона. Используйте другой литерал (например, "0" или "null") по мере необходимости. Чтобы задать полное совпадение, используйте шаблон отмены "_".</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
index 8a774ebcf2cf6..83cb76209ee3f 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
@@ -347,11 +347,6 @@
         <target state="translated">Varsayılan değişmez değer için hedef tür yok.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
-        <source>Default parameter value not allowed here</source>
-        <target state="new">Default parameter value not allowed here</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">'default' varsayılan sabit değeri bir desen olarak geçerli değil. Uygun olan başka bir sabit değeri (ör. '0' veya 'null') kullanın. Tüm öğeleri eşleştirmek için '_' atma desenini kullanın.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
index 44b701eae7378..de52f51125798 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
@@ -347,11 +347,6 @@
         <target state="translated">default 字面量缺少目标类型。</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
-        <source>Default parameter value not allowed here</source>
-        <target state="new">Default parameter value not allowed here</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">默认字面量“default”不能作为模式使用。请使用其他更适合的字面量（如“0”或“null”）。若要匹配任何输入，请使用放弃模式“_”。</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
index b4ee58d24cc73..49532a745b040 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
@@ -347,11 +347,6 @@
         <target state="translated">預設常值沒有目標類型。</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_DefaultParameterValueNotAllowed">
-        <source>Default parameter value not allowed here</source>
-        <target state="new">Default parameter value not allowed here</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ERR_DefaultPattern">
         <source>A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'.</source>
         <target state="translated">預設常值 'default' 作為模式無效。請使用另一個適當的常值 (例如 '0' 或 'null')。若要比對所有項目，請使用捨棄模式 '_'。</target>
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
index 34a03beb0eecf..63f3e200718c7 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
@@ -1227,228 +1227,33 @@ public void TestNullCheckedDiscard()
         public void TestNullCheckedSyntaxCorrection0()
         {
             UsingDeclaration("Func<string, string> func0 = x!=> x;", options: TestOptions.RegularPreview,
-                    // (1,31): error CS1003: Syntax error, '=>' expected
+                    // (1,31): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func0 = x!=> x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!=").WithArguments("=>", "!=").WithLocation(1, 31),
-                    // (1,31): error CS1525: Invalid expression term '!='
-                    // Func<string, string> func0 = x!=> x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!=").WithArguments("!=").WithLocation(1, 31),
-                    // (1,33): error CS1525: Invalid expression term '>'
-                    // Func<string, string> func0 = x!=> x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, ">").WithArguments(">").WithLocation(1, 33));
-            N(SyntaxKind.FieldDeclaration);
-            {
-                N(SyntaxKind.VariableDeclaration);
-                {
-                    N(SyntaxKind.GenericName);
-                    {
-                        N(SyntaxKind.IdentifierToken, "Func");
-                        N(SyntaxKind.TypeArgumentList);
-                        {
-                            N(SyntaxKind.LessThanToken);
-                            N(SyntaxKind.PredefinedType);
-                            {
-                                N(SyntaxKind.StringKeyword);
-                            }
-                            N(SyntaxKind.CommaToken);
-                            N(SyntaxKind.PredefinedType);
-                            {
-                                N(SyntaxKind.StringKeyword);
-                            }
-                            N(SyntaxKind.GreaterThanToken);
-                        }
-                    }
-                    N(SyntaxKind.VariableDeclarator);
-                    {
-                        N(SyntaxKind.IdentifierToken, "func0");
-                        N(SyntaxKind.EqualsValueClause);
-                        {
-                            N(SyntaxKind.EqualsToken);
-                            N(SyntaxKind.SimpleLambdaExpression);
-                            {
-                                N(SyntaxKind.Parameter);
-                                {
-                                    N(SyntaxKind.IdentifierToken, "x");
-                                }
-                                M(SyntaxKind.EqualsGreaterThanToken);
-                                N(SyntaxKind.NotEqualsExpression);
-                                {
-                                    M(SyntaxKind.IdentifierName);
-                                    {
-                                        M(SyntaxKind.IdentifierToken);
-                                    }
-                                    N(SyntaxKind.ExclamationEqualsToken);
-                                    N(SyntaxKind.GreaterThanExpression);
-                                    {
-                                        M(SyntaxKind.IdentifierName);
-                                        {
-                                            M(SyntaxKind.IdentifierToken);
-                                        }
-                                        N(SyntaxKind.GreaterThanToken);
-                                        N(SyntaxKind.IdentifierName);
-                                        {
-                                            N(SyntaxKind.IdentifierToken, "x");
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                N(SyntaxKind.SemicolonToken);
-            }
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 31));
+            EOF();
         }
 
         [Fact]
         public void TestNullCheckedSyntaxCorrection1()
         {
             UsingDeclaration("Func<string, string> func1 = x !=> x;", options: TestOptions.RegularPreview,
-                    // (1,32): error CS1003: Syntax error, '=>' expected
-                    // Func<string, string> func1 = x !=> x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!=").WithArguments("=>", "!=").WithLocation(1, 32),
-                    // (1,32): error CS1525: Invalid expression term '!='
+                    // (1,32): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func1 = x !=> x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!=").WithArguments("!=").WithLocation(1, 32),
-                    // (1,34): error CS1525: Invalid expression term '>'
-                    // Func<string, string> func1 = x !=> x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, ">").WithArguments(">").WithLocation(1, 34));
-            N(SyntaxKind.FieldDeclaration);
-            {
-                N(SyntaxKind.VariableDeclaration);
-                {
-                    N(SyntaxKind.GenericName);
-                    {
-                        N(SyntaxKind.IdentifierToken, "Func");
-                        N(SyntaxKind.TypeArgumentList);
-                        {
-                            N(SyntaxKind.LessThanToken);
-                            N(SyntaxKind.PredefinedType);
-                            {
-                                N(SyntaxKind.StringKeyword);
-                            }
-                            N(SyntaxKind.CommaToken);
-                            N(SyntaxKind.PredefinedType);
-                            {
-                                N(SyntaxKind.StringKeyword);
-                            }
-                            N(SyntaxKind.GreaterThanToken);
-                        }
-                    }
-                    N(SyntaxKind.VariableDeclarator);
-                    {
-                        N(SyntaxKind.IdentifierToken, "func1");
-                        N(SyntaxKind.EqualsValueClause);
-                        {
-                            N(SyntaxKind.EqualsToken);
-                            N(SyntaxKind.SimpleLambdaExpression);
-                            {
-                                N(SyntaxKind.Parameter);
-                                {
-                                    N(SyntaxKind.IdentifierToken, "x");
-                                }
-                                M(SyntaxKind.EqualsGreaterThanToken);
-                                N(SyntaxKind.NotEqualsExpression);
-                                {
-                                    M(SyntaxKind.IdentifierName);
-                                    {
-                                        M(SyntaxKind.IdentifierToken);
-                                    }
-                                    N(SyntaxKind.ExclamationEqualsToken);
-                                    N(SyntaxKind.GreaterThanExpression);
-                                    {
-                                        M(SyntaxKind.IdentifierName);
-                                        {
-                                            M(SyntaxKind.IdentifierToken);
-                                        }
-                                        N(SyntaxKind.GreaterThanToken);
-                                        N(SyntaxKind.IdentifierName);
-                                        {
-                                            N(SyntaxKind.IdentifierToken, "x");
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                N(SyntaxKind.SemicolonToken);
-            }
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 32));
+            EOF();
         }
 
         [Fact]
         public void TestNullCheckedSyntaxCorrection2()
         {
             UsingDeclaration("Func<string, string> func2 = x != > x;", options: TestOptions.RegularPreview,
-                    // (1,32): error CS1003: Syntax error, '=>' expected
+                    // (1,32): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func2 = x != > x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!=").WithArguments("=>", "!=").WithLocation(1, 32),
-                    // (1,32): error CS1525: Invalid expression term '!='
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 32),
+                    // (1,33): error CS1003: Syntax error, '=>' expected
                     // Func<string, string> func2 = x != > x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!=").WithArguments("!=").WithLocation(1, 32),
-                    // (1,35): error CS1525: Invalid expression term '>'
-                    // Func<string, string> func2 = x != > x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, ">").WithArguments(">").WithLocation(1, 35));
-            N(SyntaxKind.FieldDeclaration);
-            {
-                N(SyntaxKind.VariableDeclaration);
-                {
-                    N(SyntaxKind.GenericName);
-                    {
-                        N(SyntaxKind.IdentifierToken, "Func");
-                        N(SyntaxKind.TypeArgumentList);
-                        {
-                            N(SyntaxKind.LessThanToken);
-                            N(SyntaxKind.PredefinedType);
-                            {
-                                N(SyntaxKind.StringKeyword);
-                            }
-                            N(SyntaxKind.CommaToken);
-                            N(SyntaxKind.PredefinedType);
-                            {
-                                N(SyntaxKind.StringKeyword);
-                            }
-                            N(SyntaxKind.GreaterThanToken);
-                        }
-                    }
-                    N(SyntaxKind.VariableDeclarator);
-                    {
-                        N(SyntaxKind.IdentifierToken, "func2");
-                        N(SyntaxKind.EqualsValueClause);
-                        {
-                            N(SyntaxKind.EqualsToken);
-                            N(SyntaxKind.SimpleLambdaExpression);
-                            {
-                                N(SyntaxKind.Parameter);
-                                {
-                                    N(SyntaxKind.IdentifierToken, "x");
-                                }
-                                M(SyntaxKind.EqualsGreaterThanToken);
-                                N(SyntaxKind.NotEqualsExpression);
-                                {
-                                    M(SyntaxKind.IdentifierName);
-                                    {
-                                        M(SyntaxKind.IdentifierToken);
-                                    }
-                                    N(SyntaxKind.ExclamationEqualsToken);
-                                    N(SyntaxKind.GreaterThanExpression);
-                                    {
-                                        M(SyntaxKind.IdentifierName);
-                                        {
-                                            M(SyntaxKind.IdentifierToken);
-                                        }
-                                        N(SyntaxKind.GreaterThanToken);
-                                        N(SyntaxKind.IdentifierName);
-                                        {
-                                            N(SyntaxKind.IdentifierToken, "x");
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                N(SyntaxKind.SemicolonToken);
-            }
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments("=>", "=").WithLocation(1, 33));
+            EOF();
         }
 
         [Fact]
@@ -1607,55 +1412,10 @@ public void TestNullCheckedSyntaxCorrection5()
         public void TestNullCheckedSyntaxCorrection6()
         {
             UsingDeclaration("Func<string, string> func6 = x !!= > x;", options: TestOptions.RegularPreview,
-                    // (1,36): error CS1525: Invalid expression term '>'
+                    // (1,34): error CS1003: Syntax error, '=>' expected
                     // Func<string, string> func6 = x !!= > x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, ">").WithArguments(">").WithLocation(1, 36));
-            N(SyntaxKind.FieldDeclaration);
-            {
-                N(SyntaxKind.VariableDeclaration);
-                {
-                    N(SyntaxKind.GenericName);
-                    {
-                        N(SyntaxKind.IdentifierToken, "Func");
-                        N(SyntaxKind.TypeArgumentList);
-                        {
-                            N(SyntaxKind.LessThanToken);
-                            N(SyntaxKind.PredefinedType);
-                            {
-                                N(SyntaxKind.StringKeyword);
-                            }
-                            N(SyntaxKind.CommaToken);
-                            N(SyntaxKind.PredefinedType);
-                            {
-                                N(SyntaxKind.StringKeyword);
-                            }
-                            N(SyntaxKind.GreaterThanToken);
-                        }
-                    }
-                    N(SyntaxKind.VariableDeclarator);
-                    {
-                        N(SyntaxKind.IdentifierToken, "func6");
-                        N(SyntaxKind.EqualsValueClause);
-                        {
-                            N(SyntaxKind.EqualsToken);
-                            N(SyntaxKind.SimpleLambdaExpression);
-                            {
-                                N(SyntaxKind.Parameter);
-                                {
-                                    N(SyntaxKind.IdentifierToken, "x");
-                                    N(SyntaxKind.ExclamationExclamationToken);
-                                }
-                                M(SyntaxKind.EqualsGreaterThanToken);
-                                N(SyntaxKind.IdentifierName);
-                                {
-                                    N(SyntaxKind.IdentifierToken, "x");
-                                }
-                            }
-                        }
-                    }
-                }
-                N(SyntaxKind.SemicolonToken);
-            }
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments("=>", "=").WithLocation(1, 34));
+            EOF();
         }
 
         [Fact]
@@ -1714,110 +1474,20 @@ public void TestNullCheckedSyntaxCorrection7()
         public void TestNullCheckedSyntaxCorrection8()
         {
             UsingDeclaration("Func<string, string> func8 = x! !=> x;", options: TestOptions.RegularPreview,
-                    // (1,33): error CS1525: Invalid expression term '!'
+                    // (1,31): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func8 = x! !=> x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(1, 33));
-            N(SyntaxKind.FieldDeclaration);
-            {
-                N(SyntaxKind.VariableDeclaration);
-                {
-                    N(SyntaxKind.GenericName);
-                    {
-                        N(SyntaxKind.IdentifierToken, "Func");
-                        N(SyntaxKind.TypeArgumentList);
-                        {
-                            N(SyntaxKind.LessThanToken);
-                            N(SyntaxKind.PredefinedType);
-                            {
-                                N(SyntaxKind.StringKeyword);
-                            }
-                            N(SyntaxKind.CommaToken);
-                            N(SyntaxKind.PredefinedType);
-                            {
-                                N(SyntaxKind.StringKeyword);
-                            }
-                            N(SyntaxKind.GreaterThanToken);
-                        }
-                    }
-                    N(SyntaxKind.VariableDeclarator);
-                    {
-                        N(SyntaxKind.IdentifierToken, "func8");
-                        N(SyntaxKind.EqualsValueClause);
-                        {
-                            N(SyntaxKind.EqualsToken);
-                            N(SyntaxKind.SimpleLambdaExpression);
-                            {
-                                N(SyntaxKind.Parameter);
-                                {
-                                    N(SyntaxKind.IdentifierToken, "x");
-                                    M(SyntaxKind.ExclamationExclamationToken);
-                                }
-                                N(SyntaxKind.EqualsGreaterThanToken);
-                                N(SyntaxKind.IdentifierName);
-                                {
-                                    N(SyntaxKind.IdentifierToken, "x");
-                                }
-                            }
-                        }
-                    }
-                }
-                N(SyntaxKind.SemicolonToken);
-            }
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 31));
+            EOF();
         }
 
         [Fact]
         public void TestNullCheckedSyntaxCorrection9()
         {
             UsingDeclaration("Func<string, string> func9 = x! ! => x;", options: TestOptions.RegularPreview,
-                    // (1,33): error CS1525: Invalid expression term '!'
+                    // (1,31): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func9 = x! ! => x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(1, 33));
-            N(SyntaxKind.FieldDeclaration);
-            {
-                N(SyntaxKind.VariableDeclaration);
-                {
-                    N(SyntaxKind.GenericName);
-                    {
-                        N(SyntaxKind.IdentifierToken, "Func");
-                        N(SyntaxKind.TypeArgumentList);
-                        {
-                            N(SyntaxKind.LessThanToken);
-                            N(SyntaxKind.PredefinedType);
-                            {
-                                N(SyntaxKind.StringKeyword);
-                            }
-                            N(SyntaxKind.CommaToken);
-                            N(SyntaxKind.PredefinedType);
-                            {
-                                N(SyntaxKind.StringKeyword);
-                            }
-                            N(SyntaxKind.GreaterThanToken);
-                        }
-                    }
-                    N(SyntaxKind.VariableDeclarator);
-                    {
-                        N(SyntaxKind.IdentifierToken, "func9");
-                        N(SyntaxKind.EqualsValueClause);
-                        {
-                            N(SyntaxKind.EqualsToken);
-                            N(SyntaxKind.SimpleLambdaExpression);
-                            {
-                                N(SyntaxKind.Parameter);
-                                {
-                                    N(SyntaxKind.IdentifierToken, "x");
-                                    M(SyntaxKind.ExclamationExclamationToken);
-                                }
-                                N(SyntaxKind.EqualsGreaterThanToken);
-                                N(SyntaxKind.IdentifierName);
-                                {
-                                    N(SyntaxKind.IdentifierToken, "x");
-                                }
-                            }
-                        }
-                    }
-                }
-                N(SyntaxKind.SemicolonToken);
-            }
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "! ").WithArguments("!!", "!").WithLocation(1, 31));
+            EOF();
         }
 
         [Fact]
@@ -1986,21 +1656,30 @@ public void TestNullCheckedDefaultValueParenthesizedLamdaWithType2()
         [Fact]
         public void TestNullCheckedSpaceBetweenSimpleLambda()
         {
-            UsingDeclaration("Func<string, string> func0 = x! ! => x;", options: TestOptions.RegularPreview);
+            UsingDeclaration("Func<string, string> func0 = x! ! => x;", options: TestOptions.RegularPreview,
+                    // (1,31): error CS1003: Syntax error, '!!' expected
+                    // Func<string, string> func0 = x! ! => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "! ").WithArguments("!!", "!").WithLocation(1, 31));
             EOF();
         }
 
         [Fact]
         public void TestNullCheckedSpaceBetweenParenthesizedLamda1()
         {
-            UsingDeclaration("Func<string, string> func0 = (x! !) => x;", options: TestOptions.RegularPreview);
+            UsingDeclaration("Func<string, string> func0 = (x! !) => x;", options: TestOptions.RegularPreview,
+                    // (1,32): error CS1003: Syntax error, '!!' expected
+                    // Func<string, string> func0 = (x! !) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 32));
             EOF();
         }
 
         [Fact]
         public void TestNullCheckedSpaceBetweenParenthesizedLamda2()
         {
-            UsingDeclaration("Func<string, string> func0 = (y, x! !) => x;", options: TestOptions.RegularPreview);
+            UsingDeclaration("Func<string, string> func0 = (y, x! !) => x;", options: TestOptions.RegularPreview,
+                    // (1,35): error CS1003: Syntax error, '!!' expected
+                    // Func<string, string> func0 = (y, x! !) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 35));
             EOF();
         }
 
@@ -2008,22 +1687,19 @@ public void TestNullCheckedSpaceBetweenParenthesizedLamda2()
         public void TestNullCheckedSpaceBetweenLamdaWithType1()
         {
             UsingDeclaration("Func<string, string> func0 = (string x! !) => x;", options: TestOptions.RegularPreview,
-                    // (1,31): error CS1525: Invalid expression term 'string'
-                    // Func<string, string> func0 = (string x! !) => x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "string").WithArguments("string").WithLocation(1, 31),
-                    // (1,38): error CS1026: ) expected
+                    // (1,39): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func0 = (string x! !) => x;
-                    Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 38),
-                    // (1,38): error CS1003: Syntax error, ',' expected
-                    // Func<string, string> func0 = (string x! !) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 38));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 39));
             EOF();
         }
 
         [Fact]
         public void TestNullCheckedSpaceBetweenLamdaWithType2()
         {
-            UsingDeclaration("Func<string, string> func0 = (string y, string x! !) => x;", options: TestOptions.RegularPreview);
+            UsingDeclaration("Func<string, string> func0 = (string y, string x! !) => x;", options: TestOptions.RegularPreview,
+                    // (1,49): error CS1003: Syntax error, '!!' expected
+                    // Func<string, string> func0 = (string y, string x! !) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 49));
             EOF();
         }
 

From 7eabbf583d376ccd32932bb8b876e6740f064ade Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Wed, 5 Jan 2022 15:25:29 -0800
Subject: [PATCH 241/444] Add tests

---
 .../CSharp/Portable/Parser/LanguageParser.cs  |   36 +-
 .../Syntax/Parsing/DeclarationParsingTests.cs |   70 +-
 .../Parsing/LambdaParameterParsingTests.cs    | 1378 ++++++++++++++++-
 3 files changed, 1391 insertions(+), 93 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
index 6a9da5d306365..20bd7ea92f299 100644
--- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
+++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
@@ -4401,7 +4401,15 @@ private ParameterSyntax ParseParameter()
                     identifier = this.ParseIdentifierToken();
                 }
 
-                ParseParameterRest(ref identifier, out var exclamationExclamationToken, out var equalsToken);
+                // When the user type "int goo[]", give them a useful error
+                if (this.CurrentToken.Kind is SyntaxKind.OpenBracketToken && this.PeekToken(1).Kind is SyntaxKind.CloseBracketToken)
+                {
+                    identifier = AddTrailingSkippedSyntax(identifier, SyntaxList.List(
+                        this.AddError(this.EatToken(), ErrorCode.ERR_BadArraySyntax),
+                        this.EatToken()));
+                }
+
+                ParseParameterNullCheck(out var exclamationExclamationToken, out var equalsToken);
 
                 // If we didn't already consume an equals sign as part of !!=, then try to scan one out now.
                 equalsToken ??= TryEatToken(SyntaxKind.EqualsToken);
@@ -4421,26 +4429,17 @@ private ParameterSyntax ParseParameter()
 #nullable enable
 
         /// <summary>
-        /// Parses out the remainder of a parameter once the type and identifier of it has been parsed out already.  If
-        /// the token is followed by <c>!!=</c> or <c>! !=</c>, then the final equals will be returned out through
-        /// <paramref name="equalsToken"/>.
+        /// Parses out the <c>!!</c> following once the type and identifier has been parsed out already.  If the token
+        /// is followed by <c>!!=</c> or <c>! !=</c>, then the final equals will be returned out through <paramref
+        /// name="equalsToken"/>.
         /// </summary>
-        private void ParseParameterRest(
-            ref SyntaxToken identifier,
+        private void ParseParameterNullCheck(
             out SyntaxToken? exclamationExclamationToken,
             out SyntaxToken? equalsToken)
         {
             exclamationExclamationToken = null;
             equalsToken = null;
 
-            // When the user type "int goo[]", give them a useful error
-            if (this.CurrentToken.Kind is SyntaxKind.OpenBracketToken && this.PeekToken(1).Kind is SyntaxKind.CloseBracketToken)
-            {
-                identifier = AddTrailingSkippedSyntax(identifier, SyntaxList.List(
-                    this.AddError(this.EatToken(), ErrorCode.ERR_BadArraySyntax),
-                    this.EatToken()));
-            }
-
             if (this.CurrentToken.Kind is SyntaxKind.ExclamationEqualsToken)
             {
                 // split != into two tokens.
@@ -4454,8 +4453,7 @@ private void ParseParameterRest(
                 // Return the split out `=` for the consumer to handle.
                 equalsToken = SyntaxFactory.Token(leading: null, SyntaxKind.EqualsToken, exclamationEquals.GetTrailingTrivia());
             }
-
-            if (this.CurrentToken.Kind is SyntaxKind.ExclamationToken)
+            else if (this.CurrentToken.Kind is SyntaxKind.ExclamationToken)
             {
                 // We have seen at least !
                 //
@@ -4486,7 +4484,7 @@ private void ParseParameterRest(
                 {
                     // Report that the ! should have been !!
                     exclamationExclamationToken = WithAdditionalDiagnostics(
-                        SyntaxFactory.Token(firstExclamation.GetLeadingTrivia(), SyntaxKind.ExclamationExclamationToken, "!", "!", trailing: firstExclamation.GetTrailingTrivia())
+                        SyntaxFactory.Token(firstExclamation.GetLeadingTrivia(), SyntaxKind.ExclamationExclamationToken, "!", "!", trailing: firstExclamation.GetTrailingTrivia()),
                         this.GetExpectedTokenError(expected: SyntaxKind.ExclamationExclamationToken, actual: firstExclamation.Kind));
                 }
             }
@@ -12966,7 +12964,7 @@ LambdaExpressionSyntax parseLambdaExpressionWorker()
                 {
                     var identifier = this.ParseIdentifierToken();
 
-                    ParseParameterRest(ref identifier, out var exclamationExclamationToken, out var equalsToken);
+                    ParseParameterNullCheck(out var exclamationExclamationToken, out var equalsToken);
 
                     SyntaxToken arrow;
                     if (equalsToken != null)
@@ -13112,7 +13110,7 @@ private ParameterSyntax ParseLambdaParameter()
             }
 
             var identifier = this.ParseIdentifierToken();
-            ParseParameterRest(ref identifier, out var exclamationExclamationToken, out var equalsToken);
+            ParseParameterNullCheck(out var exclamationExclamationToken, out var equalsToken);
 
             // This should never be non-null.  That indicates while we were scanning for potential lambdas, we saw an
             // `!!=` or `!=` sign in the parameter list and allowed it. However, that should never happen as
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs
index be3b1b5f4e127..4c59496b30fef 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs
@@ -7276,9 +7276,9 @@ public void TestMethodDeclarationNullValidation()
         public void TestMethodDeclarationNullValidation_SingleExclamation()
         {
             UsingStatement(@"void M(string name!) { }", options: TestOptions.RegularPreview,
-                // (1,20): error CS1003: Syntax error, '!' expected
-                // void M(string name!) { }
-                Diagnostic(ErrorCode.ERR_SyntaxError, ")").WithArguments("!", ")").WithLocation(1, 20));
+                    // (1,19): error CS1003: Syntax error, '!!' expected
+                    // void M(string name!) { }
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 19));
 
             N(SyntaxKind.LocalFunctionStatement);
             {
@@ -7297,7 +7297,7 @@ public void TestMethodDeclarationNullValidation_SingleExclamation()
                             N(SyntaxKind.StringKeyword);
                         }
                         N(SyntaxKind.IdentifierToken, "name");
-                        M(SyntaxKind.ExclamationExclamationToken);
+                        N(SyntaxKind.ExclamationExclamationToken);
                     }
                     N(SyntaxKind.CloseParenToken);
                 }
@@ -7396,9 +7396,9 @@ public void TestOptParamMethodDeclarationWithNullValidationNoSpaces()
         public void TestNullCheckedArgList()
         {
             UsingStatement(@"void M(__arglist!) { }", options: TestOptions.RegularPreview,
-                    // (1,17): error CS1003: Syntax error, ',' expected
+                    // (1,17): error CS1003: Syntax error, '!!' expected
                     // void M(__arglist!) { }
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments(",", "!").WithLocation(1, 17));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 17));
             N(SyntaxKind.LocalFunctionStatement);
             {
                 N(SyntaxKind.PredefinedType);
@@ -7412,6 +7412,7 @@ public void TestNullCheckedArgList()
                     N(SyntaxKind.Parameter);
                     {
                         N(SyntaxKind.ArgListKeyword);
+                        N(SyntaxKind.ExclamationExclamationToken);
                     }
                     N(SyntaxKind.CloseParenToken);
                 }
@@ -7421,8 +7422,44 @@ public void TestNullCheckedArgList()
                     N(SyntaxKind.CloseBraceToken);
                 }
             }
+            EOF();
         }
 
+        [Fact]
+        public void TestArgListWithDefaultValue()
+        {
+            UsingStatement(@"void M(__arglist = null) { }", options: TestOptions.RegularPreview); N(SyntaxKind.LocalFunctionStatement);
+            {
+                N(SyntaxKind.PredefinedType);
+                {
+                    N(SyntaxKind.VoidKeyword);
+                }
+                N(SyntaxKind.IdentifierToken, "M");
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.ArgListKeyword);
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.NullLiteralExpression);
+                            {
+                                N(SyntaxKind.NullKeyword);
+                            }
+                        }
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
 
         [Fact]
         public void TestNullCheckedArgWithLeadingSpace()
@@ -7592,9 +7629,9 @@ public void TestNullCheckedArgWithTrailingNewLine()
         public void TestNullCheckedArgWithSpaceInbetween()
         {
             UsingStatement(@"void M(string name! !=null) { }", options: TestOptions.RegularPreview,
-                    // (1,21): error CS1525: Invalid expression term '!'
+                    // (1,19): error CS1003: Syntax error, '!!' expected
                     // void M(string name! !=null) { }
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(1, 21));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "! !=").WithArguments("!!", "!").WithLocation(1, 19));
             N(SyntaxKind.LocalFunctionStatement);
             {
                 N(SyntaxKind.PredefinedType);
@@ -7612,7 +7649,7 @@ public void TestNullCheckedArgWithSpaceInbetween()
                             N(SyntaxKind.StringKeyword);
                         }
                         N(SyntaxKind.IdentifierToken, "name");
-                        M(SyntaxKind.ExclamationExclamationToken);
+                        N(SyntaxKind.ExclamationExclamationToken);
                         N(SyntaxKind.EqualsValueClause);
                         {
                             N(SyntaxKind.EqualsToken);
@@ -7630,6 +7667,7 @@ public void TestNullCheckedArgWithSpaceInbetween()
                     N(SyntaxKind.CloseBraceToken);
                 }
             }
+            EOF();
         }
 
         [Fact]
@@ -7677,9 +7715,9 @@ public void TestNullCheckedArgWithSpaceAfterParam()
         public void TestNullCheckedArgWithSpaceAfterBangs()
         {
             UsingStatement(@"void M(string name! ! =null) { }", options: TestOptions.RegularPreview,
-                    // (1,21): error CS1525: Invalid expression term '!'
+                    // (1,19): error CS1003: Syntax error, '!!' expected
                     // void M(string name! ! =null) { }
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(1, 21));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 19));
             N(SyntaxKind.LocalFunctionStatement);
             {
                 N(SyntaxKind.PredefinedType);
@@ -7697,7 +7735,7 @@ public void TestNullCheckedArgWithSpaceAfterBangs()
                             N(SyntaxKind.StringKeyword);
                         }
                         N(SyntaxKind.IdentifierToken, "name");
-                        M(SyntaxKind.ExclamationExclamationToken);
+                        N(SyntaxKind.ExclamationExclamationToken);
                         N(SyntaxKind.EqualsValueClause);
                         {
                             N(SyntaxKind.EqualsToken);
@@ -7715,15 +7753,16 @@ public void TestNullCheckedArgWithSpaceAfterBangs()
                     N(SyntaxKind.CloseBraceToken);
                 }
             }
+            EOF();
         }
 
         [Fact]
         public void TestNullCheckedArgWithSpaceBeforeBangs()
         {
             UsingStatement(@"void M(string name ! !=null) { }", options: TestOptions.RegularPreview,
-                    // (1,22): error CS1525: Invalid expression term '!'
+                    // (1,20): error CS1003: Syntax error, '!!' expected
                     // void M(string name ! !=null) { }
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(1, 22));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "! !=").WithArguments("!!", "!").WithLocation(1, 20));
             N(SyntaxKind.LocalFunctionStatement);
             {
                 N(SyntaxKind.PredefinedType);
@@ -7741,7 +7780,7 @@ public void TestNullCheckedArgWithSpaceBeforeBangs()
                             N(SyntaxKind.StringKeyword);
                         }
                         N(SyntaxKind.IdentifierToken, "name");
-                        M(SyntaxKind.ExclamationExclamationToken);
+                        N(SyntaxKind.ExclamationExclamationToken);
                         N(SyntaxKind.EqualsValueClause);
                         {
                             N(SyntaxKind.EqualsToken);
@@ -7759,6 +7798,7 @@ public void TestNullCheckedArgWithSpaceBeforeBangs()
                     N(SyntaxKind.CloseBraceToken);
                 }
             }
+            EOF();
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
index 63f3e200718c7..b9f8e62bf20a2 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
@@ -1229,7 +1229,52 @@ public void TestNullCheckedSyntaxCorrection0()
             UsingDeclaration("Func<string, string> func0 = x!=> x;", options: TestOptions.RegularPreview,
                     // (1,31): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func0 = x!=> x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 31));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 31)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.SimpleLambdaExpression);
+                            {
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                    N(SyntaxKind.ExclamationExclamationToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
             EOF();
         }
 
@@ -1239,7 +1284,52 @@ public void TestNullCheckedSyntaxCorrection1()
             UsingDeclaration("Func<string, string> func1 = x !=> x;", options: TestOptions.RegularPreview,
                     // (1,32): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func1 = x !=> x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 32));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 32)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func1");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.SimpleLambdaExpression);
+                            {
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                    N(SyntaxKind.ExclamationExclamationToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
             EOF();
         }
 
@@ -1252,7 +1342,52 @@ public void TestNullCheckedSyntaxCorrection2()
                     Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 32),
                     // (1,33): error CS1003: Syntax error, '=>' expected
                     // Func<string, string> func2 = x != > x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments("=>", "=").WithLocation(1, 33));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments("=>", "=").WithLocation(1, 33)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func2");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.SimpleLambdaExpression);
+                            {
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                    N(SyntaxKind.ExclamationExclamationToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
             EOF();
         }
 
@@ -1414,7 +1549,52 @@ public void TestNullCheckedSyntaxCorrection6()
             UsingDeclaration("Func<string, string> func6 = x !!= > x;", options: TestOptions.RegularPreview,
                     // (1,34): error CS1003: Syntax error, '=>' expected
                     // Func<string, string> func6 = x !!= > x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments("=>", "=").WithLocation(1, 34));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments("=>", "=").WithLocation(1, 34)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func6");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.SimpleLambdaExpression);
+                            {
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                    N(SyntaxKind.ExclamationExclamationToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
             EOF();
         }
 
@@ -1476,7 +1656,52 @@ public void TestNullCheckedSyntaxCorrection8()
             UsingDeclaration("Func<string, string> func8 = x! !=> x;", options: TestOptions.RegularPreview,
                     // (1,31): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func8 = x! !=> x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 31));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 31)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func8");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.SimpleLambdaExpression);
+                            {
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                    N(SyntaxKind.ExclamationExclamationToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
             EOF();
         }
 
@@ -1486,46 +1711,284 @@ public void TestNullCheckedSyntaxCorrection9()
             UsingDeclaration("Func<string, string> func9 = x! ! => x;", options: TestOptions.RegularPreview,
                     // (1,31): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func9 = x! ! => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "! ").WithArguments("!!", "!").WithLocation(1, 31));
-            EOF();
-        }
-
-        [Fact]
-        public void TestBracesAfterSimpleLambdaName()
-        {
-            UsingDeclaration("Func<string[], string> func0 = x[] => x;", options: TestOptions.RegularPreview,
-                    // (1,34): error CS0443: Syntax error; value expected
-                    // Func<string[], string> func0 = x[] => x;
-                    Diagnostic(ErrorCode.ERR_ValueExpected, "]").WithLocation(1, 34),
-                    // (1,36): error CS1003: Syntax error, ',' expected
-                    // Func<string[], string> func0 = x[] => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 36));
-            EOF();
-        }
-
-        [Fact]
-        public void TestBracesAfterParenthesizedLambdaName()
-        {
-            UsingDeclaration("Func<string[], string> func0 = (x[]) => x;", options: TestOptions.RegularPreview,
-                    // (1,36): error CS1001: Identifier expected
-                    // Func<string[], string> func0 = (x[]) => x;
-                    Diagnostic(ErrorCode.ERR_IdentifierExpected, ")").WithLocation(1, 36));
-            EOF();
-        }
-
-        [Fact]
-        public void TestBracesAfterParenthesizedLambdaTypeAndName()
-        {
-            UsingDeclaration("Func<string[], string> func0 = (string x[]) => x;", options: TestOptions.RegularPreview,
-                    // (1,33): error CS1525: Invalid expression term 'string'
-                    // Func<string[], string> func0 = (string x[]) => x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "string").WithArguments("string").WithLocation(1, 33),
-                    // (1,40): error CS1026: ) expected
-                    // Func<string[], string> func0 = (string x[]) => x;
-                    Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 40),
-                    // (1,40): error CS1003: Syntax error, ',' expected
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "! ").WithArguments("!!", "!").WithLocation(1, 31)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func9");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.SimpleLambdaExpression);
+                            {
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                    N(SyntaxKind.ExclamationExclamationToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestBracesAfterSimpleLambdaName()
+        {
+            UsingDeclaration("Func<string[], string> func0 = x[] => x;", options: TestOptions.RegularPreview,
+                    // (1,34): error CS0443: Syntax error; value expected
+                    // Func<string[], string> func0 = x[] => x;
+                    Diagnostic(ErrorCode.ERR_ValueExpected, "]").WithLocation(1, 34),
+                    // (1,36): error CS1003: Syntax error, ',' expected
+                    // Func<string[], string> func0 = x[] => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 36)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.ArrayType);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.StringKeyword);
+                                }
+                                N(SyntaxKind.ArrayRankSpecifier);
+                                {
+                                    N(SyntaxKind.OpenBracketToken);
+                                    N(SyntaxKind.OmittedArraySizeExpression);
+                                    {
+                                        N(SyntaxKind.OmittedArraySizeExpressionToken);
+                                    }
+                                    N(SyntaxKind.CloseBracketToken);
+                                }
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.ElementAccessExpression);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                                N(SyntaxKind.BracketedArgumentList);
+                                {
+                                    N(SyntaxKind.OpenBracketToken);
+                                    M(SyntaxKind.Argument);
+                                    {
+                                        M(SyntaxKind.IdentifierName);
+                                        {
+                                            M(SyntaxKind.IdentifierToken);
+                                        }
+                                    }
+                                    N(SyntaxKind.CloseBracketToken);
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestBracesAfterParenthesizedLambdaName()
+        {
+            UsingDeclaration("Func<string[], string> func0 = (x[]) => x;", options: TestOptions.RegularPreview,
+                    // (1,36): error CS1001: Identifier expected
+                    // Func<string[], string> func0 = (x[]) => x;
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, ")").WithLocation(1, 36)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.ArrayType);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.StringKeyword);
+                                }
+                                N(SyntaxKind.ArrayRankSpecifier);
+                                {
+                                    N(SyntaxKind.OpenBracketToken);
+                                    N(SyntaxKind.OmittedArraySizeExpression);
+                                    {
+                                        N(SyntaxKind.OmittedArraySizeExpressionToken);
+                                    }
+                                    N(SyntaxKind.CloseBracketToken);
+                                }
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.ParenthesizedLambdaExpression);
+                            {
+                                N(SyntaxKind.ParameterList);
+                                {
+                                    N(SyntaxKind.OpenParenToken);
+                                    N(SyntaxKind.Parameter);
+                                    {
+                                        N(SyntaxKind.ArrayType);
+                                        {
+                                            N(SyntaxKind.IdentifierName);
+                                            {
+                                                N(SyntaxKind.IdentifierToken, "x");
+                                            }
+                                            N(SyntaxKind.ArrayRankSpecifier);
+                                            {
+                                                N(SyntaxKind.OpenBracketToken);
+                                                N(SyntaxKind.OmittedArraySizeExpression);
+                                                {
+                                                    N(SyntaxKind.OmittedArraySizeExpressionToken);
+                                                }
+                                                N(SyntaxKind.CloseBracketToken);
+                                            }
+                                        }
+                                        M(SyntaxKind.IdentifierToken);
+                                    }
+                                    N(SyntaxKind.CloseParenToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestBracesAfterParenthesizedLambdaTypeAndName()
+        {
+            UsingDeclaration("Func<string[], string> func0 = (string x[]) => x;", options: TestOptions.RegularPreview,
+                    // (1,33): error CS1525: Invalid expression term 'string'
+                    // Func<string[], string> func0 = (string x[]) => x;
+                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "string").WithArguments("string").WithLocation(1, 33),
+                    // (1,40): error CS1026: ) expected
+                    // Func<string[], string> func0 = (string x[]) => x;
+                    Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 40),
+                    // (1,40): error CS1003: Syntax error, ',' expected
                     // Func<string[], string> func0 = (string x[]) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 40));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 40)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.ArrayType);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.StringKeyword);
+                                }
+                                N(SyntaxKind.ArrayRankSpecifier);
+                                {
+                                    N(SyntaxKind.OpenBracketToken);
+                                    N(SyntaxKind.OmittedArraySizeExpression);
+                                    {
+                                        N(SyntaxKind.OmittedArraySizeExpressionToken);
+                                    }
+                                    N(SyntaxKind.CloseBracketToken);
+                                }
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.ParenthesizedExpression);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.StringKeyword);
+                                }
+                                M(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
             EOF();
         }
 
@@ -1535,7 +1998,51 @@ public void TestDefaultValueSimpleLambda()
             UsingDeclaration("Func<string, string> func0 = x = null => x;", options: TestOptions.RegularPreview,
                     // (1,39): error CS1003: Syntax error, ',' expected
                     // Func<string, string> func0 = x = null => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 39));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 39)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.SimpleAssignmentExpression);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                                N(SyntaxKind.EqualsToken);
+                                N(SyntaxKind.NullLiteralExpression);
+                                {
+                                    N(SyntaxKind.NullKeyword);
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
             EOF();
         }
 
@@ -1545,7 +2052,56 @@ public void TestDefaultValueParenthesizedLamda1()
             UsingDeclaration("Func<string, string> func0 = (x = null) => x;", options: TestOptions.RegularPreview,
                     // (1,41): error CS1003: Syntax error, ',' expected
                     // Func<string, string> func0 = (x = null) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 41));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 41)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.ParenthesizedExpression);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.SimpleAssignmentExpression);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "x");
+                                    }
+                                    N(SyntaxKind.EqualsToken);
+                                    N(SyntaxKind.NullLiteralExpression);
+                                    {
+                                        N(SyntaxKind.NullKeyword);
+                                    }
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
             EOF();
         }
 
@@ -1555,7 +2111,67 @@ public void TestDefaultValueParenthesizedLamda2()
             UsingDeclaration("Func<string, string> func0 = (y, x = null) => x;", options: TestOptions.RegularPreview,
                     // (1,44): error CS1003: Syntax error, ',' expected
                     // Func<string, string> func0 = (y, x = null) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 44));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 44)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.TupleExpression);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.Argument);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "y");
+                                    }
+                                }
+                                N(SyntaxKind.CommaToken);
+                                N(SyntaxKind.Argument);
+                                {
+                                    N(SyntaxKind.SimpleAssignmentExpression);
+                                    {
+                                        N(SyntaxKind.IdentifierName);
+                                        {
+                                            N(SyntaxKind.IdentifierToken, "x");
+                                        }
+                                        N(SyntaxKind.EqualsToken);
+                                        N(SyntaxKind.NullLiteralExpression);
+                                        {
+                                            N(SyntaxKind.NullKeyword);
+                                        }
+                                    }
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
             EOF();
         }
 
@@ -1571,7 +2187,48 @@ public void TestDefaultValueParenthesizedLamdaWithType1()
                     Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 38),
                     // (1,38): error CS1003: Syntax error, ',' expected
                     // Func<string, string> func0 = (string x = null) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 38));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 38)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.ParenthesizedExpression);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.StringKeyword);
+                                }
+                                M(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
             EOF();
         }
 
@@ -1587,7 +2244,66 @@ public void TestDefaultValueParenthesizedLamdaWithType2()
                     Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 48),
                     // (1,48): error CS1003: Syntax error, ',' expected
                     // Func<string, string> func0 = (string y, string x = null) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 48));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 48)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.TupleExpression);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.Argument);
+                                {
+                                    N(SyntaxKind.DeclarationExpression);
+                                    {
+                                        N(SyntaxKind.PredefinedType);
+                                        {
+                                            N(SyntaxKind.StringKeyword);
+                                        }
+                                        N(SyntaxKind.SingleVariableDesignation);
+                                        {
+                                            N(SyntaxKind.IdentifierToken, "y");
+                                        }
+                                    }
+                                }
+                                N(SyntaxKind.CommaToken);
+                                N(SyntaxKind.Argument);
+                                {
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.StringKeyword);
+                                    }
+                                }
+                                M(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
             EOF();
         }
 
@@ -1597,7 +2313,59 @@ public void TestNullCheckedDefaultValueSimpleLambda()
             UsingDeclaration("Func<string, string> func0 = x!! = null => x;", options: TestOptions.RegularPreview,
                     // (1,41): error CS1003: Syntax error, ',' expected
                     // Func<string, string> func0 = x!! = null => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 41));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 41)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.SimpleAssignmentExpression);
+                            {
+                                N(SyntaxKind.SuppressNullableWarningExpression);
+                                {
+                                    N(SyntaxKind.SuppressNullableWarningExpression);
+                                    {
+                                        N(SyntaxKind.IdentifierName);
+                                        {
+                                            N(SyntaxKind.IdentifierToken, "x");
+                                        }
+                                        N(SyntaxKind.ExclamationToken);
+                                    }
+                                    N(SyntaxKind.ExclamationToken);
+                                }
+                                N(SyntaxKind.EqualsToken);
+                                N(SyntaxKind.NullLiteralExpression);
+                                {
+                                    N(SyntaxKind.NullKeyword);
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
             EOF();
         }
 
@@ -1607,7 +2375,64 @@ public void TestNullCheckedDefaultValueParenthesizedLamda1()
             UsingDeclaration("Func<string, string> func0 = (x!! = null) => x;", options: TestOptions.RegularPreview,
                     // (1,43): error CS1003: Syntax error, ',' expected
                     // Func<string, string> func0 = (x!! = null) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 43));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 43)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.ParenthesizedExpression);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.SimpleAssignmentExpression);
+                                {
+                                    N(SyntaxKind.SuppressNullableWarningExpression);
+                                    {
+                                        N(SyntaxKind.SuppressNullableWarningExpression);
+                                        {
+                                            N(SyntaxKind.IdentifierName);
+                                            {
+                                                N(SyntaxKind.IdentifierToken, "x");
+                                            }
+                                            N(SyntaxKind.ExclamationToken);
+                                        }
+                                        N(SyntaxKind.ExclamationToken);
+                                    }
+                                    N(SyntaxKind.EqualsToken);
+                                    N(SyntaxKind.NullLiteralExpression);
+                                    {
+                                        N(SyntaxKind.NullKeyword);
+                                    }
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
             EOF();
         }
 
@@ -1617,7 +2442,75 @@ public void TestNullCheckedDefaultValueParenthesizedLamda2()
             UsingDeclaration("Func<string, string> func0 = (y, x!! = null) => x;", options: TestOptions.RegularPreview,
                     // (1,46): error CS1003: Syntax error, ',' expected
                     // Func<string, string> func0 = (y, x!! = null) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 46));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 46)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.TupleExpression);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.Argument);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "y");
+                                    }
+                                }
+                                N(SyntaxKind.CommaToken);
+                                N(SyntaxKind.Argument);
+                                {
+                                    N(SyntaxKind.SimpleAssignmentExpression);
+                                    {
+                                        N(SyntaxKind.SuppressNullableWarningExpression);
+                                        {
+                                            N(SyntaxKind.SuppressNullableWarningExpression);
+                                            {
+                                                N(SyntaxKind.IdentifierName);
+                                                {
+                                                    N(SyntaxKind.IdentifierToken, "x");
+                                                }
+                                                N(SyntaxKind.ExclamationToken);
+                                            }
+                                            N(SyntaxKind.ExclamationToken);
+                                        }
+                                        N(SyntaxKind.EqualsToken);
+                                        N(SyntaxKind.NullLiteralExpression);
+                                        {
+                                            N(SyntaxKind.NullKeyword);
+                                        }
+                                    }
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
             EOF();
         }
 
@@ -1633,7 +2526,48 @@ public void TestNullCheckedDefaultValueParenthesizedLamdaWithType1()
                     Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 38),
                     // (1,38): error CS1003: Syntax error, ',' expected
                     // Func<string, string> func0 = (string x!! = null) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 38));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 38)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.ParenthesizedExpression);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.StringKeyword);
+                                }
+                                M(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
             EOF();
         }
 
@@ -1649,7 +2583,66 @@ public void TestNullCheckedDefaultValueParenthesizedLamdaWithType2()
                 Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 48),
                 // (1,48): error CS1003: Syntax error, ',' expected
                 // Func<string, string> func0 = (string y, string x!! = null) => x;
-                Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 48));
+                Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 48)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.TupleExpression);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.Argument);
+                                {
+                                    N(SyntaxKind.DeclarationExpression);
+                                    {
+                                        N(SyntaxKind.PredefinedType);
+                                        {
+                                            N(SyntaxKind.StringKeyword);
+                                        }
+                                        N(SyntaxKind.SingleVariableDesignation);
+                                        {
+                                            N(SyntaxKind.IdentifierToken, "y");
+                                        }
+                                    }
+                                }
+                                N(SyntaxKind.CommaToken);
+                                N(SyntaxKind.Argument);
+                                {
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.StringKeyword);
+                                    }
+                                }
+                                M(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
             EOF();
         }
 
@@ -1659,7 +2652,52 @@ public void TestNullCheckedSpaceBetweenSimpleLambda()
             UsingDeclaration("Func<string, string> func0 = x! ! => x;", options: TestOptions.RegularPreview,
                     // (1,31): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func0 = x! ! => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "! ").WithArguments("!!", "!").WithLocation(1, 31));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "! ").WithArguments("!!", "!").WithLocation(1, 31)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.SimpleLambdaExpression);
+                            {
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                    N(SyntaxKind.ExclamationExclamationToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
             EOF();
         }
 
@@ -1669,7 +2707,57 @@ public void TestNullCheckedSpaceBetweenParenthesizedLamda1()
             UsingDeclaration("Func<string, string> func0 = (x! !) => x;", options: TestOptions.RegularPreview,
                     // (1,32): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func0 = (x! !) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 32));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 32)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.ParenthesizedLambdaExpression);
+                            {
+                                N(SyntaxKind.ParameterList);
+                                {
+                                    N(SyntaxKind.OpenParenToken);
+                                    N(SyntaxKind.Parameter);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "x");
+                                        N(SyntaxKind.ExclamationExclamationToken);
+                                    }
+                                    N(SyntaxKind.CloseParenToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
             EOF();
         }
 
@@ -1679,7 +2767,62 @@ public void TestNullCheckedSpaceBetweenParenthesizedLamda2()
             UsingDeclaration("Func<string, string> func0 = (y, x! !) => x;", options: TestOptions.RegularPreview,
                     // (1,35): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func0 = (y, x! !) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 35));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 35)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.ParenthesizedLambdaExpression);
+                            {
+                                N(SyntaxKind.ParameterList);
+                                {
+                                    N(SyntaxKind.OpenParenToken);
+                                    N(SyntaxKind.Parameter);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "y");
+                                    }
+                                    N(SyntaxKind.CommaToken);
+                                    N(SyntaxKind.Parameter);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "x");
+                                        N(SyntaxKind.ExclamationExclamationToken);
+                                    }
+                                    N(SyntaxKind.CloseParenToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
             EOF();
         }
 
@@ -1689,7 +2832,61 @@ public void TestNullCheckedSpaceBetweenLamdaWithType1()
             UsingDeclaration("Func<string, string> func0 = (string x! !) => x;", options: TestOptions.RegularPreview,
                     // (1,39): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func0 = (string x! !) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 39));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 39)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.ParenthesizedLambdaExpression);
+                            {
+                                N(SyntaxKind.ParameterList);
+                                {
+                                    N(SyntaxKind.OpenParenToken);
+                                    N(SyntaxKind.Parameter);
+                                    {
+                                        N(SyntaxKind.PredefinedType);
+                                        {
+                                            N(SyntaxKind.StringKeyword);
+                                        }
+                                        N(SyntaxKind.IdentifierToken, "x");
+                                        N(SyntaxKind.ExclamationExclamationToken);
+                                    }
+                                    N(SyntaxKind.CloseParenToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
             EOF();
         }
 
@@ -1699,7 +2896,70 @@ public void TestNullCheckedSpaceBetweenLamdaWithType2()
             UsingDeclaration("Func<string, string> func0 = (string y, string x! !) => x;", options: TestOptions.RegularPreview,
                     // (1,49): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func0 = (string y, string x! !) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 49));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 49)); N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.ParenthesizedLambdaExpression);
+                            {
+                                N(SyntaxKind.ParameterList);
+                                {
+                                    N(SyntaxKind.OpenParenToken);
+                                    N(SyntaxKind.Parameter);
+                                    {
+                                        N(SyntaxKind.PredefinedType);
+                                        {
+                                            N(SyntaxKind.StringKeyword);
+                                        }
+                                        N(SyntaxKind.IdentifierToken, "y");
+                                    }
+                                    N(SyntaxKind.CommaToken);
+                                    N(SyntaxKind.Parameter);
+                                    {
+                                        N(SyntaxKind.PredefinedType);
+                                        {
+                                            N(SyntaxKind.StringKeyword);
+                                        }
+                                        N(SyntaxKind.IdentifierToken, "x");
+                                        N(SyntaxKind.ExclamationExclamationToken);
+                                    }
+                                    N(SyntaxKind.CloseParenToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
             EOF();
         }
 

From f5e3bd547924ead02e2b5d9716e04521550eda82 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Wed, 5 Jan 2022 15:27:48 -0800
Subject: [PATCH 242/444] Add comment

---
 src/Compilers/CSharp/Portable/Parser/LanguageParser.cs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
index 20bd7ea92f299..3b13e7d566d86 100644
--- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
+++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
@@ -4493,6 +4493,12 @@ private void ParseParameterNullCheck(
                 exclamationExclamationToken = CheckFeatureAvailability(exclamationExclamationToken, MessageID.IDS_ParameterNullChecking);
         }
 
+        /// <summary>
+        /// Merges two successive tokens into a single token with the given <paramref name="kind"/>.  If the two tokens
+        /// have no trivia between them, then the final token will be trivially generated, properly passing on the right
+        /// leading/trailing trivia.  However, if there is trivia between the tokens, then appropriate errors will be
+        /// reported that the tokens cannot merge successfully.
+        /// </summary>
         private SyntaxToken? MergeAdjacent(SyntaxToken t1, SyntaxToken t2, SyntaxKind kind)
         {
             if (t1.GetTrailingTriviaWidth() == 0 && t2.GetLeadingTriviaWidth() == 0)

From 47e7eff0883138b3cc1095c824888592e896bfb0 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Wed, 5 Jan 2022 15:32:52 -0800
Subject: [PATCH 243/444] Simplify

---
 .../CSharp/Portable/Parser/LanguageParser.cs  | 30 ++++++++-----------
 1 file changed, 13 insertions(+), 17 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
index 3b13e7d566d86..90c6a2701a09b 100644
--- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
+++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
@@ -4460,25 +4460,21 @@ private void ParseParameterNullCheck(
                 // We can potentially merge that with an immediately following !! or an immediately following !=
                 // All other cases are in error.
                 var firstExclamation = this.EatToken();
-                if (this.CurrentToken.Kind is SyntaxKind.ExclamationToken or SyntaxKind.ExclamationEqualsToken)
+                if (this.CurrentToken.Kind is SyntaxKind.ExclamationToken)
                 {
-                    if (this.CurrentToken.Kind is SyntaxKind.ExclamationToken)
-                    {
-                        // have two !'s in a row.  Merge them (reporting any errors if they cannot merge properly).
-                        exclamationExclamationToken = MergeAdjacent(firstExclamation, this.EatToken(), SyntaxKind.ExclamationExclamationToken);
-                    }
-                    else
-                    {
-                        Debug.Assert(this.CurrentToken.Kind == SyntaxKind.ExclamationEqualsToken);
-                        // split != into two tokens.
-                        var exclamationEquals = this.EatToken();
+                    // have two !'s in a row.  Merge them (reporting any errors if they cannot merge properly).
+                    exclamationExclamationToken = MergeAdjacent(firstExclamation, this.EatToken(), SyntaxKind.ExclamationExclamationToken);
+                }
+                else if (this.CurrentToken.Kind is SyntaxKind.ExclamationEqualsToken)
+                {
+                    // split != into two tokens.
+                    var exclamationEquals = this.EatToken();
 
-                        exclamationExclamationToken = MergeAdjacent(
-                            firstExclamation,
-                            SyntaxFactory.Token(exclamationEquals.GetLeadingTrivia(), SyntaxKind.ExclamationToken, trailing: null),
-                            SyntaxKind.ExclamationExclamationToken);
-                        equalsToken = SyntaxFactory.Token(leading: null, SyntaxKind.EqualsToken, exclamationEquals.GetTrailingTrivia());
-                    }
+                    exclamationExclamationToken = MergeAdjacent(
+                        firstExclamation,
+                        SyntaxFactory.Token(exclamationEquals.GetLeadingTrivia(), SyntaxKind.ExclamationToken, trailing: null),
+                        SyntaxKind.ExclamationExclamationToken);
+                    equalsToken = SyntaxFactory.Token(leading: null, SyntaxKind.EqualsToken, exclamationEquals.GetTrailingTrivia());
                 }
                 else
                 {

From 6f2b564b75e51806306a05fe797cc10c02128afb Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Wed, 5 Jan 2022 15:57:48 -0800
Subject: [PATCH 244/444] Disallow features with __arglist

---
 .../CSharp/Portable/Parser/LanguageParser.cs  |  14 +-
 .../Semantics/NullCheckedParameterTests.cs    | 202 ++++++++----------
 .../Syntax/Parsing/DeclarationParsingTests.cs |  75 ++++++-
 3 files changed, 165 insertions(+), 126 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
index 90c6a2701a09b..75a65c5290f4d 100644
--- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
+++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
@@ -4386,21 +4386,17 @@ private ParameterSyntax ParseParameter()
             {
                 this.ParseParameterModifiers(modifiers);
 
-                TypeSyntax type;
-                SyntaxToken identifier;
                 if (this.CurrentToken.Kind == SyntaxKind.ArgListKeyword)
                 {
                     // We store an __arglist parameter as a parameter with null type and whose 
                     // .Identifier has the kind ArgListKeyword.
-                    type = null;
-                    identifier = this.EatToken(SyntaxKind.ArgListKeyword);
-                }
-                else
-                {
-                    type = this.ParseType(mode: ParseTypeMode.Parameter);
-                    identifier = this.ParseIdentifierToken();
+                    return _syntaxFactory.Parameter(
+                        attributes, modifiers.ToList(), type: null, this.EatToken(SyntaxKind.ArgListKeyword), exclamationExclamationToken: null, @default: null);
                 }
 
+                var type = this.ParseType(mode: ParseTypeMode.Parameter);
+                var identifier = this.ParseIdentifierToken();
+
                 // When the user type "int goo[]", give them a useful error
                 if (this.CurrentToken.Kind is SyntaxKind.OpenBracketToken && this.PeekToken(1).Kind is SyntaxKind.CloseBracketToken)
                 {
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs
index f6e02cac45ba2..5dfccc5784c12 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs
@@ -140,48 +140,49 @@ void M7(string name!
     != null) { }
 }";
             CreateCompilation(source, parseOptions: TestOptions.RegularPreview).VerifyDiagnostics(
-                // (5,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                //     void M0(string name !!=null) { }
-                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(5, 20),
-                // (6,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                //     void M1(string name! !=null) { }
-                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(6, 20),
-                // (6,26): error CS1525: Invalid expression term '!'
-                //     void M1(string name! !=null) { }
-                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(6, 26),
-                // (7,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                //     void M2(string name!!= null) { }
-                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(7, 20),
-                // (8,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                //     void M3(string name ! !=null) { }
-                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(8, 20),
-                // (8,27): error CS1525: Invalid expression term '!'
-                //     void M3(string name ! !=null) { }
-                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(8, 27),
-                // (9,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                //     void M4(string name ! ! =null) { }
-                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(9, 20),
-                // (9,27): error CS1525: Invalid expression term '!'
-                //     void M4(string name ! ! =null) { }
-                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(9, 27),
-                // (10,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                //     void M5(string name! ! =null) { }
-                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(10, 20),
-                // (10,26): error CS1525: Invalid expression term '!'
-                //     void M5(string name! ! =null) { }
-                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(10, 26),
-                // (11,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                //     void M6(string name! != null) { }
-                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(11, 20),
-                // (11,26): error CS1525: Invalid expression term '!'
-                //     void M6(string name! != null) { }
-                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(11, 26),
-                // (12,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                //     void M7(string name!
-                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(12, 20),
-                // (13,5): error CS1525: Invalid expression term '!'
-                //     != null) { }
-                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(13, 5));
+                    // (5,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
+                    //     void M0(string name !!=null) { }
+                    Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(5, 20),
+                    // (6,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
+                    //     void M1(string name! !=null) { }
+                    Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(6, 20),
+                    // (6,24): error CS1003: Syntax error, '!!' expected
+                    //     void M1(string name! !=null) { }
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "! !=").WithArguments("!!", "!").WithLocation(6, 24),
+                    // (7,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
+                    //     void M2(string name!!= null) { }
+                    Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(7, 20),
+                    // (8,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
+                    //     void M3(string name ! !=null) { }
+                    Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(8, 20),
+                    // (8,25): error CS1003: Syntax error, '!!' expected
+                    //     void M3(string name ! !=null) { }
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "! !=").WithArguments("!!", "!").WithLocation(8, 25),
+                    // (9,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
+                    //     void M4(string name ! ! =null) { }
+                    Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(9, 20),
+                    // (9,25): error CS1003: Syntax error, '!!' expected
+                    //     void M4(string name ! ! =null) { }
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(9, 25),
+                    // (10,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
+                    //     void M5(string name! ! =null) { }
+                    Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(10, 20),
+                    // (10,24): error CS1003: Syntax error, '!!' expected
+                    //     void M5(string name! ! =null) { }
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(10, 24),
+                    // (11,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
+                    //     void M6(string name! != null) { }
+                    Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(11, 20),
+                    // (11,24): error CS1003: Syntax error, '!!' expected
+                    //     void M6(string name! != null) { }
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "! !=").WithArguments("!!", "!").WithLocation(11, 24),
+                    // (12,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
+                    //     void M7(string name!
+                    Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(12, 20),
+                    // (12,24): error CS1003: Syntax error, '!!' expected
+                    //     void M7(string name!
+                    Diagnostic(ErrorCode.ERR_SyntaxError, @"!
+ ").WithArguments("!!", "!").WithLocation(12, 24));
         }
 
         [Fact]
@@ -497,72 +498,57 @@ public void M()
     }
 }";
             CreateCompilation(source, parseOptions: TestOptions.RegularPreview).VerifyDiagnostics(
-                    // (7,39): error CS1003: Syntax error, '=>' expected
-                    //         Func<string, string> func0 = x!=> x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!=").WithArguments("=>", "!=").WithLocation(7, 39),
-                    // (7,39): error CS1525: Invalid expression term '!='
-                    //         Func<string, string> func0 = x!=> x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!=").WithArguments("!=").WithLocation(7, 39),
-                    // (7,41): error CS1525: Invalid expression term '>'
-                    //         Func<string, string> func0 = x!=> x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, ">").WithArguments(">").WithLocation(7, 41),
-                    // (8,40): error CS1003: Syntax error, '=>' expected
-                    //         Func<string, string> func1 = x !=> x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!=").WithArguments("=>", "!=").WithLocation(8, 40),
-                    // (8,40): error CS1525: Invalid expression term '!='
-                    //         Func<string, string> func1 = x !=> x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!=").WithArguments("!=").WithLocation(8, 40),
-                    // (8,42): error CS1525: Invalid expression term '>'
-                    //         Func<string, string> func1 = x !=> x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, ">").WithArguments(">").WithLocation(8, 42),
-                    // (9,40): error CS1003: Syntax error, '=>' expected
-                    //         Func<string, string> func2 = x != > x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!=").WithArguments("=>", "!=").WithLocation(9, 40),
-                    // (9,40): error CS1525: Invalid expression term '!='
-                    //         Func<string, string> func2 = x != > x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!=").WithArguments("!=").WithLocation(9, 40),
-                    // (9,43): error CS1525: Invalid expression term '>'
-                    //         Func<string, string> func2 = x != > x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, ">").WithArguments(">").WithLocation(9, 43),
-                    // (10,38): error CS0103: The name 'x' does not exist in the current context
-                    //         Func<string, string> func3 = x! => x;
-                    Diagnostic(ErrorCode.ERR_NameNotInContext, "x").WithArguments("x").WithLocation(10, 38),
-                    // (10,41): error CS1003: Syntax error, ',' expected
-                    //         Func<string, string> func3 = x! => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(10, 41),
-                    // (10,44): error CS1002: ; expected
-                    //         Func<string, string> func3 = x! => x;
-                    Diagnostic(ErrorCode.ERR_SemicolonExpected, "x").WithLocation(10, 44),
-                    // (10,44): error CS0103: The name 'x' does not exist in the current context
-                    //         Func<string, string> func3 = x! => x;
-                    Diagnostic(ErrorCode.ERR_NameNotInContext, "x").WithArguments("x").WithLocation(10, 44),
-                    // (10,44): error CS0201: Only assignment, call, increment, decrement, await, and new object expressions can be used as a statement
-                    //         Func<string, string> func3 = x! => x;
-                    Diagnostic(ErrorCode.ERR_IllegalStatement, "x").WithLocation(10, 44),
-                    // (11,38): error CS0103: The name 'x' does not exist in the current context
-                    //         Func<string, string> func4 = x ! => x;
-                    Diagnostic(ErrorCode.ERR_NameNotInContext, "x").WithArguments("x").WithLocation(11, 38),
-                    // (11,42): error CS1003: Syntax error, ',' expected
-                    //         Func<string, string> func4 = x ! => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(11, 42),
-                    // (11,45): error CS1002: ; expected
-                    //         Func<string, string> func4 = x ! => x;
-                    Diagnostic(ErrorCode.ERR_SemicolonExpected, "x").WithLocation(11, 45),
-                    // (11,45): error CS0103: The name 'x' does not exist in the current context
-                    //         Func<string, string> func4 = x ! => x;
-                    Diagnostic(ErrorCode.ERR_NameNotInContext, "x").WithArguments("x").WithLocation(11, 45),
-                    // (11,45): error CS0201: Only assignment, call, increment, decrement, await, and new object expressions can be used as a statement
-                    //         Func<string, string> func4 = x ! => x;
-                    Diagnostic(ErrorCode.ERR_IllegalStatement, "x").WithLocation(11, 45),
-                    // (13,44): error CS1525: Invalid expression term '>'
-                    //         Func<string, string> func6 = x !!= > x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, ">").WithArguments(">").WithLocation(13, 44),
-                    // (15,41): error CS1525: Invalid expression term '!'
-                    //         Func<string, string> func8 = x! !=> x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(15, 41),
-                    // (16,41): error CS1525: Invalid expression term '!'
-                    //         Func<string, string> func9 = x! ! => x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(16, 41));
+                // (7,39): error CS1003: Syntax error, '!!' expected
+                //         Func<string, string> func0 = x!=> x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(7, 39),
+                // (8,40): error CS1003: Syntax error, '!!' expected
+                //         Func<string, string> func1 = x !=> x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(8, 40),
+                // (9,40): error CS1003: Syntax error, '!!' expected
+                //         Func<string, string> func2 = x != > x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(9, 40),
+                // (9,41): error CS1003: Syntax error, '=>' expected
+                //         Func<string, string> func2 = x != > x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments("=>", "=").WithLocation(9, 41),
+                // (10,38): error CS0103: The name 'x' does not exist in the current context
+                //         Func<string, string> func3 = x! => x;
+                Diagnostic(ErrorCode.ERR_NameNotInContext, "x").WithArguments("x").WithLocation(10, 38),
+                // (10,41): error CS1003: Syntax error, ',' expected
+                //         Func<string, string> func3 = x! => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(10, 41),
+                // (10,44): error CS1002: ; expected
+                //         Func<string, string> func3 = x! => x;
+                Diagnostic(ErrorCode.ERR_SemicolonExpected, "x").WithLocation(10, 44),
+                // (10,44): error CS0103: The name 'x' does not exist in the current context
+                //         Func<string, string> func3 = x! => x;
+                Diagnostic(ErrorCode.ERR_NameNotInContext, "x").WithArguments("x").WithLocation(10, 44),
+                // (10,44): error CS0201: Only assignment, call, increment, decrement, await, and new object expressions can be used as a statement
+                //         Func<string, string> func3 = x! => x;
+                Diagnostic(ErrorCode.ERR_IllegalStatement, "x").WithLocation(10, 44),
+                // (11,38): error CS0103: The name 'x' does not exist in the current context
+                //         Func<string, string> func4 = x ! => x;
+                Diagnostic(ErrorCode.ERR_NameNotInContext, "x").WithArguments("x").WithLocation(11, 38),
+                // (11,42): error CS1003: Syntax error, ',' expected
+                //         Func<string, string> func4 = x ! => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(11, 42),
+                // (11,45): error CS1002: ; expected
+                //         Func<string, string> func4 = x ! => x;
+                Diagnostic(ErrorCode.ERR_SemicolonExpected, "x").WithLocation(11, 45),
+                // (11,45): error CS0103: The name 'x' does not exist in the current context
+                //         Func<string, string> func4 = x ! => x;
+                Diagnostic(ErrorCode.ERR_NameNotInContext, "x").WithArguments("x").WithLocation(11, 45),
+                // (11,45): error CS0201: Only assignment, call, increment, decrement, await, and new object expressions can be used as a statement
+                //         Func<string, string> func4 = x ! => x;
+                Diagnostic(ErrorCode.ERR_IllegalStatement, "x").WithLocation(11, 45),
+                // (13,42): error CS1003: Syntax error, '=>' expected
+                //         Func<string, string> func6 = x !!= > x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments("=>", "=").WithLocation(13, 42),
+                // (15,39): error CS1003: Syntax error, '!!' expected
+                //         Func<string, string> func8 = x! !=> x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(15, 39),
+                // (16,39): error CS1003: Syntax error, '!!' expected
+                //         Func<string, string> func9 = x! ! => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "! ").WithArguments("!!", "!").WithLocation(16, 39));
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs
index 4c59496b30fef..d50a88347bf59 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs
@@ -7396,9 +7396,9 @@ public void TestOptParamMethodDeclarationWithNullValidationNoSpaces()
         public void TestNullCheckedArgList()
         {
             UsingStatement(@"void M(__arglist!) { }", options: TestOptions.RegularPreview,
-                    // (1,17): error CS1003: Syntax error, '!!' expected
+                    // (1,17): error CS1003: Syntax error, ',' expected
                     // void M(__arglist!) { }
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 17));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments(",", "!").WithLocation(1, 17));
             N(SyntaxKind.LocalFunctionStatement);
             {
                 N(SyntaxKind.PredefinedType);
@@ -7412,7 +7412,6 @@ public void TestNullCheckedArgList()
                     N(SyntaxKind.Parameter);
                     {
                         N(SyntaxKind.ArgListKeyword);
-                        N(SyntaxKind.ExclamationExclamationToken);
                     }
                     N(SyntaxKind.CloseParenToken);
                 }
@@ -7426,9 +7425,22 @@ public void TestNullCheckedArgList()
         }
 
         [Fact]
-        public void TestArgListWithDefaultValue()
+        public void TestArgListWithBrackets()
         {
-            UsingStatement(@"void M(__arglist = null) { }", options: TestOptions.RegularPreview); N(SyntaxKind.LocalFunctionStatement);
+            UsingStatement(@"void M(__arglist[]) { }", options: TestOptions.RegularPreview,
+                    // (1,17): error CS1003: Syntax error, ',' expected
+                    // void M(__arglist[]) { }
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "[").WithArguments(",", "[").WithLocation(1, 17),
+                    // (1,18): error CS1001: Identifier expected
+                    // void M(__arglist[]) { }
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, "]").WithLocation(1, 18),
+                    // (1,19): error CS1031: Type expected
+                    // void M(__arglist[]) { }
+                    Diagnostic(ErrorCode.ERR_TypeExpected, ")").WithLocation(1, 19),
+                    // (1,19): error CS1001: Identifier expected
+                    // void M(__arglist[]) { }
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, ")").WithLocation(1, 19));
+            N(SyntaxKind.LocalFunctionStatement);
             {
                 N(SyntaxKind.PredefinedType);
                 {
@@ -7441,14 +7453,59 @@ public void TestArgListWithDefaultValue()
                     N(SyntaxKind.Parameter);
                     {
                         N(SyntaxKind.ArgListKeyword);
-                        N(SyntaxKind.EqualsValueClause);
+                    }
+                    M(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.AttributeList);
                         {
-                            N(SyntaxKind.EqualsToken);
-                            N(SyntaxKind.NullLiteralExpression);
+                            N(SyntaxKind.OpenBracketToken);
+                            M(SyntaxKind.Attribute);
                             {
-                                N(SyntaxKind.NullKeyword);
+                                M(SyntaxKind.IdentifierName);
+                                {
+                                    M(SyntaxKind.IdentifierToken);
+                                }
                             }
+                            N(SyntaxKind.CloseBracketToken);
+                        }
+                        M(SyntaxKind.IdentifierName);
+                        {
+                            M(SyntaxKind.IdentifierToken);
                         }
+                        M(SyntaxKind.IdentifierToken);
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestArgListWithDefaultValue()
+        {
+            UsingStatement(@"void M(__arglist = null) { }", options: TestOptions.RegularPreview,
+                    // (1,18): error CS1003: Syntax error, ',' expected
+                    // void M(__arglist = null) { }
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments(",", "=").WithLocation(1, 18));
+            N(SyntaxKind.LocalFunctionStatement);
+            {
+                N(SyntaxKind.PredefinedType);
+                {
+                    N(SyntaxKind.VoidKeyword);
+                }
+                N(SyntaxKind.IdentifierToken, "M");
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.ArgListKeyword);
                     }
                     N(SyntaxKind.CloseParenToken);
                 }

From a6c9e0b9412a01bfc15c0d36ff8dc9d5db4590cf Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Wed, 5 Jan 2022 16:00:38 -0800
Subject: [PATCH 245/444] formatting

---
 .../Semantics/NullCheckedParameterTests.cs    | 84 +++++++++----------
 1 file changed, 42 insertions(+), 42 deletions(-)

diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs
index 5dfccc5784c12..085c4a87e36a9 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs
@@ -140,48 +140,48 @@ void M7(string name!
     != null) { }
 }";
             CreateCompilation(source, parseOptions: TestOptions.RegularPreview).VerifyDiagnostics(
-                    // (5,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                    //     void M0(string name !!=null) { }
-                    Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(5, 20),
-                    // (6,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                    //     void M1(string name! !=null) { }
-                    Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(6, 20),
-                    // (6,24): error CS1003: Syntax error, '!!' expected
-                    //     void M1(string name! !=null) { }
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "! !=").WithArguments("!!", "!").WithLocation(6, 24),
-                    // (7,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                    //     void M2(string name!!= null) { }
-                    Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(7, 20),
-                    // (8,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                    //     void M3(string name ! !=null) { }
-                    Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(8, 20),
-                    // (8,25): error CS1003: Syntax error, '!!' expected
-                    //     void M3(string name ! !=null) { }
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "! !=").WithArguments("!!", "!").WithLocation(8, 25),
-                    // (9,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                    //     void M4(string name ! ! =null) { }
-                    Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(9, 20),
-                    // (9,25): error CS1003: Syntax error, '!!' expected
-                    //     void M4(string name ! ! =null) { }
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(9, 25),
-                    // (10,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                    //     void M5(string name! ! =null) { }
-                    Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(10, 20),
-                    // (10,24): error CS1003: Syntax error, '!!' expected
-                    //     void M5(string name! ! =null) { }
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(10, 24),
-                    // (11,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                    //     void M6(string name! != null) { }
-                    Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(11, 20),
-                    // (11,24): error CS1003: Syntax error, '!!' expected
-                    //     void M6(string name! != null) { }
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "! !=").WithArguments("!!", "!").WithLocation(11, 24),
-                    // (12,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                    //     void M7(string name!
-                    Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(12, 20),
-                    // (12,24): error CS1003: Syntax error, '!!' expected
-                    //     void M7(string name!
-                    Diagnostic(ErrorCode.ERR_SyntaxError, @"!
+                // (5,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
+                //     void M0(string name !!=null) { }
+                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(5, 20),
+                // (6,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
+                //     void M1(string name! !=null) { }
+                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(6, 20),
+                // (6,24): error CS1003: Syntax error, '!!' expected
+                //     void M1(string name! !=null) { }
+                Diagnostic(ErrorCode.ERR_SyntaxError, "! !=").WithArguments("!!", "!").WithLocation(6, 24),
+                // (7,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
+                //     void M2(string name!!= null) { }
+                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(7, 20),
+                // (8,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
+                //     void M3(string name ! !=null) { }
+                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(8, 20),
+                // (8,25): error CS1003: Syntax error, '!!' expected
+                //     void M3(string name ! !=null) { }
+                Diagnostic(ErrorCode.ERR_SyntaxError, "! !=").WithArguments("!!", "!").WithLocation(8, 25),
+                // (9,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
+                //     void M4(string name ! ! =null) { }
+                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(9, 20),
+                // (9,25): error CS1003: Syntax error, '!!' expected
+                //     void M4(string name ! ! =null) { }
+                Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(9, 25),
+                // (10,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
+                //     void M5(string name! ! =null) { }
+                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(10, 20),
+                // (10,24): error CS1003: Syntax error, '!!' expected
+                //     void M5(string name! ! =null) { }
+                Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(10, 24),
+                // (11,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
+                //     void M6(string name! != null) { }
+                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(11, 20),
+                // (11,24): error CS1003: Syntax error, '!!' expected
+                //     void M6(string name! != null) { }
+                Diagnostic(ErrorCode.ERR_SyntaxError, "! !=").WithArguments("!!", "!").WithLocation(11, 24),
+                // (12,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
+                //     void M7(string name!
+                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(12, 20),
+                // (12,24): error CS1003: Syntax error, '!!' expected
+                //     void M7(string name!
+                Diagnostic(ErrorCode.ERR_SyntaxError, @"!
  ").WithArguments("!!", "!").WithLocation(12, 24));
         }
 

From f69027324e2f2573c3921f85297c84825ae4e750 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Wed, 5 Jan 2022 16:00:59 -0800
Subject: [PATCH 246/444] formatting

---
 .../Semantics/NullCheckedParameterTests.cs    | 102 +++++++++---------
 1 file changed, 51 insertions(+), 51 deletions(-)

diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs
index 085c4a87e36a9..07e063f4db0e2 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs
@@ -498,57 +498,57 @@ public void M()
     }
 }";
             CreateCompilation(source, parseOptions: TestOptions.RegularPreview).VerifyDiagnostics(
-                // (7,39): error CS1003: Syntax error, '!!' expected
-                //         Func<string, string> func0 = x!=> x;
-                Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(7, 39),
-                // (8,40): error CS1003: Syntax error, '!!' expected
-                //         Func<string, string> func1 = x !=> x;
-                Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(8, 40),
-                // (9,40): error CS1003: Syntax error, '!!' expected
-                //         Func<string, string> func2 = x != > x;
-                Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(9, 40),
-                // (9,41): error CS1003: Syntax error, '=>' expected
-                //         Func<string, string> func2 = x != > x;
-                Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments("=>", "=").WithLocation(9, 41),
-                // (10,38): error CS0103: The name 'x' does not exist in the current context
-                //         Func<string, string> func3 = x! => x;
-                Diagnostic(ErrorCode.ERR_NameNotInContext, "x").WithArguments("x").WithLocation(10, 38),
-                // (10,41): error CS1003: Syntax error, ',' expected
-                //         Func<string, string> func3 = x! => x;
-                Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(10, 41),
-                // (10,44): error CS1002: ; expected
-                //         Func<string, string> func3 = x! => x;
-                Diagnostic(ErrorCode.ERR_SemicolonExpected, "x").WithLocation(10, 44),
-                // (10,44): error CS0103: The name 'x' does not exist in the current context
-                //         Func<string, string> func3 = x! => x;
-                Diagnostic(ErrorCode.ERR_NameNotInContext, "x").WithArguments("x").WithLocation(10, 44),
-                // (10,44): error CS0201: Only assignment, call, increment, decrement, await, and new object expressions can be used as a statement
-                //         Func<string, string> func3 = x! => x;
-                Diagnostic(ErrorCode.ERR_IllegalStatement, "x").WithLocation(10, 44),
-                // (11,38): error CS0103: The name 'x' does not exist in the current context
-                //         Func<string, string> func4 = x ! => x;
-                Diagnostic(ErrorCode.ERR_NameNotInContext, "x").WithArguments("x").WithLocation(11, 38),
-                // (11,42): error CS1003: Syntax error, ',' expected
-                //         Func<string, string> func4 = x ! => x;
-                Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(11, 42),
-                // (11,45): error CS1002: ; expected
-                //         Func<string, string> func4 = x ! => x;
-                Diagnostic(ErrorCode.ERR_SemicolonExpected, "x").WithLocation(11, 45),
-                // (11,45): error CS0103: The name 'x' does not exist in the current context
-                //         Func<string, string> func4 = x ! => x;
-                Diagnostic(ErrorCode.ERR_NameNotInContext, "x").WithArguments("x").WithLocation(11, 45),
-                // (11,45): error CS0201: Only assignment, call, increment, decrement, await, and new object expressions can be used as a statement
-                //         Func<string, string> func4 = x ! => x;
-                Diagnostic(ErrorCode.ERR_IllegalStatement, "x").WithLocation(11, 45),
-                // (13,42): error CS1003: Syntax error, '=>' expected
-                //         Func<string, string> func6 = x !!= > x;
-                Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments("=>", "=").WithLocation(13, 42),
-                // (15,39): error CS1003: Syntax error, '!!' expected
-                //         Func<string, string> func8 = x! !=> x;
-                Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(15, 39),
-                // (16,39): error CS1003: Syntax error, '!!' expected
-                //         Func<string, string> func9 = x! ! => x;
-                Diagnostic(ErrorCode.ERR_SyntaxError, "! ").WithArguments("!!", "!").WithLocation(16, 39));
+                    // (7,39): error CS1003: Syntax error, '!!' expected
+                    //         Func<string, string> func0 = x!=> x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(7, 39),
+                    // (8,40): error CS1003: Syntax error, '!!' expected
+                    //         Func<string, string> func1 = x !=> x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(8, 40),
+                    // (9,40): error CS1003: Syntax error, '!!' expected
+                    //         Func<string, string> func2 = x != > x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(9, 40),
+                    // (9,41): error CS1003: Syntax error, '=>' expected
+                    //         Func<string, string> func2 = x != > x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments("=>", "=").WithLocation(9, 41),
+                    // (10,38): error CS0103: The name 'x' does not exist in the current context
+                    //         Func<string, string> func3 = x! => x;
+                    Diagnostic(ErrorCode.ERR_NameNotInContext, "x").WithArguments("x").WithLocation(10, 38),
+                    // (10,41): error CS1003: Syntax error, ',' expected
+                    //         Func<string, string> func3 = x! => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(10, 41),
+                    // (10,44): error CS1002: ; expected
+                    //         Func<string, string> func3 = x! => x;
+                    Diagnostic(ErrorCode.ERR_SemicolonExpected, "x").WithLocation(10, 44),
+                    // (10,44): error CS0103: The name 'x' does not exist in the current context
+                    //         Func<string, string> func3 = x! => x;
+                    Diagnostic(ErrorCode.ERR_NameNotInContext, "x").WithArguments("x").WithLocation(10, 44),
+                    // (10,44): error CS0201: Only assignment, call, increment, decrement, await, and new object expressions can be used as a statement
+                    //         Func<string, string> func3 = x! => x;
+                    Diagnostic(ErrorCode.ERR_IllegalStatement, "x").WithLocation(10, 44),
+                    // (11,38): error CS0103: The name 'x' does not exist in the current context
+                    //         Func<string, string> func4 = x ! => x;
+                    Diagnostic(ErrorCode.ERR_NameNotInContext, "x").WithArguments("x").WithLocation(11, 38),
+                    // (11,42): error CS1003: Syntax error, ',' expected
+                    //         Func<string, string> func4 = x ! => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(11, 42),
+                    // (11,45): error CS1002: ; expected
+                    //         Func<string, string> func4 = x ! => x;
+                    Diagnostic(ErrorCode.ERR_SemicolonExpected, "x").WithLocation(11, 45),
+                    // (11,45): error CS0103: The name 'x' does not exist in the current context
+                    //         Func<string, string> func4 = x ! => x;
+                    Diagnostic(ErrorCode.ERR_NameNotInContext, "x").WithArguments("x").WithLocation(11, 45),
+                    // (11,45): error CS0201: Only assignment, call, increment, decrement, await, and new object expressions can be used as a statement
+                    //         Func<string, string> func4 = x ! => x;
+                    Diagnostic(ErrorCode.ERR_IllegalStatement, "x").WithLocation(11, 45),
+                    // (13,42): error CS1003: Syntax error, '=>' expected
+                    //         Func<string, string> func6 = x !!= > x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments("=>", "=").WithLocation(13, 42),
+                    // (15,39): error CS1003: Syntax error, '!!' expected
+                    //         Func<string, string> func8 = x! !=> x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(15, 39),
+                    // (16,39): error CS1003: Syntax error, '!!' expected
+                    //         Func<string, string> func9 = x! ! => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "! ").WithArguments("!!", "!").WithLocation(16, 39));
         }
 
         [Fact]

From 93297d4692ac9e08e575c0d3c09c4caf6d49949b Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Wed, 29 Dec 2021 12:54:51 -0800
Subject: [PATCH 247/444] Simplify new integration tests using a source
 generator

---
 eng/Versions.props                            |   4 +-
 .../AbstractIntegrationTest.cs                | 112 +--------------
 .../InProcess/EditorInProcess.cs              |   9 +-
 .../InProcess/EditorVerifierInProcess.cs      |   9 +-
 .../InProcess/ErrorListInProcess.cs           |   9 +-
 .../InProcess/InProcComponent.cs              |  67 ---------
 .../InProcess/InputInProcess.cs               |  20 ++-
 .../InProcess/ShellInProcess.cs               |  34 +----
 .../InProcess/SolutionExplorerInProcess.cs    | 132 +-----------------
 .../InProcess/SolutionVerifierInProcess.cs    |   9 +-
 .../InProcess/StateResetInProcess.cs          |   9 +-
 .../InProcess/TestServices.cs                 |  60 --------
 .../InProcess/WorkspaceInProcess.cs           |   9 +-
 ...nguageServices.New.IntegrationTests.csproj |   1 +
 14 files changed, 47 insertions(+), 437 deletions(-)
 delete mode 100644 src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/InProcComponent.cs
 delete mode 100644 src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/TestServices.cs

diff --git a/eng/Versions.props b/eng/Versions.props
index a805334356202..ef7c476551541 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -30,6 +30,7 @@
     <RoslynDiagnosticsNugetPackageVersion>3.3.3-beta1.21105.3</RoslynDiagnosticsNugetPackageVersion>
     <MicrosoftCodeAnalysisNetAnalyzersVersion>6.0.0-rc1.21366.2</MicrosoftCodeAnalysisNetAnalyzersVersion>
     <MicrosoftCodeAnalysisTestingVersion>1.1.1-beta1.21480.3</MicrosoftCodeAnalysisTestingVersion>
+    <MicrosoftVisualStudioExtensibilityTestingVersion>0.1.110-beta</MicrosoftVisualStudioExtensibilityTestingVersion>
     <!-- CodeStyleAnalyzerVersion should we updated together with version of dotnet-format in dotnet-tools.json -->
     <CodeStyleAnalyzerVersion>4.0.0-3.final</CodeStyleAnalyzerVersion>
     <VisualStudioEditorPackagesVersion>16.10.230</VisualStudioEditorPackagesVersion>
@@ -141,7 +142,8 @@
     <MicrosoftVisualStudioDiagnosticsPerformanceProviderVersion>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftVisualStudioDiagnosticsPerformanceProviderVersion>
     <MicrosoftVisualStudioSDKEmbedInteropTypesVersion>15.0.36</MicrosoftVisualStudioSDKEmbedInteropTypesVersion>
     <MicrosoftVisualStudioEditorVersion>$(VisualStudioEditorNewPackagesVersion)</MicrosoftVisualStudioEditorVersion>
-    <MicrosoftVisualStudioExtensibilityTestingXunitVersion>0.1.90-beta</MicrosoftVisualStudioExtensibilityTestingXunitVersion>
+    <MicrosoftVisualStudioExtensibiltyTestingSourceGeneratorVersion>$(MicrosoftVisualStudioExtensibilityTestingVersion)</MicrosoftVisualStudioExtensibiltyTestingSourceGeneratorVersion>
+    <MicrosoftVisualStudioExtensibilityTestingXunitVersion>$(MicrosoftVisualStudioExtensibilityTestingVersion)</MicrosoftVisualStudioExtensibilityTestingXunitVersion>
     <MicrosoftVisualStudioGraphModelVersion>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftVisualStudioGraphModelVersion>
     <MicrosoftVisualStudioImageCatalogVersion>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftVisualStudioImageCatalogVersion>
     <MicrosoftVisualStudioImagingVersion>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftVisualStudioImagingVersion>
diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/AbstractIntegrationTest.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/AbstractIntegrationTest.cs
index 57afa5e9fc765..daffce0aa899a 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/AbstractIntegrationTest.cs
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/AbstractIntegrationTest.cs
@@ -2,132 +2,30 @@
 // 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.Diagnostics.CodeAnalysis;
-using System.Threading;
 using System.Threading.Tasks;
-using System.Windows;
-using System.Windows.Threading;
-using Microsoft.VisualStudio.Shell;
-using Microsoft.VisualStudio.Threading;
+using Microsoft.VisualStudio.Extensibility.Testing;
 using Roslyn.VisualStudio.IntegrationTests.InProcess;
 using Xunit;
 
 namespace Roslyn.VisualStudio.IntegrationTests
 {
     [IdeSettings(MinVersion = VisualStudioVersion.VS2022, RootSuffix = "RoslynDev")]
-    public abstract class AbstractIntegrationTest : IAsyncLifetime, IDisposable
+    public abstract class AbstractIntegrationTest : AbstractIdeIntegrationTest
     {
         protected const string ProjectName = "TestProj";
         protected const string SolutionName = "TestSolution";
 
-        /// <summary>
-        /// A long timeout used to avoid hangs in tests, where a test failure manifests as an operation never occurring.
-        /// </summary>
-        public static readonly TimeSpan HangMitigatingTimeout = TimeSpan.FromMinutes(4);
-
-        private JoinableTaskContext? _joinableTaskContext;
-        private JoinableTaskCollection? _joinableTaskCollection;
-        private JoinableTaskFactory? _joinableTaskFactory;
-
-        private TestServices? _testServices;
-
-        private readonly CancellationTokenSource _hangMitigatingCancellationTokenSource;
-
         protected AbstractIntegrationTest()
         {
-            Assert.True(Application.Current.Dispatcher.CheckAccess());
-
-            JoinableTaskContext = ThreadHelper.JoinableTaskContext;
-
-            _hangMitigatingCancellationTokenSource = new CancellationTokenSource(HangMitigatingTimeout);
-        }
-
-        [NotNull]
-        protected JoinableTaskContext? JoinableTaskContext
-        {
-            get
-            {
-                return _joinableTaskContext ?? throw new InvalidOperationException();
-            }
-
-            private set
-            {
-                if (value == _joinableTaskContext)
-                {
-                    return;
-                }
-
-                if (value is null)
-                {
-                    _joinableTaskContext = null;
-                    _joinableTaskCollection = null;
-                    _joinableTaskFactory = null;
-                }
-                else
-                {
-                    _joinableTaskContext = value;
-                    _joinableTaskCollection = value.CreateCollection();
-                    _joinableTaskFactory = value.CreateFactory(_joinableTaskCollection).WithPriority(Application.Current.Dispatcher, DispatcherPriority.Background);
-                }
-            }
-        }
-
-        [NotNull]
-        private protected TestServices? TestServices
-        {
-            get
-            {
-                return _testServices ?? throw new InvalidOperationException();
-            }
-
-            private set
-            {
-                _testServices = value;
-            }
+            WorkspaceInProcess.EnableAsynchronousOperationTracking();
         }
 
-        protected JoinableTaskFactory JoinableTaskFactory
-            => _joinableTaskFactory ?? throw new InvalidOperationException();
-
-        protected CancellationToken HangMitigatingCancellationToken
-            => _hangMitigatingCancellationTokenSource.Token;
-
-        public virtual async Task InitializeAsync()
+        public override async Task InitializeAsync()
         {
-            TestServices = await CreateTestServicesAsync();
+            await base.InitializeAsync();
 
             await TestServices.StateReset.ResetGlobalOptionsAsync(HangMitigatingCancellationToken);
             await TestServices.StateReset.ResetHostSettingsAsync(HangMitigatingCancellationToken);
         }
-
-        /// <summary>
-        /// This method implements <see cref="IAsyncLifetime.DisposeAsync"/>, and is used for releasing resources
-        /// created by <see cref="IAsyncLifetime.InitializeAsync"/>. This method is only called if
-        /// <see cref="InitializeAsync"/> completes successfully.
-        /// </summary>
-        public virtual async Task DisposeAsync()
-        {
-            await TestServices.SolutionExplorer.CloseSolutionAsync(HangMitigatingCancellationToken);
-
-            if (_joinableTaskCollection is object)
-            {
-                await _joinableTaskCollection.JoinTillEmptyAsync(HangMitigatingCancellationToken);
-            }
-
-            JoinableTaskContext = null;
-        }
-
-        /// <summary>
-        /// This method provides the implementation for <see cref="IDisposable.Dispose"/>.
-        /// This method is called via the <see cref="IDisposable"/> interface if the constructor completes successfully.
-        /// The <see cref="InitializeAsync"/> may or may not have completed successfully.
-        /// </summary>
-        public virtual void Dispose()
-        {
-        }
-
-        private protected virtual async Task<TestServices> CreateTestServicesAsync()
-            => await TestServices.CreateAsync(JoinableTaskFactory);
     }
 }
diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/EditorInProcess.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/EditorInProcess.cs
index 56e7293e12745..d0ac346f395d5 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/EditorInProcess.cs
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/EditorInProcess.cs
@@ -22,6 +22,7 @@
 using Microsoft.CodeAnalysis.UnitTests;
 using Microsoft.VisualStudio;
 using Microsoft.VisualStudio.Editor;
+using Microsoft.VisualStudio.Extensibility.Testing;
 using Microsoft.VisualStudio.IntegrationTest.Utilities;
 using Microsoft.VisualStudio.IntegrationTest.Utilities.Input;
 using Microsoft.VisualStudio.Language.Intellisense;
@@ -40,13 +41,9 @@
 
 namespace Roslyn.VisualStudio.IntegrationTests.InProcess
 {
-    internal class EditorInProcess : InProcComponent
+    [TestService]
+    internal partial class EditorInProcess
     {
-        public EditorInProcess(TestServices testServices)
-            : base(testServices)
-        {
-        }
-
         public async Task<IWpfTextView> GetActiveTextViewAsync(CancellationToken cancellationToken)
             => (await GetActiveTextViewHostAsync(cancellationToken)).TextView;
 
diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/EditorVerifierInProcess.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/EditorVerifierInProcess.cs
index 1aede4f2782f7..51da240d3f8ba 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/EditorVerifierInProcess.cs
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/EditorVerifierInProcess.cs
@@ -10,19 +10,16 @@
 using Microsoft;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
+using Microsoft.VisualStudio.Extensibility.Testing;
 using Microsoft.VisualStudio.IntegrationTest.Utilities;
 using Roslyn.Utilities;
 using Xunit;
 
 namespace Roslyn.VisualStudio.IntegrationTests.InProcess
 {
-    internal class EditorVerifierInProcess : InProcComponent
+    [TestService]
+    internal partial class EditorVerifierInProcess
     {
-        public EditorVerifierInProcess(TestServices testServices)
-            : base(testServices)
-        {
-        }
-
         public async Task CurrentLineTextAsync(
             string expectedText,
             bool assertCaretPosition = false,
diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/ErrorListInProcess.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/ErrorListInProcess.cs
index 23379c20c4316..f8920216dacbd 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/ErrorListInProcess.cs
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/ErrorListInProcess.cs
@@ -2,13 +2,12 @@
 // 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.VisualStudio.Extensibility.Testing;
+
 namespace Roslyn.VisualStudio.IntegrationTests.InProcess
 {
-    internal class ErrorListInProcess : InProcComponent
+    [TestService]
+    internal partial class ErrorListInProcess
     {
-        public ErrorListInProcess(TestServices testServices)
-            : base(testServices)
-        {
-        }
     }
 }
diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/InProcComponent.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/InProcComponent.cs
deleted file mode 100644
index 49ac125c185fa..0000000000000
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/InProcComponent.cs
+++ /dev/null
@@ -1,67 +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 System.Threading.Tasks;
-using System.Windows;
-using System.Windows.Threading;
-using Microsoft;
-using Microsoft.VisualStudio.ComponentModelHost;
-using Microsoft.VisualStudio.Shell;
-using Microsoft.VisualStudio.Shell.Interop;
-using Microsoft.VisualStudio.Threading;
-using Xunit.Threading;
-
-namespace Roslyn.VisualStudio.IntegrationTests.InProcess
-{
-    internal abstract class InProcComponent
-    {
-        protected InProcComponent(TestServices testServices)
-        {
-            TestServices = testServices ?? throw new ArgumentNullException(nameof(testServices));
-        }
-
-        public TestServices TestServices { get; }
-
-        protected JoinableTaskFactory JoinableTaskFactory => TestServices.JoinableTaskFactory;
-
-        protected async Task<TInterface> GetRequiredGlobalServiceAsync<TService, TInterface>(CancellationToken cancellationToken)
-            where TService : class
-            where TInterface : class
-        {
-            await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
-
-            var serviceProvider = (IAsyncServiceProvider2?)await AsyncServiceProvider.GlobalProvider.GetServiceAsync(typeof(SAsyncServiceProvider)).WithCancellation(cancellationToken);
-            Assumes.Present(serviceProvider);
-
-            var @interface = (TInterface?)await serviceProvider.GetServiceAsync(typeof(TService)).WithCancellation(cancellationToken);
-            Assumes.Present(@interface);
-            return @interface;
-        }
-
-        protected async Task<TService> GetComponentModelServiceAsync<TService>(CancellationToken cancellationToken)
-            where TService : class
-        {
-            var componentModel = await GetRequiredGlobalServiceAsync<SComponentModel, IComponentModel>(cancellationToken);
-            return componentModel.GetService<TService>();
-        }
-
-        /// <summary>
-        /// Waiting for the application to 'idle' means that it is done pumping messages (including WM_PAINT).
-        /// </summary>
-        /// <param name="cancellationToken">The cancellation token that the operation will observe.</param>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        protected static async Task WaitForApplicationIdleAsync(CancellationToken cancellationToken)
-        {
-            var synchronizationContext = new DispatcherSynchronizationContext(Application.Current.Dispatcher, DispatcherPriority.ApplicationIdle);
-            var taskScheduler = new SynchronizationContextTaskScheduler(synchronizationContext);
-            await Task.Factory.StartNew(
-                () => { },
-                cancellationToken,
-                TaskCreationOptions.None,
-                taskScheduler);
-        }
-    }
-}
diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/InputInProcess.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/InputInProcess.cs
index d1ce153673d90..ebc72bd93c26f 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/InputInProcess.cs
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/InputInProcess.cs
@@ -4,21 +4,29 @@
 
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.VisualStudio.Extensibility.Testing;
 using Microsoft.VisualStudio.IntegrationTest.Utilities.Input;
 using Microsoft.VisualStudio.Threading;
+using Roslyn.Utilities;
 
 namespace Roslyn.VisualStudio.IntegrationTests.InProcess
 {
-    internal class InputInProcess : InProcComponent
+    [TestService]
+    internal partial class InputInProcess
     {
-        public InputInProcess(TestServices testServices)
-            : base(testServices)
+        private SendKeysImpl? _lazySendKeys;
+
+        private SendKeysImpl SendKeys
         {
-            SendKeys = new(testServices);
+            get
+            {
+                return LazyInitialization.EnsureInitialized(
+                    ref _lazySendKeys,
+                    static testServices => new SendKeysImpl(testServices),
+                    TestServices);
+            }
         }
 
-        private SendKeysImpl SendKeys { get; }
-
         internal async Task SendAsync(params object[] keys)
         {
             // AbstractSendKeys runs synchronously, so switch to a background thread before the call
diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/ShellInProcess.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/ShellInProcess.cs
index e09a972477332..6e20e5012972f 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/ShellInProcess.cs
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/ShellInProcess.cs
@@ -2,39 +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;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.VisualStudio.Shell.Interop;
-
-namespace Roslyn.VisualStudio.IntegrationTests.InProcess
+namespace Microsoft.VisualStudio.Extensibility.Testing
 {
-    internal class ShellInProcess : InProcComponent
+    internal partial class ShellInProcess
     {
-        public ShellInProcess(TestServices testServices)
-            : base(testServices)
-        {
-        }
-
-        public async Task<Version> GetVersionAsync(CancellationToken cancellationToken)
-        {
-            await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
-
-            var shell = await GetRequiredGlobalServiceAsync<SVsShell, IVsShell>(cancellationToken);
-            shell.GetProperty((int)__VSSPROPID5.VSSPROPID_ReleaseVersion, out var versionProperty);
-
-            var fullVersion = versionProperty?.ToString() ?? "";
-            var firstSpace = fullVersion.IndexOf(' ');
-            if (firstSpace >= 0)
-            {
-                // e.g. "17.1.31907.60 MAIN"
-                fullVersion = fullVersion[..firstSpace];
-            }
-
-            if (Version.TryParse(fullVersion, out var version))
-                return version;
-
-            throw new NotSupportedException($"Unexpected version format: {versionProperty}");
-        }
     }
 }
diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/SolutionExplorerInProcess.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/SolutionExplorerInProcess.cs
index 3192bc829da18..b258a3633e18e 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/SolutionExplorerInProcess.cs
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/SolutionExplorerInProcess.cs
@@ -10,9 +10,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using System.Xml.Linq;
-using Microsoft;
 using Microsoft.CodeAnalysis;
-using Microsoft.VisualStudio;
 using Microsoft.VisualStudio.Editor;
 using Microsoft.VisualStudio.IntegrationTest.Utilities;
 using Microsoft.VisualStudio.Shell;
@@ -22,19 +20,14 @@
 using Microsoft.VisualStudio.TextManager.Interop;
 using Microsoft.VisualStudio.Threading;
 using NuGet.SolutionRestoreManager;
-using IAsyncDisposable = System.IAsyncDisposable;
+using Roslyn.VisualStudio.IntegrationTests.InProcess;
 using Reference = VSLangProj.Reference;
 using VSProject = VSLangProj.VSProject;
 
-namespace Roslyn.VisualStudio.IntegrationTests.InProcess
+namespace Microsoft.VisualStudio.Extensibility.Testing
 {
-    internal class SolutionExplorerInProcess : InProcComponent
+    internal partial class SolutionExplorerInProcess
     {
-        public SolutionExplorerInProcess(TestServices testServices)
-            : base(testServices)
-        {
-        }
-
         public async Task CreateSolutionAsync(string solutionName, CancellationToken cancellationToken)
         {
             await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
@@ -348,50 +341,6 @@ private async Task<string> GetAbsolutePathForProjectRelativeFilePathAsync(string
             return Path.Combine(projectPath, relativeFilePath);
         }
 
-        private async Task<bool> IsSolutionOpenAsync(CancellationToken cancellationToken)
-        {
-            await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
-
-            var solution = await GetRequiredGlobalServiceAsync<SVsSolution, IVsSolution>(cancellationToken);
-            ErrorHandler.ThrowOnFailure(solution.GetProperty((int)__VSPROPID.VSPROPID_IsSolutionOpen, out var isOpen));
-            return (bool)isOpen;
-        }
-
-        /// <summary>
-        /// Close the currently open solution without saving.
-        /// </summary>
-        public async Task CloseSolutionAsync(CancellationToken cancellationToken)
-        {
-            await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
-
-            var solution = await GetRequiredGlobalServiceAsync<SVsSolution, IVsSolution>(cancellationToken);
-            if (!await IsSolutionOpenAsync(cancellationToken))
-            {
-                return;
-            }
-
-#pragma warning disable IDE0007 // Use implicit type (implicit type introduces a compiler warning)
-            using SemaphoreSlim semaphore = new SemaphoreSlim(1);
-#pragma warning restore IDE0007 // Use implicit type
-            await using var solutionEvents = new SolutionEvents(JoinableTaskFactory, solution);
-
-            await semaphore.WaitAsync(cancellationToken);
-
-            void HandleAfterCloseSolution(object sender, EventArgs e)
-                => semaphore.Release();
-
-            solutionEvents.AfterCloseSolution += HandleAfterCloseSolution;
-            try
-            {
-                ErrorHandler.ThrowOnFailure(solution.CloseSolutionElement((uint)__VSSLNCLOSEOPTIONS.SLNCLOSEOPT_DeleteProject | (uint)__VSSLNSAVEOPTIONS.SLNSAVEOPT_NoSave, null, 0));
-                await semaphore.WaitAsync(cancellationToken);
-            }
-            finally
-            {
-                solutionEvents.AfterCloseSolution -= HandleAfterCloseSolution;
-            }
-        }
-
         private async Task<string> GetDirectoryNameAsync(CancellationToken cancellationToken)
         {
             await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
@@ -474,80 +423,5 @@ private static string CreateTemporaryPath()
                         || string.Equals(project.Name, nameOrFileName, StringComparison.OrdinalIgnoreCase);
                 });
         }
-
-        private sealed class SolutionEvents : IVsSolutionEvents, IAsyncDisposable
-        {
-            private readonly JoinableTaskFactory _joinableTaskFactory;
-            private readonly IVsSolution _solution;
-            private readonly uint _cookie;
-
-            public SolutionEvents(JoinableTaskFactory joinableTaskFactory, IVsSolution solution)
-            {
-                ThreadHelper.ThrowIfNotOnUIThread();
-
-                _joinableTaskFactory = joinableTaskFactory;
-                _solution = solution;
-                ErrorHandler.ThrowOnFailure(solution.AdviseSolutionEvents(this, out _cookie));
-            }
-
-            public event EventHandler? AfterCloseSolution;
-
-            public async ValueTask DisposeAsync()
-            {
-                await _joinableTaskFactory.SwitchToMainThreadAsync(CancellationToken.None);
-                ErrorHandler.ThrowOnFailure(_solution.UnadviseSolutionEvents(_cookie));
-            }
-
-            public int OnAfterOpenProject(IVsHierarchy pHierarchy, int fAdded)
-            {
-                return VSConstants.S_OK;
-            }
-
-            public int OnQueryCloseProject(IVsHierarchy pHierarchy, int fRemoving, ref int pfCancel)
-            {
-                return VSConstants.S_OK;
-            }
-
-            public int OnBeforeCloseProject(IVsHierarchy pHierarchy, int fRemoved)
-            {
-                return VSConstants.S_OK;
-            }
-
-            public int OnAfterLoadProject(IVsHierarchy pStubHierarchy, IVsHierarchy pRealHierarchy)
-            {
-                return VSConstants.S_OK;
-            }
-
-            public int OnQueryUnloadProject(IVsHierarchy pRealHierarchy, ref int pfCancel)
-            {
-                return VSConstants.S_OK;
-            }
-
-            public int OnBeforeUnloadProject(IVsHierarchy pRealHierarchy, IVsHierarchy pStubHierarchy)
-            {
-                return VSConstants.S_OK;
-            }
-
-            public int OnAfterOpenSolution(object pUnkReserved, int fNewSolution)
-            {
-                return VSConstants.S_OK;
-            }
-
-            public int OnQueryCloseSolution(object pUnkReserved, ref int pfCancel)
-            {
-                return VSConstants.S_OK;
-            }
-
-            public int OnBeforeCloseSolution(object pUnkReserved)
-            {
-                return VSConstants.S_OK;
-            }
-
-            public int OnAfterCloseSolution(object pUnkReserved)
-            {
-                AfterCloseSolution?.Invoke(this, EventArgs.Empty);
-                return VSConstants.S_OK;
-            }
-        }
     }
 }
diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/SolutionVerifierInProcess.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/SolutionVerifierInProcess.cs
index 5293ae8cbe03e..c57af108f6ef0 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/SolutionVerifierInProcess.cs
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/SolutionVerifierInProcess.cs
@@ -4,17 +4,14 @@
 
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.VisualStudio.Extensibility.Testing;
 using Xunit;
 
 namespace Roslyn.VisualStudio.IntegrationTests.InProcess
 {
-    internal class SolutionVerifierInProcess : InProcComponent
+    [TestService]
+    internal partial class SolutionVerifierInProcess
     {
-        public SolutionVerifierInProcess(TestServices testServices)
-            : base(testServices)
-        {
-        }
-
         public async Task AssemblyReferencePresentAsync(string projectName, string assemblyName, string assemblyVersion, string assemblyPublicKeyToken, CancellationToken cancellationToken)
         {
             var assemblyReferences = await TestServices.SolutionExplorer.GetAssemblyReferencesAsync(projectName, cancellationToken);
diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/StateResetInProcess.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/StateResetInProcess.cs
index 41f66aa43ea22..08daa1cac3fb0 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/StateResetInProcess.cs
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/StateResetInProcess.cs
@@ -11,17 +11,14 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Editor.Options;
 using Microsoft.CodeAnalysis.Options;
+using Microsoft.VisualStudio.Extensibility.Testing;
 using Microsoft.VisualStudio.LanguageServices;
 
 namespace Roslyn.VisualStudio.IntegrationTests.InProcess
 {
-    internal class StateResetInProcess : InProcComponent
+    [TestService]
+    internal partial class StateResetInProcess
     {
-        public StateResetInProcess(TestServices testServices)
-            : base(testServices)
-        {
-        }
-
         public async Task ResetGlobalOptionsAsync(CancellationToken cancellationToken)
         {
             var globalOptions = await GetComponentModelServiceAsync<IGlobalOptionService>(cancellationToken);
diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/TestServices.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/TestServices.cs
deleted file mode 100644
index 2c4607e0bf62f..0000000000000
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/TestServices.cs
+++ /dev/null
@@ -1,60 +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.Threading.Tasks;
-using Microsoft.VisualStudio.Threading;
-
-namespace Roslyn.VisualStudio.IntegrationTests.InProcess
-{
-    internal class TestServices
-    {
-        protected TestServices(JoinableTaskFactory joinableTaskFactory)
-        {
-            JoinableTaskFactory = joinableTaskFactory;
-
-            Editor = new EditorInProcess(this);
-            EditorVerifier = new EditorVerifierInProcess(this);
-            ErrorList = new ErrorListInProcess(this);
-            Input = new InputInProcess(this);
-            Shell = new ShellInProcess(this);
-            SolutionExplorer = new SolutionExplorerInProcess(this);
-            SolutionVerifier = new SolutionVerifierInProcess(this);
-            StateReset = new StateResetInProcess(this);
-            Workspace = new WorkspaceInProcess(this);
-        }
-
-        public JoinableTaskFactory JoinableTaskFactory { get; }
-
-        public EditorInProcess Editor { get; }
-
-        public EditorVerifierInProcess EditorVerifier { get; }
-
-        public ErrorListInProcess ErrorList { get; }
-
-        public InputInProcess Input { get; }
-
-        public ShellInProcess Shell { get; }
-
-        public SolutionExplorerInProcess SolutionExplorer { get; }
-
-        public SolutionVerifierInProcess SolutionVerifier { get; }
-
-        public StateResetInProcess StateReset { get; }
-
-        public WorkspaceInProcess Workspace { get; }
-
-        internal static async Task<TestServices> CreateAsync(JoinableTaskFactory joinableTaskFactory)
-        {
-            var services = new TestServices(joinableTaskFactory);
-            await services.InitializeAsync();
-            return services;
-        }
-
-        protected virtual Task InitializeAsync()
-        {
-            WorkspaceInProcess.EnableAsynchronousOperationTracking();
-            return Task.CompletedTask;
-        }
-    }
-}
diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/WorkspaceInProcess.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/WorkspaceInProcess.cs
index 46be3bee8f831..5f3ca0ccfe5fd 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/WorkspaceInProcess.cs
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/WorkspaceInProcess.cs
@@ -7,18 +7,15 @@
 using Microsoft.CodeAnalysis.Editor.Shared.Options;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
+using Microsoft.VisualStudio.Extensibility.Testing;
 using Microsoft.VisualStudio.OperationProgress;
 using Microsoft.VisualStudio.Threading;
 
 namespace Roslyn.VisualStudio.IntegrationTests.InProcess
 {
-    internal class WorkspaceInProcess : InProcComponent
+    [TestService]
+    internal partial class WorkspaceInProcess
     {
-        public WorkspaceInProcess(TestServices testServices)
-            : base(testServices)
-        {
-        }
-
         internal static void EnableAsynchronousOperationTracking()
         {
             AsynchronousOperationListenerProvider.Enable(true);
diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/Microsoft.VisualStudio.LanguageServices.New.IntegrationTests.csproj b/src/VisualStudio/IntegrationTest/New.IntegrationTests/Microsoft.VisualStudio.LanguageServices.New.IntegrationTests.csproj
index 11338cab1c03a..852793035d8a9 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/Microsoft.VisualStudio.LanguageServices.New.IntegrationTests.csproj
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/Microsoft.VisualStudio.LanguageServices.New.IntegrationTests.csproj
@@ -47,6 +47,7 @@
     <ProjectReference Include="..\..\..\Workspaces\Core\Portable\Microsoft.CodeAnalysis.Workspaces.csproj" />
   </ItemGroup>
   <ItemGroup>
+    <PackageReference Include="Microsoft.VisualStudio.Extensibilty.Testing.SourceGenerator" Version="$(MicrosoftVisualStudioExtensibiltyTestingSourceGeneratorVersion)" PrivateAssets="all" />
     <PackageReference Include="Microsoft.VisualStudio.Extensibility.Testing.Xunit" Version="$(MicrosoftVisualStudioExtensibilityTestingXunitVersion)" />
     <PackageReference Include="Microsoft.VisualStudio.Imaging.Interop.14.0.DesignTime" Version="$(MicrosoftVisualStudioImagingInterop140DesignTimeVersion)" />
     <PackageReference Include="NuGet.SolutionRestoreManager.Interop" Version="$(NuGetSolutionRestoreManagerInteropVersion)" />

From 608d06af4ef4e3fe84653d07ef97b3283326e96e Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Mon, 3 Jan 2022 10:59:45 -0800
Subject: [PATCH 248/444] Update to
 Microsoft.VisualStudio.Extensibility.Testing 0.1.116-beta

---
 eng/Versions.props                                  |  4 ++--
 .../InProcess/InputInProcess.cs                     | 13 +++++--------
 ...dio.LanguageServices.New.IntegrationTests.csproj |  2 +-
 3 files changed, 8 insertions(+), 11 deletions(-)

diff --git a/eng/Versions.props b/eng/Versions.props
index ef7c476551541..e12b4c1c39b8f 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -30,7 +30,7 @@
     <RoslynDiagnosticsNugetPackageVersion>3.3.3-beta1.21105.3</RoslynDiagnosticsNugetPackageVersion>
     <MicrosoftCodeAnalysisNetAnalyzersVersion>6.0.0-rc1.21366.2</MicrosoftCodeAnalysisNetAnalyzersVersion>
     <MicrosoftCodeAnalysisTestingVersion>1.1.1-beta1.21480.3</MicrosoftCodeAnalysisTestingVersion>
-    <MicrosoftVisualStudioExtensibilityTestingVersion>0.1.110-beta</MicrosoftVisualStudioExtensibilityTestingVersion>
+    <MicrosoftVisualStudioExtensibilityTestingVersion>0.1.116-beta</MicrosoftVisualStudioExtensibilityTestingVersion>
     <!-- CodeStyleAnalyzerVersion should we updated together with version of dotnet-format in dotnet-tools.json -->
     <CodeStyleAnalyzerVersion>4.0.0-3.final</CodeStyleAnalyzerVersion>
     <VisualStudioEditorPackagesVersion>16.10.230</VisualStudioEditorPackagesVersion>
@@ -142,7 +142,7 @@
     <MicrosoftVisualStudioDiagnosticsPerformanceProviderVersion>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftVisualStudioDiagnosticsPerformanceProviderVersion>
     <MicrosoftVisualStudioSDKEmbedInteropTypesVersion>15.0.36</MicrosoftVisualStudioSDKEmbedInteropTypesVersion>
     <MicrosoftVisualStudioEditorVersion>$(VisualStudioEditorNewPackagesVersion)</MicrosoftVisualStudioEditorVersion>
-    <MicrosoftVisualStudioExtensibiltyTestingSourceGeneratorVersion>$(MicrosoftVisualStudioExtensibilityTestingVersion)</MicrosoftVisualStudioExtensibiltyTestingSourceGeneratorVersion>
+    <MicrosoftVisualStudioExtensibilityTestingSourceGeneratorVersion>$(MicrosoftVisualStudioExtensibilityTestingVersion)</MicrosoftVisualStudioExtensibilityTestingSourceGeneratorVersion>
     <MicrosoftVisualStudioExtensibilityTestingXunitVersion>$(MicrosoftVisualStudioExtensibilityTestingVersion)</MicrosoftVisualStudioExtensibilityTestingXunitVersion>
     <MicrosoftVisualStudioGraphModelVersion>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftVisualStudioGraphModelVersion>
     <MicrosoftVisualStudioImageCatalogVersion>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftVisualStudioImageCatalogVersion>
diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/InputInProcess.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/InputInProcess.cs
index ebc72bd93c26f..e0065fb679d80 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/InputInProcess.cs
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/InputInProcess.cs
@@ -16,15 +16,12 @@ internal partial class InputInProcess
     {
         private SendKeysImpl? _lazySendKeys;
 
-        private SendKeysImpl SendKeys
+        private SendKeysImpl SendKeys => _lazySendKeys ?? throw ExceptionUtilities.Unreachable;
+
+        protected override async Task InitializeCoreAsync()
         {
-            get
-            {
-                return LazyInitialization.EnsureInitialized(
-                    ref _lazySendKeys,
-                    static testServices => new SendKeysImpl(testServices),
-                    TestServices);
-            }
+            await base.InitializeCoreAsync();
+            _lazySendKeys = new SendKeysImpl(TestServices);
         }
 
         internal async Task SendAsync(params object[] keys)
diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/Microsoft.VisualStudio.LanguageServices.New.IntegrationTests.csproj b/src/VisualStudio/IntegrationTest/New.IntegrationTests/Microsoft.VisualStudio.LanguageServices.New.IntegrationTests.csproj
index 852793035d8a9..bfd265a449ee6 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/Microsoft.VisualStudio.LanguageServices.New.IntegrationTests.csproj
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/Microsoft.VisualStudio.LanguageServices.New.IntegrationTests.csproj
@@ -47,7 +47,7 @@
     <ProjectReference Include="..\..\..\Workspaces\Core\Portable\Microsoft.CodeAnalysis.Workspaces.csproj" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.VisualStudio.Extensibilty.Testing.SourceGenerator" Version="$(MicrosoftVisualStudioExtensibiltyTestingSourceGeneratorVersion)" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.VisualStudio.Extensibility.Testing.SourceGenerator" Version="$(MicrosoftVisualStudioExtensibilityTestingSourceGeneratorVersion)" PrivateAssets="all" />
     <PackageReference Include="Microsoft.VisualStudio.Extensibility.Testing.Xunit" Version="$(MicrosoftVisualStudioExtensibilityTestingXunitVersion)" />
     <PackageReference Include="Microsoft.VisualStudio.Imaging.Interop.14.0.DesignTime" Version="$(MicrosoftVisualStudioImagingInterop140DesignTimeVersion)" />
     <PackageReference Include="NuGet.SolutionRestoreManager.Interop" Version="$(NuGetSolutionRestoreManagerInteropVersion)" />

From 4ca36aaa70ff3c8826313d318d90994c95dbcc44 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Wed, 5 Jan 2022 16:02:50 -0800
Subject: [PATCH 249/444] Update to
 Microsoft.VisualStudio.Extensibility.Testing 0.1.122-beta

---
 eng/Versions.props                            |  2 +-
 .../InProcess/EditorInProcess.cs              | 37 +------------------
 .../InProcess/WorkspaceInProcess.cs           | 12 +-----
 3 files changed, 4 insertions(+), 47 deletions(-)

diff --git a/eng/Versions.props b/eng/Versions.props
index e12b4c1c39b8f..0cb4883a5263f 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -30,7 +30,7 @@
     <RoslynDiagnosticsNugetPackageVersion>3.3.3-beta1.21105.3</RoslynDiagnosticsNugetPackageVersion>
     <MicrosoftCodeAnalysisNetAnalyzersVersion>6.0.0-rc1.21366.2</MicrosoftCodeAnalysisNetAnalyzersVersion>
     <MicrosoftCodeAnalysisTestingVersion>1.1.1-beta1.21480.3</MicrosoftCodeAnalysisTestingVersion>
-    <MicrosoftVisualStudioExtensibilityTestingVersion>0.1.116-beta</MicrosoftVisualStudioExtensibilityTestingVersion>
+    <MicrosoftVisualStudioExtensibilityTestingVersion>0.1.122-beta</MicrosoftVisualStudioExtensibilityTestingVersion>
     <!-- CodeStyleAnalyzerVersion should we updated together with version of dotnet-format in dotnet-tools.json -->
     <CodeStyleAnalyzerVersion>4.0.0-3.final</CodeStyleAnalyzerVersion>
     <VisualStudioEditorPackagesVersion>16.10.230</VisualStudioEditorPackagesVersion>
diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/EditorInProcess.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/EditorInProcess.cs
index d0ac346f395d5..37c69d509cf96 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/EditorInProcess.cs
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/EditorInProcess.cs
@@ -13,16 +13,13 @@
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Input;
-using Microsoft;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Editor.Implementation.Suggestions;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.UnitTests;
-using Microsoft.VisualStudio;
 using Microsoft.VisualStudio.Editor;
-using Microsoft.VisualStudio.Extensibility.Testing;
 using Microsoft.VisualStudio.IntegrationTest.Utilities;
 using Microsoft.VisualStudio.IntegrationTest.Utilities.Input;
 using Microsoft.VisualStudio.Language.Intellisense;
@@ -33,20 +30,17 @@
 using Microsoft.VisualStudio.TextManager.Interop;
 using Microsoft.VisualStudio.Utilities;
 using Roslyn.Utilities;
+using Roslyn.VisualStudio.IntegrationTests.InProcess;
 using Xunit;
 using IObjectWithSite = Microsoft.VisualStudio.OLE.Interop.IObjectWithSite;
 using IOleCommandTarget = Microsoft.VisualStudio.OLE.Interop.IOleCommandTarget;
 using IOleServiceProvider = Microsoft.VisualStudio.OLE.Interop.IServiceProvider;
 using OLECMDEXECOPT = Microsoft.VisualStudio.OLE.Interop.OLECMDEXECOPT;
 
-namespace Roslyn.VisualStudio.IntegrationTests.InProcess
+namespace Microsoft.VisualStudio.Extensibility.Testing
 {
-    [TestService]
     internal partial class EditorInProcess
     {
-        public async Task<IWpfTextView> GetActiveTextViewAsync(CancellationToken cancellationToken)
-            => (await GetActiveTextViewHostAsync(cancellationToken)).TextView;
-
         public async Task SetTextAsync(string text, CancellationToken cancellationToken)
         {
             await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
@@ -694,32 +688,5 @@ private async Task WaitForCompletionSetAsync(CancellationToken cancellationToken
         {
             await TestServices.Workspace.WaitForAsyncOperationsAsync(FeatureAttribute.CompletionSet, cancellationToken);
         }
-
-        private async Task<IWpfTextViewHost> GetActiveTextViewHostAsync(CancellationToken cancellationToken)
-        {
-            // The active text view might not have finished composing yet, waiting for the application to 'idle'
-            // means that it is done pumping messages (including WM_PAINT) and the window should return the correct text
-            // view.
-            await WaitForApplicationIdleAsync(cancellationToken);
-
-            await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
-
-            var activeVsTextView = (IVsUserData)await GetActiveVsTextViewAsync(cancellationToken);
-
-            ErrorHandler.ThrowOnFailure(activeVsTextView.GetData(DefGuidList.guidIWpfTextViewHost, out var wpfTextViewHost));
-
-            return (IWpfTextViewHost)wpfTextViewHost;
-        }
-
-        private async Task<IVsTextView> GetActiveVsTextViewAsync(CancellationToken cancellationToken)
-        {
-            await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
-
-            var vsTextManager = await GetRequiredGlobalServiceAsync<SVsTextManager, IVsTextManager>(cancellationToken);
-
-            ErrorHandler.ThrowOnFailure(vsTextManager.GetActiveView(fMustHaveFocus: 1, pBuffer: null, ppView: out var vsTextView));
-
-            return vsTextView;
-        }
     }
 }
diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/WorkspaceInProcess.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/WorkspaceInProcess.cs
index 5f3ca0ccfe5fd..a33d4a7d39c4b 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/WorkspaceInProcess.cs
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/WorkspaceInProcess.cs
@@ -7,13 +7,10 @@
 using Microsoft.CodeAnalysis.Editor.Shared.Options;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
-using Microsoft.VisualStudio.Extensibility.Testing;
-using Microsoft.VisualStudio.OperationProgress;
 using Microsoft.VisualStudio.Threading;
 
-namespace Roslyn.VisualStudio.IntegrationTests.InProcess
+namespace Microsoft.VisualStudio.Extensibility.Testing
 {
-    [TestService]
     internal partial class WorkspaceInProcess
     {
         internal static void EnableAsynchronousOperationTracking()
@@ -56,12 +53,5 @@ public async Task WaitForAsyncOperationsAsync(string featuresToWaitFor, bool wai
             var featureWaiter = listenerProvider.GetWaiter(featuresToWaitFor);
             await featureWaiter.ExpeditedWaitAsync().WithCancellation(cancellationToken);
         }
-
-        public async Task WaitForProjectSystemAsync(CancellationToken cancellationToken)
-        {
-            var operationProgressStatus = await GetRequiredGlobalServiceAsync<SVsOperationProgress, IVsOperationProgressStatusService>(cancellationToken);
-            var stageStatus = operationProgressStatus.GetStageStatus(CommonOperationProgressStageIds.Intellisense);
-            await stageStatus.WaitForCompletionAsync().WithCancellation(cancellationToken);
-        }
     }
 }

From 1d913f313fb6977423813c52727ed724d64da6b6 Mon Sep 17 00:00:00 2001
From: Jason Malinowski <jason.malinowski@microsoft.com>
Date: Wed, 5 Jan 2022 13:45:00 -0800
Subject: [PATCH 250/444] Fix a version conflict of System.Drawing.Common
 versions

It appears that some dependency of our MSBuild.UnitTests.csproj
project is bringing in 5.0.0 of System.Drawing.Common, while the
6.0 SDK is referencing binaries that reference 6.0.0 of
System.Drawing.Common, without carrying a proper reference to the 6.0.0
NuGet package. MSBuild can't resolve that, but adding an explicit
reference to 6.0.0 of System.Drawing.Common fixes that.

Upgrading to System.Drawing.Common then causes the platform analyzers
to realize that we're calling a Windows-only API on a cross-platform
DLL. We use HasValidFonts to work around a bug in some of our old CI
infrastructure, but the only place it's already used is already
restricted to Windows only, so we can just duplicate that check to
make everything happy again.
---
 eng/Versions.props                                     |  2 +-
 .../VisualBasic/Test/Semantic/HasValidFonts.vb         | 10 ++++++++--
 ...ft.CodeAnalysis.Workspaces.MSBuild.UnitTests.csproj |  1 +
 3 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/eng/Versions.props b/eng/Versions.props
index 73156c2224466..ff869c5e4f004 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -223,7 +223,7 @@
     <SystemCommandLineVersion>2.0.0-beta1.20574.7</SystemCommandLineVersion>
     <SystemCommandLineExperimentalVersion>0.3.0-alpha.19577.1</SystemCommandLineExperimentalVersion>
     <SystemComponentModelCompositionVersion>4.5.0</SystemComponentModelCompositionVersion>
-    <SystemDrawingCommonVersion>4.5.0</SystemDrawingCommonVersion>
+    <SystemDrawingCommonVersion>6.0.0</SystemDrawingCommonVersion>
     <SystemIOFileSystemVersion>4.3.0</SystemIOFileSystemVersion>
     <SystemIOFileSystemPrimitivesVersion>4.3.0</SystemIOFileSystemPrimitivesVersion>
     <SystemIOPipesAccessControlVersion>4.5.1</SystemIOPipesAccessControlVersion>
diff --git a/src/Compilers/VisualBasic/Test/Semantic/HasValidFonts.vb b/src/Compilers/VisualBasic/Test/Semantic/HasValidFonts.vb
index 3939ebba4d623..d784b33b2c560 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/HasValidFonts.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/HasValidFonts.vb
@@ -3,6 +3,7 @@
 ' See the LICENSE file in the project root for more information.
 
 Imports System.Drawing
+Imports System.Runtime.InteropServices
 Imports Roslyn.Test.Utilities
 
 Friend Class HasValidFonts
@@ -11,8 +12,13 @@ Friend Class HasValidFonts
     Public Overrides ReadOnly Property ShouldSkip As Boolean
         Get
             Try
-                Dim result = SystemFonts.DefaultFont
-                Return result Is Nothing
+                If RuntimeInformation.IsOSPlatform(OSPlatform.Windows) Then
+                    Dim result = SystemFonts.DefaultFont
+                    Return result Is Nothing
+                Else
+                    ' The only tests using fonts are Windows-only.
+                    Return True
+                End If
             Catch ex As Exception
                 ' Motivating issue: https://github.com/dotnet/roslyn/issues/11278
                 '
diff --git a/src/Workspaces/MSBuildTest/Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests.csproj b/src/Workspaces/MSBuildTest/Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests.csproj
index 4810a5f572103..92ae0254f2ba1 100644
--- a/src/Workspaces/MSBuildTest/Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests.csproj
+++ b/src/Workspaces/MSBuildTest/Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests.csproj
@@ -29,6 +29,7 @@
     <PackageReference Include="Microsoft.Build" Version="$(RefOnlyMicrosoftBuildVersion)" ExcludeAssets="Runtime" PrivateAssets="All" />
     <PackageReference Include="Microsoft.Build.Locator" Version="$(MicrosoftBuildLocatorVersion)" />
     <PackageReference Include="Microsoft.Build.Tasks.Core" Version="$(RefOnlyMicrosoftBuildTasksCoreVersion)" ExcludeAssets="Runtime" PrivateAssets="All" />
+    <PackageReference Include="System.Drawing.Common" Version="$(SystemDrawingCommonVersion)" />
 
     <!--
       The package "Microsoft.CodeAnalysis.Analyzer.Testing" brings in a lower version of these NuGet dependencies than is expected by the

From 361f61854da926002ff177027e3fc0511955a10d Mon Sep 17 00:00:00 2001
From: Allison Chou <allichou@microsoft.com>
Date: Wed, 5 Jan 2022 17:12:52 -0800
Subject: [PATCH 251/444] [LSP] Fix semantic tokens overlap bug (#58620)

---
 .../SemanticTokens/SemanticTokensHelpers.cs     |  7 ++++++-
 .../SemanticTokens/SemanticTokensRangeTests.cs  |  6 +++---
 .../Portable/Classification/ClassifierHelper.cs | 17 +++++++++++++----
 3 files changed, 22 insertions(+), 8 deletions(-)

diff --git a/src/Features/LanguageServer/Protocol/Handler/SemanticTokens/SemanticTokensHelpers.cs b/src/Features/LanguageServer/Protocol/Handler/SemanticTokens/SemanticTokensHelpers.cs
index 7d24e2c02b2c5..dbe74f5c985fc 100644
--- a/src/Features/LanguageServer/Protocol/Handler/SemanticTokens/SemanticTokensHelpers.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/SemanticTokens/SemanticTokensHelpers.cs
@@ -4,6 +4,7 @@
 
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Classification;
@@ -187,7 +188,10 @@ private static async Task<ClassifiedSpan[]> GetClassifiedSpansForDocumentAsync(
                 // Therefore, we set both optional parameters to false.
                 var spans = await ClassifierHelper.GetClassifiedSpansAsync(
                     document, textSpan, cancellationToken, removeAdditiveSpans: false, fillInClassifiedSpanGaps: false).ConfigureAwait(false);
-                classifiedSpans.AddRange(spans);
+
+                // The spans returned to us may include some empty spans, which we don't care about.
+                var nonEmptySpans = spans.Where(s => !s.TextSpan.IsEmpty);
+                classifiedSpans.AddRange(nonEmptySpans);
             }
             else
             {
@@ -354,6 +358,7 @@ private static int ComputeNextToken(
 
             // 3. Token length
             var tokenLength = originalTextSpan.Length;
+            Contract.ThrowIfFalse(tokenLength > 0);
 
             // We currently only have one modifier (static). The logic below will need to change in the future if other
             // modifiers are added in the future.
diff --git a/src/Features/LanguageServer/ProtocolUnitTests/SemanticTokens/SemanticTokensRangeTests.cs b/src/Features/LanguageServer/ProtocolUnitTests/SemanticTokens/SemanticTokensRangeTests.cs
index f7306bacc96e1..31dd8082fa02a 100644
--- a/src/Features/LanguageServer/ProtocolUnitTests/SemanticTokens/SemanticTokensRangeTests.cs
+++ b/src/Features/LanguageServer/ProtocolUnitTests/SemanticTokens/SemanticTokensRangeTests.cs
@@ -252,9 +252,9 @@ void M()
                 {
                     // Line | Char | Len | Token type                                                                         | Modifier
                        0,     0,     5,    SemanticTokensHelpers.TokenTypeToIndex[LSP.SemanticTokenTypes.Keyword],                0, // 'using'
-                       0,     6,     6,    SemanticTokensHelpers.TokenTypeToIndex[LSP.SemanticTokenTypes.Variable],               0, // 'System'
+                       0,     6,     6,    SemanticTokensHelpers.TokenTypeToIndex[ClassificationTypeNames.NamespaceName],         0, // 'System'
                        0,     6,     1,    SemanticTokensHelpers.TokenTypeToIndex[LSP.SemanticTokenTypes.Operator],               0, // '.'
-                       0,     1,     4,    SemanticTokensHelpers.TokenTypeToIndex[LSP.SemanticTokenTypes.Variable],               0, // 'Text'
+                       0,     1,     4,    SemanticTokensHelpers.TokenTypeToIndex[ClassificationTypeNames.NamespaceName],         0, // 'Text'
                        0,     4,     1,    SemanticTokensHelpers.TokenTypeToIndex[LSP.SemanticTokenTypes.Operator],               0, // '.'
                        0,     1,     18,   SemanticTokensHelpers.TokenTypeToIndex[ClassificationTypeNames.NamespaceName],         0, // 'RegularExpressions'
                        0,     18,    1,    SemanticTokensHelpers.TokenTypeToIndex[ClassificationTypeNames.Punctuation],           0, // ';'
@@ -270,7 +270,7 @@ void M()
                        0,     4,     1,    SemanticTokensHelpers.TokenTypeToIndex[ClassificationTypeNames.LocalName],             0, // 'x'
                        0,     2,     1,    SemanticTokensHelpers.TokenTypeToIndex[LSP.SemanticTokenTypes.Operator],               0, // '='
                        0,     2,     3,    SemanticTokensHelpers.TokenTypeToIndex[LSP.SemanticTokenTypes.Keyword],                0, // 'new'
-                       0,     4,     5,    SemanticTokensHelpers.TokenTypeToIndex[LSP.SemanticTokenTypes.Variable],               0, // 'Regex'
+                       0,     4,     5,    SemanticTokensHelpers.TokenTypeToIndex[ClassificationTypeNames.ClassName],             0, // 'Regex'
                        0,     5,     1,    SemanticTokensHelpers.TokenTypeToIndex[ClassificationTypeNames.Punctuation],           0, // '('
                        0,     1,     8,    SemanticTokensHelpers.TokenTypeToIndex[LSP.SemanticTokenTypes.String],                 0, // '"(abc)*"'
                        0,     1,     1,    SemanticTokensHelpers.TokenTypeToIndex[ClassificationTypeNames.RegexGrouping],         0, // '('
diff --git a/src/Workspaces/Core/Portable/Classification/ClassifierHelper.cs b/src/Workspaces/Core/Portable/Classification/ClassifierHelper.cs
index 8c2b3354b4eba..f2409444e4364 100644
--- a/src/Workspaces/Core/Portable/Classification/ClassifierHelper.cs
+++ b/src/Workspaces/Core/Portable/Classification/ClassifierHelper.cs
@@ -198,10 +198,19 @@ private static ImmutableArray<ClassifiedSpan> MergeParts(
                 // Take the semantic part if it's just 'text'.  We want to keep it if
                 // the semantic classifier actually produced an interesting result 
                 // (as opposed to it just being a 'gap' classification).
-                var part = replacementIndex >= 0 && !IsClassifiedAsText(semanticParts[replacementIndex])
-                    ? semanticParts[replacementIndex]
-                    : syntaxPartAndSpan;
-                finalParts.Add(part);
+                if (replacementIndex >= 0 && !IsClassifiedAsText(semanticParts[replacementIndex]))
+                {
+                    finalParts.Add(semanticParts[replacementIndex]);
+                }
+                // We might already have a semantic part for the given TextSpan, in
+                // which case we don't want to add the syntactic part unless it's an
+                // additive type name (e.g. `static`).
+                else if (finalParts.Count == 0 ||
+                    !finalParts[^1].TextSpan.Equals(syntaxPartAndSpan.TextSpan) ||
+                    ClassificationTypeNames.AdditiveTypeNames.Contains(syntaxPartAndSpan.ClassificationType))
+                {
+                    finalParts.Add(syntaxPartAndSpan);
+                }
 
                 if (replacementIndex >= 0)
                 {

From 1d233bf2d217759c0d70eecbbdaa764af3669c42 Mon Sep 17 00:00:00 2001
From: Rikki Gibson <rigibson@microsoft.com>
Date: Wed, 5 Jan 2022 17:18:54 -0800
Subject: [PATCH 252/444] Address some feedback and fix tests

---
 .../CSharp/Portable/Parser/LanguageParser.cs  | 55 +++++++-------
 .../Semantics/NullCheckedParameterTests.cs    |  2 +-
 .../Parsing/LambdaParameterParsingTests.cs    | 72 ++++++++++++-------
 3 files changed, 74 insertions(+), 55 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
index 75a65c5290f4d..83fb8dbdc83c6 100644
--- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
+++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
@@ -7,6 +7,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.IO;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.Text;
@@ -4493,11 +4494,11 @@ private void ParseParameterNullCheck(
         /// </summary>
         private SyntaxToken? MergeAdjacent(SyntaxToken t1, SyntaxToken t2, SyntaxKind kind)
         {
-            if (t1.GetTrailingTriviaWidth() == 0 && t2.GetLeadingTriviaWidth() == 0)
+            if (NoTriviaBetween(t1, t2))
                 return SyntaxFactory.Token(t1.GetLeadingTrivia(), kind, t2.GetTrailingTrivia());
 
             var sb = PooledStringBuilder.GetInstance();
-            var writer = new System.IO.StringWriter(sb.Builder, System.Globalization.CultureInfo.InvariantCulture);
+            var writer = new StringWriter(sb.Builder, System.Globalization.CultureInfo.InvariantCulture);
             t1.WriteTo(writer, leading: false, trailing: true);
             t2.WriteTo(writer, leading: true, trailing: false);
             var text = sb.ToStringAndFree();
@@ -11587,17 +11588,17 @@ private bool ScanParenthesizedImplicitlyTypedLambda(Precedence precedence)
 
             bool isParenVarCommaSyntax()
             {
-                var next = this.PeekToken(1);
+                var token1 = this.PeekToken(1);
 
                 // Ensure next token is a variable
-                if (next.Kind == SyntaxKind.IdentifierToken)
+                if (token1.Kind == SyntaxKind.IdentifierToken)
                 {
-                    if (!this.IsInQuery || !IsTokenQueryContextualKeyword(next))
+                    if (!this.IsInQuery || !IsTokenQueryContextualKeyword(token1))
                     {
                         // Variable must be directly followed by a comma if not followed by exclamation
-                        var after = this.PeekToken(2);
+                        var token2 = this.PeekToken(2);
                         // ( x , [...]
-                        if (after.Kind == SyntaxKind.CommaToken)
+                        if (token2.Kind == SyntaxKind.CommaToken)
                         {
                             return true;
                         }
@@ -11605,7 +11606,7 @@ bool isParenVarCommaSyntax()
                         var token3 = this.PeekToken(3);
                         // ( x!! , [...]
                         // https://github.com/dotnet/roslyn/issues/58335: https://github.com/dotnet/roslyn/pull/46520#discussion_r466650228
-                        if (after.Kind == SyntaxKind.ExclamationToken
+                        if (token2.Kind == SyntaxKind.ExclamationToken
                             && token3.Kind == SyntaxKind.ExclamationToken
                             && this.PeekToken(4).Kind == SyntaxKind.CommaToken)
                         {
@@ -11928,27 +11929,18 @@ private bool IsPossibleLambdaExpression(Precedence precedence)
             var token2 = this.PeekToken(2);
             var token3 = this.PeekToken(3);
 
-            // x!! =>
-            //
-            // Def a lambda (though possibly has errors).
-            if (token1.Kind == SyntaxKind.ExclamationToken
-                && token2.Kind == SyntaxKind.ExclamationToken
-                && token3.Kind == SyntaxKind.EqualsGreaterThanToken)
-            {
-                return true;
-            }
+            if ((token1.Kind, token2.Kind, token3.Kind) is
 
-            // Broken case but error will be added in lambda function (!=>).
-            if (token1.Kind == SyntaxKind.ExclamationEqualsToken
-                && token2.Kind == SyntaxKind.GreaterThanToken)
-            {
-                return true;
-            }
+                // x!! =>
+                //
+                // Def a lambda (though possibly has errors).
+                (SyntaxKind.ExclamationToken, SyntaxKind.ExclamationToken, SyntaxKind.EqualsGreaterThanToken)
+
+                // Broken case but error will be added in lambda function (!=>).
+                or (SyntaxKind.ExclamationEqualsToken, SyntaxKind.GreaterThanToken, _)
 
-            // Broken case but error will be added in lambda function (!!=>).
-            if (token1.Kind == SyntaxKind.ExclamationToken
-                && token2.Kind == SyntaxKind.ExclamationEqualsToken
-                && token3.Kind == SyntaxKind.GreaterThanToken)
+                // Broken case but error will be added in lambda function (!!=>).
+                or (SyntaxKind.ExclamationToken, SyntaxKind.ExclamationEqualsToken, SyntaxKind.GreaterThanToken))
             {
                 return true;
             }
@@ -12960,6 +12952,9 @@ LambdaExpressionSyntax parseLambdaExpressionWorker()
                 }
                 else
                 {
+                    // Unparenthesized lambda case
+                    // x => ...
+                    // x!! => ...
                     var identifier = this.ParseIdentifierToken();
 
                     ParseParameterNullCheck(out var exclamationExclamationToken, out var equalsToken);
@@ -13110,9 +13105,9 @@ private ParameterSyntax ParseLambdaParameter()
             var identifier = this.ParseIdentifierToken();
             ParseParameterNullCheck(out var exclamationExclamationToken, out var equalsToken);
 
-            // This should never be non-null.  That indicates while we were scanning for potential lambdas, we saw an
-            // `!!=` or `!=` sign in the parameter list and allowed it. However, that should never happen as
-            // ScanParenthesizedLambda only allows !! only.
+            // 'equalsToken' should always be null here. Otherwise, it means while we were scanning
+            // for potential lambdas, we saw an `!!=` or `!=` sign in the parameter list and allowed
+            // it. However, that should never happen as ScanParenthesizedLambda only allows !! only.
             Debug.Assert(equalsToken == null);
 
             var parameter = _syntaxFactory.Parameter(attributes, modifiers.ToList(), paramType, identifier, exclamationExclamationToken, @default: null);
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs
index 07e063f4db0e2..d3f037e484504 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs
@@ -182,7 +182,7 @@ void M7(string name!
                 // (12,24): error CS1003: Syntax error, '!!' expected
                 //     void M7(string name!
                 Diagnostic(ErrorCode.ERR_SyntaxError, @"!
- ").WithArguments("!!", "!").WithLocation(12, 24));
+ ".NormalizeLineEndings()).WithArguments("!!", "!").WithLocation(12, 24));
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
index b9f8e62bf20a2..2fee51e71946b 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
@@ -1229,7 +1229,8 @@ public void TestNullCheckedSyntaxCorrection0()
             UsingDeclaration("Func<string, string> func0 = x!=> x;", options: TestOptions.RegularPreview,
                     // (1,31): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func0 = x!=> x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 31)); N(SyntaxKind.FieldDeclaration);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 31));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -1284,7 +1285,8 @@ public void TestNullCheckedSyntaxCorrection1()
             UsingDeclaration("Func<string, string> func1 = x !=> x;", options: TestOptions.RegularPreview,
                     // (1,32): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func1 = x !=> x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 32)); N(SyntaxKind.FieldDeclaration);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 32));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -1342,7 +1344,8 @@ public void TestNullCheckedSyntaxCorrection2()
                     Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 32),
                     // (1,33): error CS1003: Syntax error, '=>' expected
                     // Func<string, string> func2 = x != > x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments("=>", "=").WithLocation(1, 33)); N(SyntaxKind.FieldDeclaration);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments("=>", "=").WithLocation(1, 33));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -1549,7 +1552,8 @@ public void TestNullCheckedSyntaxCorrection6()
             UsingDeclaration("Func<string, string> func6 = x !!= > x;", options: TestOptions.RegularPreview,
                     // (1,34): error CS1003: Syntax error, '=>' expected
                     // Func<string, string> func6 = x !!= > x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments("=>", "=").WithLocation(1, 34)); N(SyntaxKind.FieldDeclaration);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments("=>", "=").WithLocation(1, 34));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -1656,7 +1660,8 @@ public void TestNullCheckedSyntaxCorrection8()
             UsingDeclaration("Func<string, string> func8 = x! !=> x;", options: TestOptions.RegularPreview,
                     // (1,31): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func8 = x! !=> x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 31)); N(SyntaxKind.FieldDeclaration);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 31));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -1711,7 +1716,8 @@ public void TestNullCheckedSyntaxCorrection9()
             UsingDeclaration("Func<string, string> func9 = x! ! => x;", options: TestOptions.RegularPreview,
                     // (1,31): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func9 = x! ! => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "! ").WithArguments("!!", "!").WithLocation(1, 31)); N(SyntaxKind.FieldDeclaration);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "! ").WithArguments("!!", "!").WithLocation(1, 31));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -1769,7 +1775,8 @@ public void TestBracesAfterSimpleLambdaName()
                     Diagnostic(ErrorCode.ERR_ValueExpected, "]").WithLocation(1, 34),
                     // (1,36): error CS1003: Syntax error, ',' expected
                     // Func<string[], string> func0 = x[] => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 36)); N(SyntaxKind.FieldDeclaration);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 36));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -1842,7 +1849,8 @@ public void TestBracesAfterParenthesizedLambdaName()
             UsingDeclaration("Func<string[], string> func0 = (x[]) => x;", options: TestOptions.RegularPreview,
                     // (1,36): error CS1001: Identifier expected
                     // Func<string[], string> func0 = (x[]) => x;
-                    Diagnostic(ErrorCode.ERR_IdentifierExpected, ")").WithLocation(1, 36)); N(SyntaxKind.FieldDeclaration);
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, ")").WithLocation(1, 36));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -1935,7 +1943,8 @@ public void TestBracesAfterParenthesizedLambdaTypeAndName()
                     Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 40),
                     // (1,40): error CS1003: Syntax error, ',' expected
                     // Func<string[], string> func0 = (string x[]) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 40)); N(SyntaxKind.FieldDeclaration);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 40));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -1998,7 +2007,8 @@ public void TestDefaultValueSimpleLambda()
             UsingDeclaration("Func<string, string> func0 = x = null => x;", options: TestOptions.RegularPreview,
                     // (1,39): error CS1003: Syntax error, ',' expected
                     // Func<string, string> func0 = x = null => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 39)); N(SyntaxKind.FieldDeclaration);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 39));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -2052,7 +2062,8 @@ public void TestDefaultValueParenthesizedLamda1()
             UsingDeclaration("Func<string, string> func0 = (x = null) => x;", options: TestOptions.RegularPreview,
                     // (1,41): error CS1003: Syntax error, ',' expected
                     // Func<string, string> func0 = (x = null) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 41)); N(SyntaxKind.FieldDeclaration);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 41));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -2111,7 +2122,8 @@ public void TestDefaultValueParenthesizedLamda2()
             UsingDeclaration("Func<string, string> func0 = (y, x = null) => x;", options: TestOptions.RegularPreview,
                     // (1,44): error CS1003: Syntax error, ',' expected
                     // Func<string, string> func0 = (y, x = null) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 44)); N(SyntaxKind.FieldDeclaration);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 44));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -2187,7 +2199,8 @@ public void TestDefaultValueParenthesizedLamdaWithType1()
                     Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 38),
                     // (1,38): error CS1003: Syntax error, ',' expected
                     // Func<string, string> func0 = (string x = null) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 38)); N(SyntaxKind.FieldDeclaration);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 38));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -2244,7 +2257,8 @@ public void TestDefaultValueParenthesizedLamdaWithType2()
                     Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 48),
                     // (1,48): error CS1003: Syntax error, ',' expected
                     // Func<string, string> func0 = (string y, string x = null) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 48)); N(SyntaxKind.FieldDeclaration);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 48));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -2313,7 +2327,8 @@ public void TestNullCheckedDefaultValueSimpleLambda()
             UsingDeclaration("Func<string, string> func0 = x!! = null => x;", options: TestOptions.RegularPreview,
                     // (1,41): error CS1003: Syntax error, ',' expected
                     // Func<string, string> func0 = x!! = null => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 41)); N(SyntaxKind.FieldDeclaration);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 41));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -2375,7 +2390,8 @@ public void TestNullCheckedDefaultValueParenthesizedLamda1()
             UsingDeclaration("Func<string, string> func0 = (x!! = null) => x;", options: TestOptions.RegularPreview,
                     // (1,43): error CS1003: Syntax error, ',' expected
                     // Func<string, string> func0 = (x!! = null) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 43)); N(SyntaxKind.FieldDeclaration);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 43));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -2442,7 +2458,8 @@ public void TestNullCheckedDefaultValueParenthesizedLamda2()
             UsingDeclaration("Func<string, string> func0 = (y, x!! = null) => x;", options: TestOptions.RegularPreview,
                     // (1,46): error CS1003: Syntax error, ',' expected
                     // Func<string, string> func0 = (y, x!! = null) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 46)); N(SyntaxKind.FieldDeclaration);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 46));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -2526,7 +2543,8 @@ public void TestNullCheckedDefaultValueParenthesizedLamdaWithType1()
                     Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 38),
                     // (1,38): error CS1003: Syntax error, ',' expected
                     // Func<string, string> func0 = (string x!! = null) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 38)); N(SyntaxKind.FieldDeclaration);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 38));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -2583,7 +2601,8 @@ public void TestNullCheckedDefaultValueParenthesizedLamdaWithType2()
                 Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 48),
                 // (1,48): error CS1003: Syntax error, ',' expected
                 // Func<string, string> func0 = (string y, string x!! = null) => x;
-                Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 48)); N(SyntaxKind.FieldDeclaration);
+                Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 48));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -2652,7 +2671,8 @@ public void TestNullCheckedSpaceBetweenSimpleLambda()
             UsingDeclaration("Func<string, string> func0 = x! ! => x;", options: TestOptions.RegularPreview,
                     // (1,31): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func0 = x! ! => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "! ").WithArguments("!!", "!").WithLocation(1, 31)); N(SyntaxKind.FieldDeclaration);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "! ").WithArguments("!!", "!").WithLocation(1, 31));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -2707,7 +2727,8 @@ public void TestNullCheckedSpaceBetweenParenthesizedLamda1()
             UsingDeclaration("Func<string, string> func0 = (x! !) => x;", options: TestOptions.RegularPreview,
                     // (1,32): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func0 = (x! !) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 32)); N(SyntaxKind.FieldDeclaration);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 32));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -2767,7 +2788,8 @@ public void TestNullCheckedSpaceBetweenParenthesizedLamda2()
             UsingDeclaration("Func<string, string> func0 = (y, x! !) => x;", options: TestOptions.RegularPreview,
                     // (1,35): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func0 = (y, x! !) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 35)); N(SyntaxKind.FieldDeclaration);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 35));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -2832,7 +2854,8 @@ public void TestNullCheckedSpaceBetweenLamdaWithType1()
             UsingDeclaration("Func<string, string> func0 = (string x! !) => x;", options: TestOptions.RegularPreview,
                     // (1,39): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func0 = (string x! !) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 39)); N(SyntaxKind.FieldDeclaration);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 39));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {
@@ -2896,7 +2919,8 @@ public void TestNullCheckedSpaceBetweenLamdaWithType2()
             UsingDeclaration("Func<string, string> func0 = (string y, string x! !) => x;", options: TestOptions.RegularPreview,
                     // (1,49): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func0 = (string y, string x! !) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 49)); N(SyntaxKind.FieldDeclaration);
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 49));
+            N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
                 {

From 690dfc003fd5d4db506911fb7682fa45026259bd Mon Sep 17 00:00:00 2001
From: Shen Chen <shech@microsoft.com>
Date: Wed, 5 Jan 2022 16:56:52 -0800
Subject: [PATCH 253/444] Inline the method

---
 .../IntegrationTests/Workspace/WorkspaceBase.cs           | 8 --------
 .../IntegrationTests/Workspace/WorkspacesNetCore.cs       | 4 +++-
 2 files changed, 3 insertions(+), 9 deletions(-)

diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspaceBase.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspaceBase.cs
index 287581f41c8f2..57a1a90f2d097 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspaceBase.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspaceBase.cs
@@ -62,14 +62,6 @@ public virtual void MetadataReference()
             VisualStudio.Editor.Verify.CurrentTokenType("identifier");
         }
 
-        public void PackageReference()
-        {
-            var project = new ProjectUtils.Project(ProjectName);
-            var referenceAssemblies = new ProjectUtils.PackageReference("Microsoft.NETFramework.ReferenceAssemblies", "1.0.2");
-            VisualStudio.SolutionExplorer.AddPackageReference(project, referenceAssemblies);
-            VisualStudio.SolutionExplorer.RestoreNuGetPackages(project);
-        }
-
         public virtual void ProjectReference()
         {
             var project = new ProjectUtils.Project(ProjectName);
diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspacesNetCore.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspacesNetCore.cs
index 19c2a17ea77ee..b516cb97d23e2 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspacesNetCore.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspacesNetCore.cs
@@ -49,7 +49,9 @@ public override void MetadataReference()
             // https://github.com/dotnet/roslyn/issues/34264
             VisualStudio.Workspace.WaitForAllAsyncOperations(Helper.HangMitigatingTimeout);
             VisualStudio.SolutionExplorer.OpenFile(project, "Class1.cs");
-            PackageReference();
+            var referenceAssemblies = new ProjectUtils.PackageReference("Microsoft.NETFramework.ReferenceAssemblies.net461", "1.0.2");
+            VisualStudio.SolutionExplorer.AddPackageReference(project, referenceAssemblies);
+            VisualStudio.SolutionExplorer.RestoreNuGetPackages(project);
             base.MetadataReference();
         }
 

From db849cacd1fb227b746f759ee2c98fd771e3f7c9 Mon Sep 17 00:00:00 2001
From: Shen Chen <cos_ifne@hotmail.com>
Date: Wed, 5 Jan 2022 18:33:22 -0800
Subject: [PATCH 254/444] Set the default value of Combine With Indicator
 Margin to false

---
 src/EditorFeatures/Core/Shared/Options/FeatureOnOffOptions.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/EditorFeatures/Core/Shared/Options/FeatureOnOffOptions.cs b/src/EditorFeatures/Core/Shared/Options/FeatureOnOffOptions.cs
index 1b83726ad86fc..d85f1a40347b4 100644
--- a/src/EditorFeatures/Core/Shared/Options/FeatureOnOffOptions.cs
+++ b/src/EditorFeatures/Core/Shared/Options/FeatureOnOffOptions.cs
@@ -109,7 +109,7 @@ public FeatureOnOffOptions()
             new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.ShowInheritanceMargin"));
 
         public static readonly Option2<bool> InheritanceMarginCombinedWithIndicatorMargin = new(
-            FeatureName, "InheritanceMarginCombinedWithIndicatorMargin", defaultValue: true,
+            FeatureName, "InheritanceMarginCombinedWithIndicatorMargin", defaultValue: false,
             new RoamingProfileStorageLocation("TextEditor.InheritanceMarginCombinedWithIndicatorMargin"));
 
         public static readonly Option2<bool> AutomaticallyCompleteStatementOnSemicolon = new(

From 926ef575c9f323555419beb5db2a606ce6a3c098 Mon Sep 17 00:00:00 2001
From: Fred Silberberg <frsilb@microsoft.com>
Date: Wed, 5 Jan 2022 18:39:47 -0800
Subject: [PATCH 255/444] Correctly handle null array constants from source and
 metadata (#58604)

Fixes https://github.com/dotnet/roslyn/issues/58598. Fixes https://github.com/dotnet/roslyn/issues/58025. Interpolated string handlers were presuming there would never be a null array in source, and we had a general bug with our string array cracking code that assumed arrays from metadata would also never be null.
---
 .../Source/SourceComplexParameterSymbol.cs    |  8 ++
 .../Semantic/Semantics/InterpolationTests.cs  | 75 ++++++++++++++++++-
 .../Semantics/NullableReferenceTypesTests.cs  | 44 +++++++++++
 .../Core/Portable/MetadataReader/PEModule.cs  | 36 +++++++++
 4 files changed, 162 insertions(+), 1 deletion(-)

diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceComplexParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceComplexParameterSymbol.cs
index ad07645faa928..832210b4ea495 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceComplexParameterSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceComplexParameterSymbol.cs
@@ -1197,6 +1197,14 @@ private void DecodeInterpolatedStringHandlerArgumentAttribute(ref DecodeWellKnow
             }
             else if (attributeIndex == 1)
             {
+                if (constructorArgument.IsNull)
+                {
+                    setInterpolatedStringHandlerAttributeError(ref arguments);
+                    // null is not a valid parameter name. To get access to the receiver of an instance method, use the empty string as the parameter name.
+                    diagnostics.Add(ErrorCode.ERR_NullInvalidInterpolatedStringHandlerArgumentName, arguments.AttributeSyntaxOpt!.Location);
+                    return;
+                }
+
                 bool hadError = false;
                 parameters = ArrayBuilder<ParameterSymbol?>.GetInstance(constructorArgument.Values.Length);
                 var ordinalsBuilder = ArrayBuilder<int>.GetInstance(constructorArgument.Values.Length);
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/InterpolationTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/InterpolationTests.cs
index a4828a4c4ca28..06198ad7f6904 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/InterpolationTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/InterpolationTests.cs
@@ -6819,7 +6819,7 @@ End Structure
         [Theory]
         [InlineData(@"$""""")]
         [InlineData(@"$"""" + $""""")]
-        public void InterpolatedStringHandlerArgumentAttributeError_NullConstant(string expression)
+        public void InterpolatedStringHandlerArgumentAttributeError_NullConstant_01(string expression)
         {
             var code = @"
 using System.Runtime.CompilerServices;
@@ -6851,6 +6851,39 @@ public static void M(int i, [InterpolatedStringHandlerArgumentAttribute(new stri
             Assert.True(cParam.HasInterpolatedStringHandlerArgumentError);
         }
 
+        [Fact, WorkItem(58025, "https://github.com/dotnet/roslyn/issues/58025")]
+        public void InterpolatedStringHandlerArgumentAttributeError_NullConstant_02()
+        {
+            var code = @"
+using System.Runtime.CompilerServices;
+
+C.M(1, $"""");
+
+class C
+{
+    public static void M(int i, [InterpolatedStringHandlerArgumentAttribute((string[])null)] CustomHandler c) {}
+}
+";
+
+            var handler = GetInterpolatedStringCustomHandlerType("CustomHandler", "struct", useBoolReturns: true);
+
+            var comp = CreateCompilation(new[] { code, InterpolatedStringHandlerArgumentAttribute, handler });
+            comp.VerifyDiagnostics(
+                // (4,8): error CS8949: The InterpolatedStringHandlerArgumentAttribute applied to parameter 'CustomHandler' is malformed and cannot be interpreted. Construct an instance of 'CustomHandler' manually.
+                // C.M(1, $"");
+                Diagnostic(ErrorCode.ERR_InterpolatedStringHandlerArgumentAttributeMalformed, @"$""""").WithArguments("CustomHandler", "CustomHandler").WithLocation(4, 8),
+                // (8,34): error CS8943: null is not a valid parameter name. To get access to the receiver of an instance method, use the empty string as the parameter name.
+                //     public static void M(int i, [InterpolatedStringHandlerArgumentAttribute((string[])null)] CustomHandler c) {}
+                Diagnostic(ErrorCode.ERR_NullInvalidInterpolatedStringHandlerArgumentName, "InterpolatedStringHandlerArgumentAttribute((string[])null)").WithLocation(8, 34)
+            );
+
+            var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single();
+            AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute",
+                           cParam.GetAttributes().Single().AttributeClass.ToTestDisplayString());
+            Assert.Empty(cParam.InterpolatedStringHandlerArgumentIndexes);
+            Assert.True(cParam.HasInterpolatedStringHandlerArgumentError);
+        }
+
         [Fact]
         public void InterpolatedStringHandlerArgumentAttributeError_NullConstant_FromMetadata_01()
         {
@@ -6971,6 +7004,46 @@ End Structure
             Assert.True(cParam.HasInterpolatedStringHandlerArgumentError);
         }
 
+        [Fact]
+        public void InterpolatedStringHandlerArgumentAttributeError_NullConstant_FromMetadata_04()
+        {
+            var vbCode = @"
+Imports System.Runtime.CompilerServices
+Public Class C
+    Public Shared Sub M(i As Integer, <InterpolatedStringHandlerArgument(DirectCast(Nothing, String()))> c As CustomHandler)
+    End Sub
+End Class
+<InterpolatedStringHandler>
+Public Structure CustomHandler
+End Structure
+";
+
+            var vbComp = CreateVisualBasicCompilation(new[] { vbCode, InterpolatedStringHandlerAttributesVB });
+            vbComp.VerifyDiagnostics();
+
+            var comp = CreateCompilation(@"C.M(1, $"""");", references: new[] { vbComp.EmitToImageReference() });
+            comp.VerifyEmitDiagnostics(
+                // (1,8): error CS8949: The InterpolatedStringHandlerArgumentAttribute applied to parameter 'CustomHandler' is malformed and cannot be interpreted. Construct an instance of 'CustomHandler' manually.
+                // C.M(1, $"");
+                Diagnostic(ErrorCode.ERR_InterpolatedStringHandlerArgumentAttributeMalformed, @"$""""").WithArguments("CustomHandler", "CustomHandler").WithLocation(1, 8),
+                // (1,8): error CS1729: 'CustomHandler' does not contain a constructor that takes 2 arguments
+                // C.M(1, $"");
+                Diagnostic(ErrorCode.ERR_BadCtorArgCount, @"$""""").WithArguments("CustomHandler", "2").WithLocation(1, 8),
+                // (1,8): error CS1729: 'CustomHandler' does not contain a constructor that takes 3 arguments
+                // C.M(1, $"");
+                Diagnostic(ErrorCode.ERR_BadCtorArgCount, @"$""""").WithArguments("CustomHandler", "3").WithLocation(1, 8)
+            );
+
+            var customHandler = comp.GetTypeByMetadataName("CustomHandler");
+            Assert.True(customHandler.IsInterpolatedStringHandlerType);
+
+            var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single();
+            AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute",
+                           cParam.GetAttributes().Single().AttributeClass.ToTestDisplayString());
+            Assert.Empty(cParam.InterpolatedStringHandlerArgumentIndexes);
+            Assert.True(cParam.HasInterpolatedStringHandlerArgumentError);
+        }
+
         [Theory]
         [InlineData(@"$""""")]
         [InlineData(@"$"""" + $""""")]
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
index a2ca0b64023fd..26d12949e5fcf 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
@@ -20417,6 +20417,50 @@ public C()
                 );
         }
 
+        [Fact, WorkItem(58598, "https://github.com/dotnet/roslyn/issues/58598")]
+        public void MemberNotNull_NullConstant()
+        {
+            var c = CreateNullableCompilation(new[] { @"
+using System.Diagnostics.CodeAnalysis;
+public class C
+{
+    [MemberNotNull((string[]?)null)]
+    public void Init() => throw null!;
+}
+", MemberNotNullAttributeDefinition }, parseOptions: TestOptions.Regular9);
+
+            CompileAndVerify(c, symbolValidator: module =>
+            {
+                var c = module.ContainingAssembly.GetTypeByMetadataName("C");
+                var init = c.GetMember<MethodSymbol>("Init");
+                Assert.Empty(init.NotNullMembers);
+                Assert.Empty(init.NotNullWhenFalseMembers);
+                Assert.Empty(init.NotNullWhenTrueMembers);
+            });
+        }
+
+        [Fact, WorkItem(58598, "https://github.com/dotnet/roslyn/issues/58598")]
+        public void MemberNotNullWhen_NullConstant()
+        {
+            var c = CreateNullableCompilation(new[] { @"
+using System.Diagnostics.CodeAnalysis;
+public class C
+{
+    [MemberNotNullWhen(true, (string[]?)null)]
+    public bool Init() => throw null!;
+}
+", MemberNotNullWhenAttributeDefinition }, parseOptions: TestOptions.Regular9);
+
+            CompileAndVerify(c, symbolValidator: module =>
+            {
+                var c = module.ContainingAssembly.GetTypeByMetadataName("C");
+                var init = c.GetMember<MethodSymbol>("Init");
+                Assert.Empty(init.NotNullMembers);
+                Assert.Empty(init.NotNullWhenFalseMembers);
+                Assert.Empty(init.NotNullWhenTrueMembers);
+            });
+        }
+
         [Fact]
         public void MemberNotNull_NullValue()
         {
diff --git a/src/Compilers/Core/Portable/MetadataReader/PEModule.cs b/src/Compilers/Core/Portable/MetadataReader/PEModule.cs
index b4252161e3dbe..a4704092eb521 100644
--- a/src/Compilers/Core/Portable/MetadataReader/PEModule.cs
+++ b/src/Compilers/Core/Portable/MetadataReader/PEModule.cs
@@ -1209,6 +1209,7 @@ internal ObsoleteAttributeData TryGetDeprecatedOrExperimentalOrObsoleteAttribute
             }
             else if (TryExtractStringArrayValueFromAttribute(targetAttribute.Handle, out var paramNames))
             {
+                Debug.Assert(!paramNames.IsDefault);
                 return (paramNames.NullToEmpty(), true);
             }
 
@@ -1903,7 +1904,15 @@ internal static bool CrackStringArrayInAttributeValue(out ImmutableArray<string?
             if (sig.RemainingBytes >= 4)
             {
                 uint arrayLen = sig.ReadUInt32();
+
+                if (IsArrayNull(arrayLen))
+                {
+                    value = default;
+                    return false;
+                }
+
                 var stringArray = new string?[arrayLen];
+
                 for (int i = 0; i < arrayLen; i++)
                 {
                     if (!CrackStringInAttributeValue(out stringArray[i], ref sig))
@@ -1921,6 +1930,19 @@ internal static bool CrackStringArrayInAttributeValue(out ImmutableArray<string?
             return false;
         }
 
+        private static bool IsArrayNull(uint length)
+        {
+            // Null arrays are represented in metadata by a length of 0xFFFF_FFFF. See ECMA 335 II.23.3.
+            const uint NullArray = 0xFFFF_FFFF;
+
+            if (length == NullArray)
+            {
+                return true;
+            }
+
+            return false;
+        }
+
         internal static bool CrackBoolAndStringArrayInAttributeValue(out BoolAndStringArrayData value, ref BlobReader sig)
         {
             if (CrackBooleanInAttributeValue(out bool sense, ref sig) &&
@@ -2035,6 +2057,13 @@ internal static bool CrackBoolArrayInAttributeValue(out ImmutableArray<bool> val
             if (sig.RemainingBytes >= 4)
             {
                 uint arrayLen = sig.ReadUInt32();
+
+                if (IsArrayNull(arrayLen))
+                {
+                    value = default;
+                    return false;
+                }
+
                 if (sig.RemainingBytes >= arrayLen)
                 {
                     var boolArrayBuilder = ArrayBuilder<bool>.GetInstance((int)arrayLen);
@@ -2057,6 +2086,13 @@ internal static bool CrackByteArrayInAttributeValue(out ImmutableArray<byte> val
             if (sig.RemainingBytes >= 4)
             {
                 uint arrayLen = sig.ReadUInt32();
+
+                if (IsArrayNull(arrayLen))
+                {
+                    value = default;
+                    return false;
+                }
+
                 if (sig.RemainingBytes >= arrayLen)
                 {
                     var byteArrayBuilder = ArrayBuilder<byte>.GetInstance((int)arrayLen);

From eb17a3f57546ebe9fb4288019db02c86503aa887 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Wed, 5 Jan 2022 22:23:57 -0800
Subject: [PATCH 256/444] Reduce the number of duplicate ProjectId instances
 found in OOP

---
 .../Serialization/MessagePackFormatters.cs     | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/src/Workspaces/Remote/Core/Serialization/MessagePackFormatters.cs b/src/Workspaces/Remote/Core/Serialization/MessagePackFormatters.cs
index 50ce5626b132f..18dc308593fac 100644
--- a/src/Workspaces/Remote/Core/Serialization/MessagePackFormatters.cs
+++ b/src/Workspaces/Remote/Core/Serialization/MessagePackFormatters.cs
@@ -82,6 +82,16 @@ internal sealed class ProjectIdFormatter : IMessagePackFormatter<ProjectId?>
         {
             public static readonly ProjectIdFormatter Instance = new ProjectIdFormatter();
 
+            /// <summary>
+            /// Keep a copy of the most recent project ID to avoid duplicate instances when many consecutive IDs
+            /// reference the same project.
+            /// </summary>
+            /// <remarks>
+            /// Synchronization is not required for this field, since it's only intended to be an opportunistic (lossy)
+            /// cache.
+            /// </remarks>
+            private ProjectId? _previousProjectId;
+
             public ProjectId? Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
             {
                 try
@@ -95,7 +105,13 @@ internal sealed class ProjectIdFormatter : IMessagePackFormatter<ProjectId?>
                     var id = GuidFormatter.Instance.Deserialize(ref reader, options);
                     var debugName = reader.ReadString();
 
-                    return ProjectId.CreateFromSerialized(id, debugName);
+                    var previousId = _previousProjectId;
+                    if (previousId is not null && previousId.Id == id && previousId.DebugName == debugName)
+                        return previousId;
+
+                    var currentId = ProjectId.CreateFromSerialized(id, debugName);
+                    _previousProjectId = currentId;
+                    return currentId;
                 }
                 catch (Exception e) when (e is not MessagePackSerializationException)
                 {

From a9027f3d3bddcd77eb3c97bf0caba61335c08426 Mon Sep 17 00:00:00 2001
From: Jason Malinowski <jason.malinowski@microsoft.com>
Date: Thu, 6 Jan 2022 07:33:37 -0800
Subject: [PATCH 257/444] Remove workarounds for
 https://github.com/dotnet/roslyn/issues/29660 (#58659)

---
 .../Emit/ExpressionTrees/CodeGenExprLambda.vb | 254 +++++++++---------
 ...ysis.VisualBasic.Semantic.UnitTests.vbproj |   6 -
 2 files changed, 127 insertions(+), 133 deletions(-)

diff --git a/src/Compilers/VisualBasic/Test/Emit/ExpressionTrees/CodeGenExprLambda.vb b/src/Compilers/VisualBasic/Test/Emit/ExpressionTrees/CodeGenExprLambda.vb
index 7e48a23f3368d..cd520e863fe3d 100644
--- a/src/Compilers/VisualBasic/Test/Emit/ExpressionTrees/CodeGenExprLambda.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/ExpressionTrees/CodeGenExprLambda.vb
@@ -18,7 +18,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests
 
 #Region "Literals"
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub Literals()
 
             Dim source = <compilation>
@@ -80,35 +80,35 @@ Lambda(
 
 #Region "Unary Operations"
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TestUnaryOperator_Unchecked_PlusMinus()
             TestUnaryOperator_AllTypes_PlusMinus(False, result:=ExpTreeTestResources.UncheckedUnaryPlusMinusNot)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TestUnaryOperator_Checked_PlusMinusNot()
             TestUnaryOperator_AllTypes_PlusMinus(True, result:=ExpTreeTestResources.CheckedUnaryPlusMinusNot)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub UserDefinedIsTrueIsFalse_Unchecked()
             Dim file = <file name="expr.vb"><%= ExpTreeTestResources.TestUnary_UDO_IsTrueIsFalse %></file>
             TestExpressionTrees(file, ExpTreeTestResources.CheckedAndUncheckedIsTrueIsFalse, checked:=False)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub UserDefinedIsTrueIsFalse_Checked()
             Dim file = <file name="expr.vb"><%= ExpTreeTestResources.TestUnary_UDO_IsTrueIsFalse %></file>
             TestExpressionTrees(file, ExpTreeTestResources.CheckedAndUncheckedIsTrueIsFalse, checked:=True)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub UserDefinedPlusMinusNot_Unchecked()
             Dim file = <file name="expr.vb"><%= ExpTreeTestResources.TestUnary_UDO_PlusMinusNot %></file>
             TestExpressionTrees(file, ExpTreeTestResources.CheckedAndUncheckedUdoUnaryPlusMinusNot1, checked:=False)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub UserDefinedPlusMinusNot_Checked()
             Dim file = <file name="expr.vb"><%= ExpTreeTestResources.TestUnary_UDO_PlusMinusNot %></file>
             TestExpressionTrees(file, ExpTreeTestResources.CheckedAndUncheckedUdoUnaryPlusMinusNot1, checked:=True)
@@ -233,72 +233,72 @@ Lambda(
 
 #Region "Binary Operations"
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TestBinaryOperator_Unchecked_Arithmetic()
             TestBinaryOperator_AllTypes_NumericOperations(False, result:=ExpTreeTestResources.UncheckedArithmeticBinaryOperators)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TestBinaryOperator_Checked_Arithmetic()
             TestBinaryOperator_AllTypes_NumericOperations(True, result:=ExpTreeTestResources.CheckedArithmeticBinaryOperators)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TestBinaryOperator_Unchecked_AndOrXor()
             TestBinaryOperator_AllTypes_AndOrXor(False, result:=ExpTreeTestResources.UncheckedAndOrXor)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TestBinaryOperator_Checked_AndOrXor()
             TestBinaryOperator_AllTypes_AndOrXor(True, result:=ExpTreeTestResources.CheckedAndOrXor)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TestBinaryOperator_Unchecked_ShortCircuit()
             TestBinaryOperator_AllTypes_ShortCircuit(False, result:=ExpTreeTestResources.UncheckedShortCircuit)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TestBinaryOperator_Checked_ShortCircuit()
             TestBinaryOperator_AllTypes_ShortCircuit(True, result:=ExpTreeTestResources.CheckedShortCircuit)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TestBinaryOperator_Unchecked_Comparisons()
             TestBinaryOperator_AllTypes_Comparisons(False, result:=ExpTreeTestResources.UncheckedComparisonOperators)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TestBinaryOperator_Checked_Comparisons()
             TestBinaryOperator_AllTypes_Comparisons(True, result:=ExpTreeTestResources.CheckedComparisonOperators)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TestBinaryOperator_Unchecked_IsIsNot()
             TestBinaryOperator_AllTypes_IsIsNot(False, result:=ExpTreeTestResources.CheckedAndUncheckedIsIsNot)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TestBinaryOperator_Checked_IsIsNot()
             TestBinaryOperator_AllTypes_IsIsNot(True, result:=ExpTreeTestResources.CheckedAndUncheckedIsIsNot)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TestBinaryOperator_Unchecked_IsIsNot_Nothing()
             TestUnaryOperator_AllTypes_IsIsNot(False, result:=ExpTreeTestResources.CheckedAndUncheckedIsIsNotNothing)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TestBinaryOperator_Checked_IsIsNot_Nothing()
             TestUnaryOperator_AllTypes_IsIsNot(True, result:=ExpTreeTestResources.CheckedAndUncheckedIsIsNotNothing)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TestBinaryOperator_Unchecked_Concatenate()
             TestBinaryOperator_ConcatenatePlus(False, result:=ExpTreeTestResources.UncheckedConcatenate)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TestBinaryOperator_Checked_Concatenate()
             TestBinaryOperator_ConcatenatePlus(True, result:=ExpTreeTestResources.CheckedConcatenate)
         End Sub
@@ -313,22 +313,22 @@ Lambda(
             TestBinaryOperator_Like(True, result:=ExpTreeTestResources.CheckedLike)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TestBinaryOperator_Unchecked_WithDate()
             TestBinaryOperator_DateAsOperand(False, result:=ExpTreeTestResources.CheckedAndUncheckedWithDate)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TestBinaryOperator_Checked_WithDate()
             TestBinaryOperator_DateAsOperand(True, result:=ExpTreeTestResources.CheckedAndUncheckedWithDate)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TestBinaryOperator_Unchecked_UserDefinedBinaryOperator()
             TestBinaryOperator_UserDefinedBinaryOperator(False, result:=ExpTreeTestResources.UncheckedUserDefinedBinaryOperators)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TestBinaryOperator_Checked_UserDefinedBinaryOperator()
             TestBinaryOperator_UserDefinedBinaryOperator(True, result:=ExpTreeTestResources.CheckedUserDefinedBinaryOperators)
         End Sub
@@ -607,17 +607,17 @@ Lambda(
 
 #Region "Conversions"
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub NothingLiteralConversions_Unchecked()
             TestConversion_NothingLiteral(False, ExpTreeTestResources.CheckedAndUncheckedNothingConversions)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub NothingLiteralConversions_Checked()
             TestConversion_NothingLiteral(True, ExpTreeTestResources.CheckedAndUncheckedNothingConversions)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub NothingLiteralConversionsDate_CheckedUnchecked()
 
             Dim source = <compilation>
@@ -746,69 +746,69 @@ Lambda(
 
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TypeParameterConversions_Unchecked()
             TestConversion_TypeParameters(False, ExpTreeTestResources.CheckedAndUncheckedTypeParameters)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TypeParameterConversions_Checked()
             TestConversion_TypeParameters(True, ExpTreeTestResources.CheckedAndUncheckedTypeParameters)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TypeConversions_Unchecked_Std_DirectTrySpecialized()
             TestConversion_TypeMatrix_Standard_DirectTrySpecialized(False, ExpTreeTestResources.UncheckedDirectTrySpecificConversions)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TypeConversions_Checked_Std_DirectTrySpecialized()
             TestConversion_TypeMatrix_Standard_DirectTrySpecialized(True, ExpTreeTestResources.CheckedDirectTrySpecificConversions)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TypeConversions_Unchecked_Std_ImplicitAndCType()
             TestConversion_TypeMatrix_Standard_ImplicitAndCType(False, ExpTreeTestResources.UncheckedCTypeAndImplicitConversionsEven, True)
             TestConversion_TypeMatrix_Standard_ImplicitAndCType(False, ExpTreeTestResources.UncheckedCTypeAndImplicitConversionsOdd, False)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TypeConversions_Checked_Std_ImplicitAndCType()
             TestConversion_TypeMatrix_Standard_ImplicitAndCType(True, ExpTreeTestResources.CheckedCTypeAndImplicitConversionsEven, True)
             TestConversion_TypeMatrix_Standard_ImplicitAndCType(True, ExpTreeTestResources.CheckedCTypeAndImplicitConversionsOdd, False)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TypeConversions_Unchecked_UserTypes()
             TestConversion_TypeMatrix_UserTypes(False, ExpTreeTestResources.CheckedAndUncheckedUserTypeConversions)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TypeConversions_Checked_UserTypes()
             TestConversion_TypeMatrix_UserTypes(True, ExpTreeTestResources.CheckedAndUncheckedUserTypeConversions)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TypeConversions_Unchecked_Narrowing_UserDefinedConversions()
             TestConversion_UserDefinedTypes_Narrowing(False, ExpTreeTestResources.CheckedAndUncheckedNarrowingUDC)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TypeConversions_Checked_Narrowing_UserDefinedConversions()
             TestConversion_UserDefinedTypes_Narrowing(True, ExpTreeTestResources.CheckedAndUncheckedNarrowingUDC)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TypeConversions_Unchecked_Widening_UserDefinedConversions()
             TestConversion_UserDefinedTypes_Widening(False, ExpTreeTestResources.CheckedAndUncheckedWideningUDC)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TypeConversions_Checked_Widening_UserDefinedConversions()
             TestConversion_UserDefinedTypes_Widening(True, ExpTreeTestResources.CheckedAndUncheckedWideningUDC)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExpressionTrees_UDC_NullableAndConversion()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -1994,7 +1994,7 @@ Public Enum E_Long As Long : Dummy : End Enum
 
 #Region "Lambdas"
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         <WorkItem(530883, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/530883")>
         Public Sub ExpressionTreeParameterWithLambdaArgumentAndTypeInference()
             Dim source = <compilation>
@@ -2017,7 +2017,7 @@ End Module
             CompileAndVerify(source, references:={Net40.SystemCore}).VerifyDiagnostics()
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         <WorkItem(577271, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/577271")>
         Public Sub Bug577271()
             Dim file = <file name="expr.vb"><![CDATA[
@@ -2045,7 +2045,7 @@ BC36675: Statement lambdas cannot be converted to expression trees.
         End Sub
 
         <WorkItem(577272, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/577272")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub Bug577272()
             Dim file = <file name="expr.vb"><![CDATA[
 Imports System.Linq.Expressions
@@ -2099,7 +2099,7 @@ Lambda(
 ]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub LambdaConversion1()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -2148,7 +2148,7 @@ Lambda(
 ]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub LambdaConversion2()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -2191,7 +2191,7 @@ Lambda(
 ]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub LambdaConversion3()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -2283,7 +2283,7 @@ Lambda(
 ]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub LambdaConversion4()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -2351,7 +2351,7 @@ Lambda(
 ]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub LambdaConversion5()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -2456,7 +2456,7 @@ Lambda(
 ]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub LambdaConversion5_45()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -2556,7 +2556,7 @@ Lambda(
 ]]>, latestReferences:=True)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub LambdaConversion6()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -2713,7 +2713,7 @@ Lambda(
 ]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub LambdaConversion7()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -2812,7 +2812,7 @@ Lambda(
 ]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub Relaxation01()
             Dim file = <file name="expr.vb"><![CDATA[
 Imports System
@@ -2909,7 +2909,7 @@ c => Process(ConvertChecked(c))
 ]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub Relaxation03()
             Dim file = <file name="expr.vb"><![CDATA[
 Imports System
@@ -2957,7 +2957,7 @@ c => Process()
 ]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub Relaxation04()
             Dim file = <file name="expr.vb"><![CDATA[
 Imports System
@@ -3006,7 +3006,7 @@ a0 => Invoke(() => Process())
 ]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub Relaxation05()
             Dim file = <file name="expr.vb"><![CDATA[
 
@@ -3055,7 +3055,7 @@ t => Process(tt => Process(null))
 ]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub Relaxation05ET()
             Dim file = <file name="expr.vb"><![CDATA[
 
@@ -3104,7 +3104,7 @@ t => Process(tt => Process(null))
 ]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub Relaxation06()
             Dim file = <file name="expr.vb"><![CDATA[
 
@@ -3158,7 +3158,7 @@ t => Process(tt => Process(null))
 ]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub Relaxation07()
             Dim file = <file name="expr.vb"><![CDATA[
 
@@ -3212,7 +3212,7 @@ t => Process(tt => Process(null))
 ]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub Relaxation08()
             Dim file = <file name="expr.vb"><![CDATA[
 Imports System
@@ -3260,7 +3260,7 @@ End Class
 
 #Region "Xml Literals"
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub XmlLiteralsInExprLambda01()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -3318,7 +3318,7 @@ End Module
             TestExpressionTrees(file, ExpTreeTestResources.XmlLiteralsInExprLambda01_Result, addXmlReferences:=True)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub XmlLiteralsInExprLambda02()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off
@@ -3385,7 +3385,7 @@ End Module
             TestExpressionTrees(file, ExpTreeTestResources.XmlLiteralsInExprLambda02_Result, addXmlReferences:=True)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub XmlLiteralsInExprLambda03()
             Dim file = <file name="expr.vb"><![CDATA[
 imports System
@@ -3439,7 +3439,7 @@ End Module
         End Sub
 
         <WorkItem(545738, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545738")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub Bug_14377b()
             ' Expression Trees: Xml literals NYI
             Dim file = <file name="a.vb"><![CDATA[
@@ -3501,7 +3501,7 @@ Lambda(
 
 #Region "Miscellaneous"
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExprTree_LegacyTests01()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -3665,7 +3665,7 @@ Lambda(
 )]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExprTree_LegacyTests02_v40()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -3710,7 +3710,7 @@ End Module
             TestExpressionTrees(file, ExpTreeTestResources.ExprTree_LegacyTests02_v40_Result)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExprTree_LegacyTests02_v45()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -3752,7 +3752,7 @@ End Module
             TestExpressionTrees(file, ExpTreeTestResources.ExprTree_LegacyTests02_v45_Result, latestReferences:=True)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExprTree_LegacyTests03()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -4033,7 +4033,7 @@ Lambda(
 )]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExprTree_LegacyTests04()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -4451,7 +4451,7 @@ Lambda(
             Diagnostic(ERRID.WRN_DefAsgUseNullRef, "t1").WithArguments("t1")})
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExprTree_LegacyTests05()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -4865,7 +4865,7 @@ Lambda(
 )]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExprTree_LegacyTests06()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -4960,7 +4960,7 @@ Lambda(
         End Sub
 
         <WorkItem(651996, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/651996")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExprTree_LegacyTests06_IL()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -5143,7 +5143,7 @@ End Module
 ]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExprTree_LegacyTests07()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -5219,7 +5219,7 @@ End Module
             TestExpressionTrees(file, ExpTreeTestResources.ExprTree_LegacyTests07_Result)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExprTree_LegacyTests07_Decimal()
 
             Dim file = <file name="expr.vb"><![CDATA[
@@ -5287,7 +5287,7 @@ End Module
 
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExprTree_LegacyTests08()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -5391,7 +5391,7 @@ End Module
             TestExpressionTrees(file, ExpTreeTestResources.ExprTree_LegacyTests08_Result)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExprTree_LegacyTests09()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -5458,7 +5458,7 @@ End Module
             TestExpressionTrees(file, ExpTreeTestResources.ExprTree_LegacyTests09_Result)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExprTree_LegacyTests09_Decimal()
 
             Dim file = <file name="expr.vb"><![CDATA[
@@ -5592,7 +5592,7 @@ Lambda(
 
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExprTree_LegacyTests10()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off
@@ -5649,7 +5649,7 @@ End Module
             TestExpressionTrees(file, ExpTreeTestResources.ExprTree_LegacyTests10_Result)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExprTreeLiftedUserDefinedConversionsWithNullableResult()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -5883,7 +5883,7 @@ Lambda(
 )]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExprTreeMiscellaneous_A()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -5928,7 +5928,7 @@ End Class
             TestExpressionTrees(file, ExpTreeTestResources.CheckedMiscellaneousA)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExprTreeNothingIsNothing()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -5966,7 +5966,7 @@ Lambda(
 ]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub CheckedCoalesceWithNullableBoolean()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -6006,7 +6006,7 @@ End Module
             TestExpressionTrees(file, ExpTreeTestResources.CheckedCoalesceWithNullableBoolean)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExprTreeWithCollectionInitializer()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -6049,7 +6049,7 @@ End Module
             TestExpressionTrees(file, ExpTreeTestResources.CheckedCollectionInitializers)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ArrayCreationAndInitialization()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -6069,7 +6069,7 @@ End Module
             TestExpressionTrees(file, ExpTreeTestResources.CheckedArrayInitializers)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub SimpleObjectCreation()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -6160,7 +6160,7 @@ Lambda(
 ]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ObjectCreationInitializers()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -6206,7 +6206,7 @@ End Module
             TestExpressionTrees(file, ExpTreeTestResources.CheckedObjectInitializers)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ObjectCreationInitializers_BC36534a()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -6249,7 +6249,7 @@ BC36534: Expression cannot be converted into an expression tree.
 </errors>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ObjectCreationInitializers_BC36534b()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -6292,7 +6292,7 @@ BC36534: Expression cannot be converted into an expression tree.
 </errors>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub AnonymousObjectCreationExpression()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -6363,7 +6363,7 @@ Lambda(
 ]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub CheckedCoalesceWithUserDefinedConversion()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -6404,7 +6404,7 @@ End Module
             TestExpressionTrees(file, ExpTreeTestResources.CheckedCoalesceWithUserDefinedConversions)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub CheckedExpressionInCoalesceWitSideEffects()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -6475,7 +6475,7 @@ Lambda(
         End Sub
 
         <WorkItem(651996, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/651996")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExprTreeIL()
             CompileAndVerify(
 <compilation>
@@ -6527,7 +6527,7 @@ End Module
 }]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub MissingHelpers()
             Dim compilation = CreateCompilationWithMscorlib40AndVBRuntime(
 <compilation>
@@ -6582,7 +6582,7 @@ BC30456: 'AddChecked' is not a member of 'Expression'.
             End Using
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub LocalVariableAccess()
 
             Dim source = <compilation>
@@ -6635,7 +6635,7 @@ Lambda(
 )]]>).VerifyDiagnostics()
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub LocalVariableAccessInGeneric()
 
             Dim source = <compilation>
@@ -6687,7 +6687,7 @@ Lambda(
         End Sub
 
         <WorkItem(651996, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/651996")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub LocalVariableAccessIL()
             Dim c = CompileAndVerify(
 <compilation>
@@ -6743,7 +6743,7 @@ End Module
     ]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub TypeInference()
             Dim source = <compilation>
                              <%= _exprTesting %>
@@ -6777,7 +6777,7 @@ Infer C=System.Int32
 ]]>).VerifyDiagnostics()
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub QueryWhereSelect()
             Dim source = <compilation>
                              <%= _exprTesting %>
@@ -6816,7 +6816,7 @@ End Module
                  expectedOutput:=<![CDATA[Where Select]]>).VerifyDiagnostics()
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub QueryGroupBy()
             Dim source = <compilation>
                              <%= _exprTesting %>
@@ -6866,7 +6866,7 @@ End Module
                  expectedOutput:="GroupBy 1;Select;GroupBy 2;Select;").VerifyDiagnostics()
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub QueryGroupJoin()
             Dim source = <compilation>
                              <%= _exprTesting %>
@@ -6909,7 +6909,7 @@ End Module]]></file>
                  expectedOutput:="GroupJoin;").VerifyDiagnostics()
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub OverloadResolutionDisambiguation1()
             Dim source = <compilation>
                              <file name="a.vb"><![CDATA[
@@ -6992,7 +6992,7 @@ End Module
                  expectedOutput:=<![CDATA[A1 B2 C1 D2 E1 F2]]>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub OverloadResolutionDisambiguation2()
             Dim source = <compilation>
                              <file name="a.vb"><![CDATA[
@@ -7061,7 +7061,7 @@ End Module
         End Sub
 
         <WorkItem(531513, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/531513")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub Bug_18234()
             Dim file = <file name="a.vb"><![CDATA[
 Option Strict Off 
@@ -7157,7 +7157,7 @@ Lambda(
         End Sub
 
         <WorkItem(545738, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545738")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub Bug_14377a()
             Dim source = <compilation>
                              <file name="a.vb"><![CDATA[
@@ -7179,7 +7179,7 @@ End Module
         End Sub
 
         <WorkItem(547151, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/547151")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub Bug_18156()
             Dim file = <file name="expr.vb"><![CDATA[
 Imports System
@@ -7228,7 +7228,7 @@ End Module
         End Sub
 
         <WorkItem(957927, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/957927")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub Bug957927()
             Dim source = <compilation>
                              <file name="a.vb"><![CDATA[
@@ -7259,7 +7259,7 @@ end class
 
 
         <WorkItem(3906, "https://github.com/dotnet/roslyn/issues/3906")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub GenericField01()
             Dim source = <compilation>
                              <file name="a.vb"><![CDATA[
@@ -7297,7 +7297,7 @@ End Class
                  expectedOutput:="").VerifyDiagnostics()
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExpressionTrees_MyBaseMyClass()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -7628,7 +7628,7 @@ Lambda(
 
 #Region "Errors"
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ArrayCreationAndInitialization_BC36603()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -7651,7 +7651,7 @@ BC36603: Multi-dimensional array cannot be converted to an expression tree.
         End Sub
 
         <WorkItem(531526, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/531526")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ByRefParamsInExpressionLambdas_BC36538()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -7698,7 +7698,7 @@ BC36538: References to 'ByRef' parameters cannot be converted to an expression t
 </errors>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub AnonymousObjectCreationExpression_BC36548()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -7724,7 +7724,7 @@ BC36548: Cannot convert anonymous type to an expression tree because a property
 </errors>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub MultiStatementLambda_BC36675a()
             Dim file = <file name="expr.vb"><![CDATA[
 Imports System
@@ -7756,7 +7756,7 @@ BC36675: Statement lambdas cannot be converted to expression trees.
 </errors>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub MultiStatementLambda_BC36675b()
             Dim file = <file name="expr.vb"><![CDATA[
 Imports System
@@ -7781,7 +7781,7 @@ BC36675: Statement lambdas cannot be converted to expression trees.
         End Sub
 
         <WorkItem(545804, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545804")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub Bug_14469()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -7815,7 +7815,7 @@ BC36675: Statement lambdas cannot be converted to expression trees.
         End Sub
 
         <WorkItem(531420, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/531420")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExprTreeLiftedUserDefinedOperatorsWithNullableResult_Binary_BC36534()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -7858,7 +7858,7 @@ BC36534: Expression cannot be converted into an expression tree.
         End Sub
 
         <WorkItem(531423, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/531423")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExprTreeUserDefinedAndAlsoOrElseWithNullableResult_BC36534()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -7904,7 +7904,7 @@ BC36534: Expression cannot be converted into an expression tree.
         End Sub
 
         <WorkItem(531424, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/531424")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExprTreeUserDefinedUnaryWithNullableResult_BC36534()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -7940,7 +7940,7 @@ BC36534: Expression cannot be converted into an expression tree.
 </errors>)
         End Sub
 
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub ExprTree_LateBinding_BC36604()
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
@@ -7983,7 +7983,7 @@ BC36604: Late binding operations cannot be converted to an expression tree.
         End Sub
 
         <WorkItem(797996, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/797996")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub MissingMember_System_Type__GetTypeFromHandle()
             Dim compilation = CreateEmptyCompilation(
 <compilation>
@@ -8045,7 +8045,7 @@ BC35000: Requested operation is not available because the runtime library functi
         End Sub
 
         <WorkItem(797996, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/797996")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub MissingMember_System_Reflection_FieldInfo__GetFieldFromHandle()
             Dim compilation = CreateEmptyCompilation(
 <compilation>
@@ -8122,7 +8122,7 @@ BC35000: Requested operation is not available because the runtime library functi
         End Sub
 
         <WorkItem(797996, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/797996")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub MissingMember_System_Reflection_MethodBase__GetMethodFromHandle()
             Dim compilation = CreateEmptyCompilation(
 <compilation>
@@ -8362,7 +8362,7 @@ End Module
         End Sub
 
         <WorkItem(808651, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/808651")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub Bug808651()
 
             Dim source = <compilation>
@@ -8394,7 +8394,7 @@ End Module
         End Sub
 
         <WorkItem(1190, "https://github.com/dotnet/roslyn/issues/1190")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub CollectionInitializers()
 
             Dim source = <compilation>
@@ -8449,7 +8449,7 @@ e2 => () => new MyStack`1() {Void Add(Int32)(42)}
         End Sub
 
         <WorkItem(4524, "https://github.com/dotnet/roslyn/issues/4524")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub PropertyAssignment()
 
             Dim source = <compilation>
@@ -8516,7 +8516,7 @@ aa
         End Sub
 
         <WorkItem(4524, "https://github.com/dotnet/roslyn/issues/4524")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub PropertyAssignmentParameterized()
 
             Dim source = <compilation>
@@ -8593,7 +8593,7 @@ aa23
         End Sub
 
         <WorkItem(4524, "https://github.com/dotnet/roslyn/issues/4524")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub PropertyAssignmentCompound()
 
             Dim source = <compilation>
@@ -8658,7 +8658,7 @@ End Module
         End Sub
 
         <WorkItem(6416, "https://github.com/dotnet/roslyn/issues/6416")>
-        <ConditionalFact(GetType(WindowsOnly), Reason:="https://github.com/dotnet/roslyn/issues/29660")>
+        <Fact>
         Public Sub CapturedMe001()
 
             Dim source = <compilation>
diff --git a/src/Compilers/VisualBasic/Test/Semantic/Microsoft.CodeAnalysis.VisualBasic.Semantic.UnitTests.vbproj b/src/Compilers/VisualBasic/Test/Semantic/Microsoft.CodeAnalysis.VisualBasic.Semantic.UnitTests.vbproj
index 0e0dd34709836..6b3c5cba79e4b 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/Microsoft.CodeAnalysis.VisualBasic.Semantic.UnitTests.vbproj
+++ b/src/Compilers/VisualBasic/Test/Semantic/Microsoft.CodeAnalysis.VisualBasic.Semantic.UnitTests.vbproj
@@ -6,12 +6,6 @@
     <TargetFrameworks>net6.0;net472</TargetFrameworks>
     <RootNamespace></RootNamespace>
 
-    <!--
-      Disable running the tests on .NET Core while we investigate the core dump issue
-      https://github.com/dotnet/roslyn/issues/29660
-    -->
-    <SkipTests Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp' and '$(OS)' != 'Windows_NT'">true</SkipTests>
-
     <!--
       Skipped because we appear to be missing things necessary to compile vb.net.
       See https://github.com/mono/mono/issues/10679

From 3e4cc4cd39422b519a379ca1bb71e860687f77d0 Mon Sep 17 00:00:00 2001
From: Charles Stoner <10732005+cston@users.noreply.github.com>
Date: Thu, 6 Jan 2022 10:16:41 -0800
Subject: [PATCH 258/444] Do not synthesize a parameterless constructor for
 struct types; report error if struct has field initializers but no
 constructors (#58581)

---
 .../Compiler Breaking Changes - DotNet 7.md   |  19 +-
 .../Portable/Binder/Binder_Expressions.cs     |   2 +-
 .../CSharp/Portable/CSharpResources.resx      |   3 +
 .../CSharp/Portable/CodeGen/EmitExpression.cs |   4 +-
 .../Portable/Compiler/MethodCompiler.cs       |   6 +-
 .../Emitter/Model/AttributeDataAdapter.cs     |   2 +-
 .../Portable/Emitter/Model/PEModuleBuilder.cs |   2 +-
 .../Emitter/NoPia/EmbeddedTypesManager.cs     |   2 +-
 .../CSharp/Portable/Errors/ErrorCode.cs       |   1 +
 .../Portable/FlowAnalysis/FlowAnalysisPass.cs |   2 +-
 .../Portable/FlowAnalysis/NullableWalker.cs   |   2 +-
 .../ExpressionLambdaRewriter.cs               |   2 +-
 .../LocalRewriter_ObjectCreationExpression.cs |   2 +-
 .../Symbols/MemberSymbolExtensions.cs         |  29 +-
 .../Symbols/Metadata/PE/PENamedTypeSymbol.cs  |   4 +-
 .../Portable/Symbols/NamedTypeSymbol.cs       |  10 -
 .../Retargeting/RetargetingNamedTypeSymbol.cs |   2 -
 .../Symbols/Source/ParameterHelpers.cs        |   2 +-
 .../Source/SourceMemberContainerSymbol.cs     |   9 +-
 .../Portable/xlf/CSharpResources.cs.xlf       |   5 +
 .../Portable/xlf/CSharpResources.de.xlf       |   5 +
 .../Portable/xlf/CSharpResources.es.xlf       |   5 +
 .../Portable/xlf/CSharpResources.fr.xlf       |   5 +
 .../Portable/xlf/CSharpResources.it.xlf       |   5 +
 .../Portable/xlf/CSharpResources.ja.xlf       |   5 +
 .../Portable/xlf/CSharpResources.ko.xlf       |   5 +
 .../Portable/xlf/CSharpResources.pl.xlf       |   5 +
 .../Portable/xlf/CSharpResources.pt-BR.xlf    |   5 +
 .../Portable/xlf/CSharpResources.ru.xlf       |   5 +
 .../Portable/xlf/CSharpResources.tr.xlf       |   5 +
 .../Portable/xlf/CSharpResources.zh-Hans.xlf  |   5 +
 .../Portable/xlf/CSharpResources.zh-Hant.xlf  |   5 +
 .../AttributeTests_WellKnownAttributes.cs     |  48 ++-
 .../EditAndContinue/EditAndContinueTests.cs   |  20 +-
 .../CSharp/Test/Emit/Emit/NoPiaEmbedTypes.cs  |   4 +-
 .../FlowAnalysis/FlowDiagnosticTests.cs       |   7 +-
 .../Semantic/Semantics/InterpolationTests.cs  |  10 +-
 .../Semantics/NullableReferenceTypesTests.cs  |   9 +-
 .../Semantic/Semantics/RecordStructTests.cs   |  60 ++-
 .../Semantics/StructConstructorTests.cs       | 345 ++++++++++++------
 .../Test/Semantic/Semantics/StructsTests.cs   |  47 ++-
 .../Symbol/Symbols/Source/PropertyTests.cs    |  10 +-
 .../Test/Symbol/Symbols/SymbolErrorTests.cs   |  20 +-
 43 files changed, 542 insertions(+), 208 deletions(-)

diff --git a/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 7.md b/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 7.md
index 519234be1f64e..3239e1081ddcf 100644
--- a/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 7.md	
+++ b/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 7.md	
@@ -70,10 +70,19 @@ Those types can be used with implicit Index indexer and list patterns.
 5. Starting with Visual Studio 17.1, format specifiers in interpolated strings can not contain curly braces (either `{` or `}`). In previous versions `{{` was interpreted as an escaped `{` and `}}` was interpreted as an escaped `}` char in the format specifier. Now the first `}` char in a format specifier ends the interpolation, and any `{` char is an error.
 https://github.com/dotnet/roslyn/issues/5775
 
-```csharp
-using System;
+    ```csharp
+    using System;
+
+    Console.WriteLine($"{{{12:X}}}");
+
+    //prints now: "{C}" - not "{X}}"
+    ```
 
-Console.WriteLine($"{{{12:X}}}");
+6. Starting with Visual Studio 17.1, `struct` type declarations with field initializers must include an explicitly declared constructor.
 
-//prints now: "{C}" - not "{X}}"
-```
+    ```csharp
+    struct S
+    {
+        int X = 1; // error: struct with field initializers must include an explicitly declared constructor
+    }
+    ```
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
index eebef6195fe3e..61be80e94b9b3 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
@@ -5386,7 +5386,7 @@ protected BoundExpression BindClassCreationExpression(
                 ReportDiagnosticsIfObsolete(diagnostics, method, node, hasBaseReceiver: false);
                 // NOTE: Use-site diagnostics were reported during overload resolution.
 
-                ConstantValue constantValueOpt = (initializerSyntaxOpt == null && method.IsDefaultValueTypeConstructor(requireZeroInit: true)) ?
+                ConstantValue constantValueOpt = (initializerSyntaxOpt == null && method.IsDefaultValueTypeConstructor()) ?
                     FoldParameterlessValueTypeConstructor(type) :
                     null;
 
diff --git a/src/Compilers/CSharp/Portable/CSharpResources.resx b/src/Compilers/CSharp/Portable/CSharpResources.resx
index a2d8a9e377099..a76b0e21f90aa 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.resx
+++ b/src/Compilers/CSharp/Portable/CSharpResources.resx
@@ -6914,6 +6914,9 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_RecordStructConstructorCallsDefaultConstructor" xml:space="preserve">
     <value>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</value>
   </data>
+  <data name="ERR_StructHasInitializersAndNoDeclaredConstructor" xml:space="preserve">
+    <value>A 'struct' with field initializers must include an explicitly declared constructor.</value>
+  </data>
   <data name="WRN_CompileTimeCheckedOverflow" xml:space="preserve">
     <value>The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</value>
   </data>
diff --git a/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs b/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs
index 0c1323670c92e..f684af2db356c 100644
--- a/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs
+++ b/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs
@@ -1485,7 +1485,7 @@ private enum CallKind
 
         private void EmitCallExpression(BoundCall call, UseKind useKind)
         {
-            if (call.Method.IsDefaultValueTypeConstructor(requireZeroInit: true))
+            if (call.Method.IsDefaultValueTypeConstructor())
             {
                 EmitDefaultValueTypeConstructorCallExpression(call);
             }
@@ -1960,7 +1960,7 @@ private void EmitConvertedStackAllocExpression(BoundConvertedStackAllocExpressio
         private void EmitObjectCreationExpression(BoundObjectCreationExpression expression, bool used)
         {
             MethodSymbol constructor = expression.Constructor;
-            if (constructor.IsDefaultValueTypeConstructor(requireZeroInit: true))
+            if (constructor.IsDefaultValueTypeConstructor())
             {
                 EmitInitObj(expression.Type, used, expression.Syntax);
             }
diff --git a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
index a6615e7e8992e..b2a274c519301 100644
--- a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
+++ b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
@@ -971,7 +971,7 @@ private void CompileMethod(
                 }
 
                 // no need to emit the default ctor, we are not emitting those
-                if (methodSymbol.IsDefaultValueTypeConstructor(requireZeroInit: true))
+                if (methodSymbol.IsDefaultValueTypeConstructor())
                 {
                     return;
                 }
@@ -1216,7 +1216,7 @@ forSemanticModel.Syntax is { } semanticModelSyntax &&
                     if (!hasErrors && (hasBody || includeNonEmptyInitializersInBody))
                     {
                         Debug.Assert(!(methodSymbol.IsImplicitInstanceConstructor && methodSymbol.ParameterCount == 0) ||
-                                     !methodSymbol.IsDefaultValueTypeConstructor(requireZeroInit: true));
+                                     !methodSymbol.IsDefaultValueTypeConstructor());
 
                         // Fields must be initialized before constructor initializer (which is the first statement of the analyzed body, if specified),
                         // so that the initialization occurs before any method overridden by the declaring class can be invoked from the base constructor
@@ -1752,7 +1752,7 @@ syntaxNode is ConstructorDeclarationSyntax constructorSyntax &&
                         constructorSyntax.Identifier.ValueText);
                 }
 
-                Debug.Assert(!sourceMethod.IsDefaultValueTypeConstructor(requireZeroInit: false));
+                Debug.Assert(!sourceMethod.IsDefaultValueTypeConstructor());
                 if (sourceMethod.IsExtern)
                 {
                     return null;
diff --git a/src/Compilers/CSharp/Portable/Emitter/Model/AttributeDataAdapter.cs b/src/Compilers/CSharp/Portable/Emitter/Model/AttributeDataAdapter.cs
index 744f7e691c1a7..11bc2426bdfb4 100644
--- a/src/Compilers/CSharp/Portable/Emitter/Model/AttributeDataAdapter.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/Model/AttributeDataAdapter.cs
@@ -35,7 +35,7 @@ internal abstract partial class CSharpAttributeData : Cci.ICustomAttribute
 
         Cci.IMethodReference Cci.ICustomAttribute.Constructor(EmitContext context, bool reportDiagnostics)
         {
-            if (this.AttributeConstructor.IsDefaultValueTypeConstructor(requireZeroInit: true))
+            if (this.AttributeConstructor.IsDefaultValueTypeConstructor())
             {
                 // Default parameterless constructors for structs exist in symbol table, but are not emitted.
                 // Produce an error since we cannot use it (instead of crashing).
diff --git a/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs b/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs
index 67ccd10bfc69a..b64be1556d300 100644
--- a/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs
@@ -1263,7 +1263,7 @@ internal Cci.IMethodReference Translate(
             BoundArgListOperator optArgList = null,
             bool needDeclaration = false)
         {
-            Debug.Assert(!methodSymbol.IsDefaultValueTypeConstructor(requireZeroInit: true));
+            Debug.Assert(!methodSymbol.IsDefaultValueTypeConstructor());
             Debug.Assert(optArgList == null || (methodSymbol.IsVararg && !needDeclaration));
 
             Cci.IMethodReference unexpandedMethodRef = Translate(methodSymbol, syntaxNodeOpt, diagnostics, needDeclaration);
diff --git a/src/Compilers/CSharp/Portable/Emitter/NoPia/EmbeddedTypesManager.cs b/src/Compilers/CSharp/Portable/Emitter/NoPia/EmbeddedTypesManager.cs
index c675813c72d5f..2362945a2ba54 100644
--- a/src/Compilers/CSharp/Portable/Emitter/NoPia/EmbeddedTypesManager.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/NoPia/EmbeddedTypesManager.cs
@@ -454,7 +454,7 @@ internal override EmbeddedMethod EmbedMethod(
             DiagnosticBag diagnostics)
         {
             Debug.Assert(method.AdaptedSymbol.IsDefinition);
-            Debug.Assert(!method.AdaptedMethodSymbol.IsDefaultValueTypeConstructor(requireZeroInit: false));
+            Debug.Assert(!method.AdaptedMethodSymbol.IsDefaultValueTypeConstructor());
 
             EmbeddedMethod embedded = new EmbeddedMethod(type, method);
             EmbeddedMethod cached = EmbeddedMethodsMap.GetOrAdd(method, embedded);
diff --git a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
index 7d18a53a3ea6a..9841798e7de00 100644
--- a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
+++ b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
@@ -2024,6 +2024,7 @@ internal enum ErrorCode
 
         WRN_LowerCaseTypeName = 8981,
         ERR_RecordStructConstructorCallsDefaultConstructor = 8982,
+        ERR_StructHasInitializersAndNoDeclaredConstructor = 8983,
 
         #endregion
 
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/FlowAnalysisPass.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/FlowAnalysisPass.cs
index 32b28f41c1420..b4f70388a035d 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/FlowAnalysisPass.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/FlowAnalysisPass.cs
@@ -43,7 +43,7 @@ public static BoundBlock Rewrite(
             if (method.ReturnsVoid || method.IsIterator || method.IsAsyncEffectivelyReturningTask(compilation))
             {
                 // we don't analyze synthesized void methods.
-                if ((method.IsImplicitlyDeclared && !method.IsScriptInitializer && !(method.ContainingType.IsStructType() && method.IsParameterlessConstructor() && !method.IsDefaultValueTypeConstructor(requireZeroInit: true))) ||
+                if ((method.IsImplicitlyDeclared && !method.IsScriptInitializer && !(method.ContainingType.IsStructType() && method.IsParameterlessConstructor() && !method.IsDefaultValueTypeConstructor())) ||
                     Analyze(compilation, method, block, diagnostics))
                 {
                     block = AppendImplicitReturn(block, method, originalBodyNested);
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
index 75580eee88add..3bdde539f9352 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
@@ -3304,7 +3304,7 @@ void setAnalyzedNullabilityAsContinuation(
                     slot = GetOrCreatePlaceholderSlot(node);
                     if (slot > 0)
                     {
-                        bool isDefaultValueTypeConstructor = constructor?.IsDefaultValueTypeConstructor(requireZeroInit: true) == true;
+                        bool isDefaultValueTypeConstructor = constructor?.IsDefaultValueTypeConstructor() == true;
 
                         if (EmptyStructTypeCache.IsTrackableStructType(type))
                         {
diff --git a/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/ExpressionLambdaRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/ExpressionLambdaRewriter.cs
index cec6066c30335..2e4168697e073 100644
--- a/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/ExpressionLambdaRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/ExpressionLambdaRewriter.cs
@@ -960,7 +960,7 @@ private BoundExpression VisitObjectCreationExpressionInternal(BoundObjectCreatio
 
             if ((object)node.Constructor == null ||
                 (node.Arguments.Length == 0 && !node.Type.IsStructType()) ||
-                node.Constructor.IsDefaultValueTypeConstructor(requireZeroInit: true))
+                node.Constructor.IsDefaultValueTypeConstructor())
             {
                 return ExprFactory("New", _bound.Typeof(node.Type));
             }
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs
index 7ad82ed7612bf..8d5119987320a 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs
@@ -82,7 +82,7 @@ public override BoundNode VisitObjectCreationExpression(BoundObjectCreationExpre
             rewrittenObjectCreation = node.UpdateArgumentsAndInitializer(rewrittenArguments, argumentRefKindsOpt, newInitializerExpression: null, changeTypeOpt: node.Constructor.ContainingType);
 
             // replace "new S()" with a default struct ctor with "default(S)"
-            if (node.Constructor.IsDefaultValueTypeConstructor(requireZeroInit: true))
+            if (node.Constructor.IsDefaultValueTypeConstructor())
             {
                 rewrittenObjectCreation = new BoundDefaultExpression(rewrittenObjectCreation.Syntax, rewrittenObjectCreation.Type!);
             }
diff --git a/src/Compilers/CSharp/Portable/Symbols/MemberSymbolExtensions.cs b/src/Compilers/CSharp/Portable/Symbols/MemberSymbolExtensions.cs
index 0155095c808a6..054534b3711ad 100644
--- a/src/Compilers/CSharp/Portable/Symbols/MemberSymbolExtensions.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/MemberSymbolExtensions.cs
@@ -426,7 +426,7 @@ internal static bool IsDefaultValueTypeConstructor(this NamedTypeSymbol type, Co
                 }
 
                 foundParameterlessCtor = true;
-                result = constructor.IsDefaultValueTypeConstructor(requireZeroInit: true);
+                result = constructor.IsDefaultValueTypeConstructor();
             }
 
             return result;
@@ -442,33 +442,18 @@ internal static bool IsParameterlessConstructor(this MethodSymbol method)
 
 #nullable enable
         /// <summary>
-        /// Returns true if the method is the default constructor synthesized for struct types, and
-        /// if <paramref name="requireZeroInit"/> is true, the constructor simply zero-inits the instance.
+        /// Returns true if the method is the default constructor synthesized for struct types.
         /// If the containing struct type is from metadata, the default constructor is synthesized when there
         /// is no accessible parameterless constructor. (That synthesized constructor from metadata zero-inits
         /// the instance.) If the containing struct type is from source, the parameterless constructor is synthesized
-        /// if there is no explicit parameterless constructor. And if the source type has no field initializers, or
-        /// the type has field initializers and at least one explicit constructor with parameters, the synthesized
+        /// if there is no explicit parameterless constructor, and the synthesized
         /// parameterless constructor simply zero-inits the instance (and is not emitted).
         /// </summary>
-        internal static bool IsDefaultValueTypeConstructor(this MethodSymbol method, bool requireZeroInit)
+        internal static bool IsDefaultValueTypeConstructor(this MethodSymbol method)
         {
-            if (method.IsImplicitlyDeclared &&
+            return method.IsImplicitlyDeclared &&
                 method.ContainingType?.IsValueType == true &&
-                method.IsParameterlessConstructor())
-            {
-                if (!requireZeroInit)
-                {
-                    return true;
-                }
-                var containingType = method.ContainingType.OriginalDefinition;
-                var constructors = containingType.InstanceConstructors;
-                // If there are field initializers and an explicit constructor with parameters
-                // (that is, more than one constructor), the implicit parameterless constructor
-                // is treated as the zero-init constructor and does not execute field initializers.
-                return constructors.Length > 1 || !containingType.HasFieldInitializers();
-            }
-            return false;
+                method.IsParameterlessConstructor();
         }
 #nullable disable
 
@@ -478,7 +463,7 @@ internal static bool IsDefaultValueTypeConstructor(this MethodSymbol method, boo
         internal static bool ShouldEmit(this MethodSymbol method)
         {
             // Don't emit the default value type constructor - the runtime handles that
-            if (method.IsDefaultValueTypeConstructor(requireZeroInit: true))
+            if (method.IsDefaultValueTypeConstructor())
             {
                 return false;
             }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs
index 25a99c88a0539..df6df4a607427 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs
@@ -1005,9 +1005,7 @@ internal override IEnumerable<MethodSymbol> GetMethodsToEmit()
                     var method = (MethodSymbol)members[index];
 
                     // Don't emit the default value type constructor - the runtime handles that.
-                    // For parameterless struct constructors from metadata, IsDefaultValueTypeConstructor()
-                    // ignores requireZeroInit and simply checks if the method is implicitly declared.
-                    if (!method.IsDefaultValueTypeConstructor(requireZeroInit: false))
+                    if (!method.IsDefaultValueTypeConstructor())
                     {
                         yield return method;
                     }
diff --git a/src/Compilers/CSharp/Portable/Symbols/NamedTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/NamedTypeSymbol.cs
index a6590c14bc80d..f3b25e788f511 100644
--- a/src/Compilers/CSharp/Portable/Symbols/NamedTypeSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/NamedTypeSymbol.cs
@@ -1543,16 +1543,6 @@ internal bool IsTupleTypeOfCardinality(out int tupleCardinality)
         /// </summary>
         internal abstract NamedTypeSymbol NativeIntegerUnderlyingType { get; }
 
-        /// <summary>
-        /// Returns true if the type is defined in source and contains field initializers.
-        /// This method is only valid on a definition.
-        /// </summary>
-        internal virtual bool HasFieldInitializers()
-        {
-            Debug.Assert(IsDefinition);
-            return false;
-        }
-
         protected override ISymbol CreateISymbol()
         {
             return new PublicModel.NonErrorNamedTypeSymbol(this, DefaultNullableAnnotation);
diff --git a/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingNamedTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingNamedTypeSymbol.cs
index 3afb8804108a9..4bd11b5db2f26 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingNamedTypeSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingNamedTypeSymbol.cs
@@ -395,8 +395,6 @@ public sealed override bool AreLocalsZeroed
         internal sealed override bool IsRecordStruct => _underlyingType.IsRecordStruct;
         internal sealed override bool HasPossibleWellKnownCloneMethod() => _underlyingType.HasPossibleWellKnownCloneMethod();
 
-        internal override bool HasFieldInitializers() => _underlyingType.HasFieldInitializers();
-
         internal override IEnumerable<(MethodSymbol Body, MethodSymbol Implemented)> SynthesizedInterfaceMethodImpls()
         {
             foreach ((MethodSymbol body, MethodSymbol implemented) in _underlyingType.SynthesizedInterfaceMethodImpls())
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs b/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs
index 32672fd8b9a71..fd74d30be3164 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs
@@ -728,7 +728,7 @@ private static bool IsValidDefaultValue(BoundExpression expression)
 
         private static bool IsValidDefaultValue(BoundObjectCreationExpression expression)
         {
-            return expression.Constructor.IsDefaultValueTypeConstructor(requireZeroInit: true) && expression.InitializerExpressionOpt == null;
+            return expression.Constructor.IsDefaultValueTypeConstructor() && expression.InitializerExpressionOpt == null;
         }
 
         internal static MethodSymbol FindContainingGenericMethod(Symbol symbol)
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs
index d54f61f32abb7..bf05a2b68cf19 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs
@@ -3524,14 +3524,21 @@ private void CheckForStructBadInitializers(DeclaredMembersAndInitializersBuilder
                 return;
             }
 
+            bool hasInitializers = false;
             foreach (var initializers in builder.InstanceInitializers)
             {
                 foreach (FieldOrPropertyInitializer initializer in initializers)
                 {
+                    hasInitializers = true;
                     var symbol = initializer.FieldOpt.AssociatedSymbol ?? initializer.FieldOpt;
                     MessageID.IDS_FeatureStructFieldInitializers.CheckFeatureAvailability(diagnostics, symbol.DeclaringCompilation, symbol.Locations[0]);
                 }
             }
+
+            if (hasInitializers && !builder.NonTypeMembers.Any(member => member is MethodSymbol { MethodKind: MethodKind.Constructor }))
+            {
+                diagnostics.Add(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, Locations[0]);
+            }
         }
 
         private void AddSynthesizedSimpleProgramEntryPointIfNecessary(MembersAndInitializersBuilder builder, DeclaredMembersAndInitializers declaredMembersAndInitializers)
@@ -4759,8 +4766,6 @@ public sealed override NamedTypeSymbol ConstructedFrom
             get { return this; }
         }
 
-        internal sealed override bool HasFieldInitializers() => InstanceInitializers.Length > 0;
-
         internal class SynthesizedExplicitImplementations
         {
             public static readonly SynthesizedExplicitImplementations Empty = new SynthesizedExplicitImplementations(ImmutableArray<SynthesizedExplicitImplementationForwardingMethod>.Empty,
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
index 4dc96dd386ae2..0c143f283af8f 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
@@ -1192,6 +1192,11 @@
         <target state="translated">Zadal se argument stdin -, ale vstup se nepřesměroval na stream standardního vstupu.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
+        <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
+        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
         <source>The pattern is unreachable. It has already been handled by a previous arm of the switch expression or it is impossible to match.</source>
         <target state="translated">Vzor není dostupný. Už se zpracoval v jiné části výrazu switch nebo není možné pro něj najít shodu.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
index 0a1f31f89a18a..20f5cf9246ee6 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
@@ -1192,6 +1192,11 @@
         <target state="translated">Das stdin-Argument "-" ist angegeben, aber die Eingabe wurde nicht vom Standardeingabestream umgeleitet.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
+        <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
+        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
         <source>The pattern is unreachable. It has already been handled by a previous arm of the switch expression or it is impossible to match.</source>
         <target state="translated">Das Muster kann nicht erreicht werden. Es wurde bereits von einem vorherigen Verzweigungsarm des Switch-Ausdrucks behandelt, oder es ist keine Übereinstimmung möglich.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
index 5c52bac5afa6b..e777231f2d8c5 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
@@ -1192,6 +1192,11 @@
         <target state="translated">Se ha especificado el argumento stdin "-", pero la entrada no se ha redirigido desde el flujo de entrada estándar.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
+        <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
+        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
         <source>The pattern is unreachable. It has already been handled by a previous arm of the switch expression or it is impossible to match.</source>
         <target state="translated">No se puede acceder al patrón. Ya se ha administrado mediante un indicador anterior de la expresión switch o no se pudo hacer coincidir.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
index 2b392f5e2785a..a1ec5ce86a71e 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
@@ -1192,6 +1192,11 @@
         <target state="translated">L'argument stdin '-' est spécifié, mais l'entrée n'a pas été redirigée à partir du flux d'entrée standard.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
+        <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
+        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
         <source>The pattern is unreachable. It has already been handled by a previous arm of the switch expression or it is impossible to match.</source>
         <target state="translated">Le modèle est inaccessible. Il a déjà été traité par un bras précédent de l'expression switch ou la mise en correspondance est impossible.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
index 7d59f370dd547..3099d6cfab162 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
@@ -1192,6 +1192,11 @@
         <target state="translated">è stato specificato l'argomento stdin '-', ma l'input non è stato reindirizzato dal flusso di input standard.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
+        <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
+        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
         <source>The pattern is unreachable. It has already been handled by a previous arm of the switch expression or it is impossible to match.</source>
         <target state="translated">Il criterio non è raggiungibile. È già stato gestito da un elemento precedente dell'espressione switch oppure non è possibile trovare una corrispondenza.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
index 7e90412db3885..5ded70e499670 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
@@ -1192,6 +1192,11 @@
         <target state="translated">stdin 引数 '-' が指定されていますが、入力が標準入力ストリームからリダイレクトされていません。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
+        <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
+        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
         <source>The pattern is unreachable. It has already been handled by a previous arm of the switch expression or it is impossible to match.</source>
         <target state="translated">このパターンには到達できません。これは、switch 式の以前のアームによって既に処理されたか、一致させることができません。</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
index 0efe3191f37f8..0467b6f969aa3 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
@@ -1192,6 +1192,11 @@
         <target state="translated">stdin 인수 '-'를 지정했지만 표준 입력 스트림에서 입력이 리디렉션되지 않았습니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
+        <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
+        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
         <source>The pattern is unreachable. It has already been handled by a previous arm of the switch expression or it is impossible to match.</source>
         <target state="translated">패턴에 연결할 수 없습니다. 이미 switch 식의 이전 ARM에서 처리되었거나 일치시킬 수 없습니다.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
index 2f856498d1a40..3d05f013a9aff 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
@@ -1192,6 +1192,11 @@
         <target state="translated">określono argument stdin „-”, ale dane wejściowe nie zostały przekierowane ze standardowego strumienia wejściowego.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
+        <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
+        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
         <source>The pattern is unreachable. It has already been handled by a previous arm of the switch expression or it is impossible to match.</source>
         <target state="translated">Wzorzec jest nieosiągalny. Został on już obsłużony przez poprzednie odgałęzienie wyrażenia switch albo nie można go dopasować.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
index be8b3c36d676d..be99a4c58d7cb 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
@@ -1192,6 +1192,11 @@
         <target state="translated">O argumento stdin '-' foi especificado, mas a entrada não foi redirecionada do fluxo de entrada padrão.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
+        <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
+        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
         <source>The pattern is unreachable. It has already been handled by a previous arm of the switch expression or it is impossible to match.</source>
         <target state="translated">O padrão não está acessível. Ele já foi manipulado por um ARM anterior da expressão do comutador ou não é possível fazer a correspondência.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
index 060db145dfa6e..e385c0a76ab08 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
@@ -1192,6 +1192,11 @@
         <target state="translated">Указан аргумент stdin "-", но входные данные не были перенаправлены из стандартного входного потока.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
+        <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
+        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
         <source>The pattern is unreachable. It has already been handled by a previous arm of the switch expression or it is impossible to match.</source>
         <target state="translated">Шаблон является недоступным. Он уже был обработан в предыдущем блоке выражения switch или условие для него не может быть выполнено.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
index 83cb76209ee3f..da8185fac7dfd 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
@@ -1192,6 +1192,11 @@
         <target state="translated">'-' stdin bağımsız değişkeni belirtildi ancak giriş, standart giriş akışından yeniden yönlendirilmedi.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
+        <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
+        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
         <source>The pattern is unreachable. It has already been handled by a previous arm of the switch expression or it is impossible to match.</source>
         <target state="translated">Desene ulaşılamıyor. switch ifadesinin önceki bir kolu tarafından zaten işlenmiş ya da eşleştirilmesi mümkün değil.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
index de52f51125798..9df925ab44fa9 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
@@ -1192,6 +1192,11 @@
         <target state="translated">已指定 stdin 参数 "-"，但尚未从标准输入流重定向输入。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
+        <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
+        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
         <source>The pattern is unreachable. It has already been handled by a previous arm of the switch expression or it is impossible to match.</source>
         <target state="translated">该模式不可访问。它已由 switch 表达式的前一个 arm 处理或无法匹配。</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
index 49532a745b040..ae3bf3dadf94b 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
@@ -1192,6 +1192,11 @@
         <target state="translated">已指定 stdin 引數 '-'，但尚未從標準輸入資料流重新導向輸入。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
+        <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
+        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
         <source>The pattern is unreachable. It has already been handled by a previous arm of the switch expression or it is impossible to match.</source>
         <target state="translated">無法使用此樣式。switch 運算式的上一個 arm 已處理了此樣式，或其無法比對。</target>
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_WellKnownAttributes.cs b/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_WellKnownAttributes.cs
index 5124d9ae3b4e1..b472499f4a267 100644
--- a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_WellKnownAttributes.cs
+++ b/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_WellKnownAttributes.cs
@@ -13362,7 +13362,7 @@ public static void Main()
         }
 
         [Fact, WorkItem(19394, "https://github.com/dotnet/roslyn/issues/19394")]
-        public void WellKnownTypeAsStruct_DefaultConstructor_IsReadOnlyAttribute()
+        public void WellKnownTypeAsStruct_DefaultConstructor_IsReadOnlyAttribute_01()
         {
             var code = @"
 namespace System.Runtime.CompilerServices
@@ -13383,13 +13383,10 @@ void M(in int x)
                 Diagnostic(ErrorCode.ERR_NotAnAttributeClass).WithArguments("System.Runtime.CompilerServices.IsReadOnlyAttribute").WithLocation(1, 1));
         }
 
-        /// <summary>
-        /// Verify that a synthesized (and emitted) parameterless constructor can be referenced
-        /// in metadata for an "attribute type", even if the attribute type is a struct. Compare
-        /// with previous test where no parameterless constructor is emitted for the struct type.
-        /// </summary>
-        [Theory]
-        [InlineData(
+        [Fact]
+        public void WellKnownTypeAsStruct_DefaultConstructor_IsReadOnlyAttribute_02()
+        {
+            var sourceAttribute =
 @"#pragma warning disable 414
 namespace System.Runtime.CompilerServices
 {
@@ -13397,8 +13394,35 @@ public struct IsReadOnlyAttribute
     {
         private int F = 1; // requires synthesized parameterless .ctor
     }
-}")]
-        [InlineData(
+}";
+            var sourceA =
+@"public class A
+{
+    public static void M(in int i)
+    {
+        System.Console.WriteLine(i);
+    }
+}";
+            var comp = CreateCompilation(new[] { sourceAttribute, sourceA }, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (4,19): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
+                //     public struct IsReadOnlyAttribute
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "IsReadOnlyAttribute").WithLocation(4, 19),
+                // (6,21): warning CS0169: The field 'IsReadOnlyAttribute.F' is never used
+                //         private int F = 1; // requires synthesized parameterless .ctor
+                Diagnostic(ErrorCode.WRN_UnreferencedField, "F").WithArguments("System.Runtime.CompilerServices.IsReadOnlyAttribute.F").WithLocation(6, 21));
+        }
+
+        /// <summary>
+        /// Verify that a parameterless constructor can be referenced
+        /// in metadata for an "attribute type", even if the attribute type is a struct.
+        /// Compare with WellKnownTypeAsStruct_DefaultConstructor_IsReadOnlyAttribute_01
+        /// where no parameterless constructor is emitted for the struct type.
+        /// </summary>
+        [Fact]
+        public void WellKnownTypeAsStruct_ExplicitParameterlessConstructor_IsReadOnlyAttribute()
+        {
+            var sourceAttribute =
 @"namespace System.Runtime.CompilerServices
 {
     public struct IsReadOnlyAttribute
@@ -13406,9 +13430,7 @@ public struct IsReadOnlyAttribute
         // explicit parameterless .ctor
         public IsReadOnlyAttribute() { }
     }
-}")]
-        public void WellKnownTypeAsStruct_ParameterlessConstructor_IsReadOnlyAttribute(string sourceAttribute)
-        {
+}";
             var sourceA =
 @"public class A
 {
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs
index a46b3a689be66..6bb089c31cd58 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs
@@ -4933,6 +4933,10 @@ struct S
 {
     int a = 1;
     int b = 2;
+    public S(int a)
+    {
+        this.a = a;
+    }
 }
 ";
             var source1 =
@@ -4941,7 +4945,10 @@ struct S
 {
     int a = 1;
     int b = 2;
-
+    public S(int a)
+    {
+        this.a = a;
+    }
     public S()
     {
         b = 3;
@@ -4952,8 +4959,8 @@ public S()
             var compilation0 = CreateCompilation(source0, options: ComSafeDebugDll);
             var compilation1 = compilation0.WithSource(source1);
 
-            var ctor0 = compilation0.GetMember<MethodSymbol>("S..ctor");
-            var ctor1 = compilation1.GetMember<MethodSymbol>("S..ctor");
+            var ctor0 = compilation0.GetMember<NamedTypeSymbol>("S").InstanceConstructors.Single(m => m.ParameterCount == 0);
+            var ctor1 = compilation1.GetMember<NamedTypeSymbol>("S").InstanceConstructors.Single(m => m.ParameterCount == 0);
 
             var v0 = CompileAndVerify(compilation0, verify: Verification.Skipped);
 
@@ -4970,7 +4977,7 @@ public S()
             var diff1 = compilation1.EmitDifference(
                 generation0,
                 ImmutableArray.Create(
-                    SemanticEdit.Create(SemanticEditKind.Update, ctor0, ctor1)));
+                    SemanticEdit.Create(SemanticEditKind.Insert, null, ctor1)));
 
             // Verify delta metadata contains expected rows.
             using var md1 = diff1.GetMetadata();
@@ -4985,11 +4992,12 @@ public S()
             CheckEncLog(reader1,
                 Row(2, TableIndex.AssemblyRef, EditAndContinueOperation.Default),
                 Row(6, TableIndex.TypeRef, EditAndContinueOperation.Default),
-                Row(1, TableIndex.MethodDef, EditAndContinueOperation.Default));
+                Row(2, TableIndex.TypeDef, EditAndContinueOperation.AddMethod),
+                Row(2, TableIndex.MethodDef, EditAndContinueOperation.Default));
 
             CheckEncMap(reader1,
                 Handle(6, TableIndex.TypeRef),
-                Handle(1, TableIndex.MethodDef),
+                Handle(2, TableIndex.MethodDef),
                 Handle(2, TableIndex.AssemblyRef));
         }
 
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/NoPiaEmbedTypes.cs b/src/Compilers/CSharp/Test/Emit/Emit/NoPiaEmbedTypes.cs
index 3eab1fd08603b..542afad36bf62 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/NoPiaEmbedTypes.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/NoPiaEmbedTypes.cs
@@ -1309,7 +1309,7 @@ public void M6(ITest26 x)
                     Assert.Equal(3, test9.GetMembers().Length);
                     Assert.Same(f1, test9.GetMembers()[0]);
                     Assert.Same(f2, test9.GetMembers()[1]);
-                    Assert.True(((MethodSymbol)test9.GetMembers()[2]).IsDefaultValueTypeConstructor(requireZeroInit: true));
+                    Assert.True(((MethodSymbol)test9.GetMembers()[2]).IsDefaultValueTypeConstructor());
 
                     var test10 = module.GlobalNamespace.GetTypeMembers("Test10").Single();
                     Assert.Equal(TypeKind.Struct, test10.TypeKind);
@@ -1333,7 +1333,7 @@ public void M6(ITest26 x)
                     Assert.Equal(System.Runtime.InteropServices.UnmanagedType.U4, f4.MarshallingType);
                     Assert.False(f4.IsNotSerialized);
 
-                    Assert.True(((MethodSymbol)test10.GetMembers()[2]).IsDefaultValueTypeConstructor(requireZeroInit: true));
+                    Assert.True(((MethodSymbol)test10.GetMembers()[2]).IsDefaultValueTypeConstructor());
 
                     var test11 = (PENamedTypeSymbol)module.GlobalNamespace.GetTypeMembers("Test11").Single();
                     Assert.Equal(TypeKind.Delegate, test11.TypeKind);
diff --git a/src/Compilers/CSharp/Test/Semantic/FlowAnalysis/FlowDiagnosticTests.cs b/src/Compilers/CSharp/Test/Semantic/FlowAnalysis/FlowDiagnosticTests.cs
index 5002210ce5735..ce5a3b5caa5f1 100644
--- a/src/Compilers/CSharp/Test/Semantic/FlowAnalysis/FlowDiagnosticTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/FlowAnalysis/FlowDiagnosticTests.cs
@@ -928,15 +928,18 @@ public static void Main()
                 // (4,7): error CS8773: Feature 'struct field initializers' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //     A a = new A(); // CS8036
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "a").WithArguments("struct field initializers", "10.0").WithLocation(4, 7),
+                // (2,15): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
+                // public struct A
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "A").WithLocation(2, 15),
                 // (4,7): error CS0523: Struct member 'A.a' of type 'A' causes a cycle in the struct layout
                 //     A a = new A(); // CS8036
                 Diagnostic(ErrorCode.ERR_StructLayoutCycle, "a").WithArguments("A.a", "A").WithLocation(4, 7),
                 // (7,11): warning CS0219: The variable 'a' is assigned but its value is never used
                 //         A a = new A();
                 Diagnostic(ErrorCode.WRN_UnreferencedVarAssg, "a").WithArguments("a").WithLocation(7, 11),
-                // (4,7): warning CS0414: The field 'A.a' is assigned but its value is never used
+                // (4,7): warning CS0169: The field 'A.a' is never used
                 //     A a = new A(); // CS8036
-                Diagnostic(ErrorCode.WRN_UnreferencedFieldAssg, "a").WithArguments("A.a").WithLocation(4, 7));
+                Diagnostic(ErrorCode.WRN_UnreferencedField, "a").WithArguments("A.a").WithLocation(4, 7));
         }
 
         [WorkItem(542356, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542356")]
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/InterpolationTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/InterpolationTests.cs
index a4828a4c4ca28..bfab2884c9496 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/InterpolationTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/InterpolationTests.cs
@@ -14191,6 +14191,7 @@ public void HandlerExtensionMethod_02()
 
 public struct S1
 {
+    public S1() { }
     public int Field = 1;
 }
 
@@ -14210,9 +14211,9 @@ partial struct CustomHandler
                 // (5,5): error CS8949: The InterpolatedStringHandlerArgumentAttribute applied to parameter 'CustomHandler' is malformed and cannot be interpreted. Construct an instance of 'CustomHandler' manually.
                 // s.M($"");
                 Diagnostic(ErrorCode.ERR_InterpolatedStringHandlerArgumentAttributeMalformed, @"$""""").WithArguments("CustomHandler", "CustomHandler").WithLocation(5, 5),
-                // (14,38): error CS8944: 'S1Ext.M(S1, CustomHandler)' is not an instance method, the receiver cannot be an interpolated string handler argument.
+                // (15,38): error CS8944: 'S1Ext.M(S1, CustomHandler)' is not an instance method, the receiver cannot be an interpolated string handler argument.
                 //     public static void M(this S1 s, [InterpolatedStringHandlerArgument("")] CustomHandler c) => throw null;
-                Diagnostic(ErrorCode.ERR_NotInstanceInvalidInterpolatedStringHandlerArgumentName, @"InterpolatedStringHandlerArgument("""")").WithArguments("S1Ext.M(S1, CustomHandler)").WithLocation(14, 38)
+                Diagnostic(ErrorCode.ERR_NotInstanceInvalidInterpolatedStringHandlerArgumentName, @"InterpolatedStringHandlerArgument("""")").WithArguments("S1Ext.M(S1, CustomHandler)").WithLocation(15, 38)
             );
         }
 
@@ -14228,6 +14229,7 @@ public void HandlerExtensionMethod_03()
 
 public struct S1
 {
+    public S1() { }
     public int Field = 1;
 }
 
@@ -14258,6 +14260,7 @@ public void HandlerExtensionMethod_04()
 
 public struct S1
 {
+    public S1() { }
     public int Field = 1;
 }
 
@@ -14308,6 +14311,7 @@ public void HandlerExtensionMethod_05()
 
 public struct S1
 {
+    public S1() { }
     public int Field = 1;
 }
 
@@ -14356,6 +14360,7 @@ public void HandlerExtensionMethod_06()
 
 public struct S1
 {
+    public S1() { }
     public int Field = 1;
 }
 
@@ -14389,6 +14394,7 @@ public void HandlerExtensionMethod_07()
 
 public struct S1
 {
+    public S1() { }
     public int Field = 1;
 }
 
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
index a2ca0b64023fd..0c06150b1cc19 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
@@ -58696,8 +58696,13 @@ public struct S3
             comp.VerifyDiagnostics(
                 // (8,1): warning CS8602: Dereference of a possibly null reference.
                 // s2.field.ToString(); // 1
-                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "s2.field").WithLocation(8, 1)
-                );
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "s2.field").WithLocation(8, 1),
+                // (11,1): warning CS8602: Dereference of a possibly null reference.
+                // s3.field.ToString();
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "s3.field").WithLocation(11, 1),
+                // (28,15): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
+                // public struct S3
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S3").WithLocation(28, 15));
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/RecordStructTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/RecordStructTests.cs
index 8b5a495e1044c..e27fdae67e507 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/RecordStructTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/RecordStructTests.cs
@@ -1139,7 +1139,7 @@ public S6() : this(""ignored"") { }
         }
 
         [Fact]
-        public void TypeDeclaration_InstanceInitializers()
+        public void TypeDeclaration_InstanceInitializers_01()
         {
             var src = @"
 public record struct S
@@ -1154,6 +1154,9 @@ public record struct S
                 // (2,15): error CS8773: Feature 'record structs' is not available in C# 9.0. Please use language version 10.0 or greater.
                 // public record struct S
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "struct").WithArguments("record structs", "10.0").WithLocation(2, 15),
+                // (2,22): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
+                // public record struct S
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S").WithLocation(2, 22),
                 // (4,16): error CS8773: Feature 'struct field initializers' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //     public int field = 42;
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "field").WithArguments("struct field initializers", "10.0").WithLocation(4, 16),
@@ -1161,6 +1164,61 @@ public record struct S
                 //     public int Property { get; set; } = 43;
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "Property").WithArguments("struct field initializers", "10.0").WithLocation(5, 16));
 
+            comp = CreateCompilation(src);
+            comp.VerifyDiagnostics(
+                // (2,22): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
+                // public record struct S
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S").WithLocation(2, 22));
+        }
+
+        [Fact]
+        public void TypeDeclaration_InstanceInitializers_02()
+        {
+            var src = @"
+public record struct S
+{
+    public S() { }
+    public int field = 42;
+    public int Property { get; set; } = 43;
+}
+";
+
+            var comp = CreateCompilation(src, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (2,15): error CS8773: Feature 'record structs' is not available in C# 9.0. Please use language version 10.0 or greater.
+                // public record struct S
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "struct").WithArguments("record structs", "10.0").WithLocation(2, 15),
+                // (4,12): error CS8773: Feature 'parameterless struct constructors' is not available in C# 9.0. Please use language version 10.0 or greater.
+                //     public S() { }
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "S").WithArguments("parameterless struct constructors", "10.0").WithLocation(4, 12),
+                // (5,16): error CS8773: Feature 'struct field initializers' is not available in C# 9.0. Please use language version 10.0 or greater.
+                //     public int field = 42;
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "field").WithArguments("struct field initializers", "10.0").WithLocation(5, 16),
+                // (6,16): error CS8773: Feature 'struct field initializers' is not available in C# 9.0. Please use language version 10.0 or greater.
+                //     public int Property { get; set; } = 43;
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "Property").WithArguments("struct field initializers", "10.0").WithLocation(6, 16));
+
+            comp = CreateCompilation(src);
+            comp.VerifyDiagnostics();
+        }
+
+        [Fact]
+        public void TypeDeclaration_InstanceInitializers_03()
+        {
+            var src = @"
+public record struct S()
+{
+    public int field = 42;
+    public int Property { get; set; } = 43;
+}
+";
+
+            var comp = CreateCompilation(src, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (2,15): error CS8773: Feature 'record structs' is not available in C# 9.0. Please use language version 10.0 or greater.
+                // public record struct S()
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "struct").WithArguments("record structs", "10.0").WithLocation(2, 15));
+
             comp = CreateCompilation(src);
             comp.VerifyDiagnostics();
         }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/StructConstructorTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/StructConstructorTests.cs
index 6105f5f25dce7..fec19fb91cccc 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/StructConstructorTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/StructConstructorTests.cs
@@ -1211,50 +1211,65 @@ .maxstack  2
         }
 
         [Fact]
-        public void FieldInitializers_04()
+        public void FieldInitializers_04A()
         {
             var source =
 @"#pragma warning disable 649
 using System;
 struct S1<T> { internal int X = 1; }
+class Program
+{
+    static void Main()
+    {
+        Console.WriteLine(new S1<object>().X);
+    }
+}";
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (3,8): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
+                // struct S1<T> { internal int X = 1; }
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S1").WithLocation(3, 8));
+        }
+
+        [Fact]
+        public void FieldInitializers_04B()
+        {
+            var source =
+@"#pragma warning disable 649
+using System;
 struct S2<T> { internal int X = 2; public S2() { } }
 struct S3<T> { internal int X = 3; public S3(int _) { } }
 class Program
 {
     static void Main()
     {
-        Console.WriteLine(new S1<object>().X);
         Console.WriteLine(new S2<object>().X);
         Console.WriteLine(new S3<object>().X);
     }
 }";
 
             var verifier = CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
-@"1
-2
+@"2
 0");
             verifier.VerifyIL("Program.Main",
 @"{
-  // Code size       50 (0x32)
+  // Code size       35 (0x23)
   .maxstack  1
   .locals init (S3<object> V_0)
-  IL_0000:  newobj     ""S1<object>..ctor()""
-  IL_0005:  ldfld      ""int S1<object>.X""
+  IL_0000:  newobj     ""S2<object>..ctor()""
+  IL_0005:  ldfld      ""int S2<object>.X""
   IL_000a:  call       ""void System.Console.WriteLine(int)""
-  IL_000f:  newobj     ""S2<object>..ctor()""
-  IL_0014:  ldfld      ""int S2<object>.X""
-  IL_0019:  call       ""void System.Console.WriteLine(int)""
-  IL_001e:  ldloca.s   V_0
-  IL_0020:  initobj    ""S3<object>""
-  IL_0026:  ldloc.0
-  IL_0027:  ldfld      ""int S3<object>.X""
-  IL_002c:  call       ""void System.Console.WriteLine(int)""
-  IL_0031:  ret
+  IL_000f:  ldloca.s   V_0
+  IL_0011:  initobj    ""S3<object>""
+  IL_0017:  ldloc.0
+  IL_0018:  ldfld      ""int S3<object>.X""
+  IL_001d:  call       ""void System.Console.WriteLine(int)""
+  IL_0022:  ret
 }");
         }
 
         [Fact]
-        public void FieldInitializers_05()
+        public void FieldInitializers_05A()
         {
             var source =
 @"#pragma warning disable 649
@@ -1262,6 +1277,29 @@ public void FieldInitializers_05()
 class A<T>
 {
     internal struct S1 { internal int X { get; } = 1; }
+}
+class Program
+{
+    static void Main()
+    {
+        Console.WriteLine(new A<object>.S1().X);
+    }
+}";
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (5,21): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
+                //     internal struct S1 { internal int X { get; } = 1; }
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S1").WithLocation(5, 21));
+        }
+
+        [Fact]
+        public void FieldInitializers_05B()
+        {
+            var source =
+@"#pragma warning disable 649
+using System;
+class A<T>
+{
     internal struct S2 { internal int X { get; init; } = 2; public S2() { } }
     internal struct S3 { internal int X { get; set; } = 3; public S3(int _) { } }
 }
@@ -1269,48 +1307,31 @@ class Program
 {
     static void Main()
     {
-        Console.WriteLine(new A<object>.S1().X);
         Console.WriteLine(new A<object>.S2().X);
         Console.WriteLine(new A<object>.S3().X);
     }
 }";
 
             var verifier = CompileAndVerify(new[] { source, IsExternalInitTypeDefinition }, options: TestOptions.ReleaseExe, verify: Verification.Skipped, expectedOutput:
-@"1
-2
+@"2
 0");
             verifier.VerifyIL("Program.Main",
 @"{
-  // Code size       56 (0x38)
+  // Code size       38 (0x26)
   .maxstack  2
-  .locals init (A<object>.S1 V_0,
-                A<object>.S2 V_1,
-                A<object>.S3 V_2)
-  IL_0000:  newobj     ""A<object>.S1..ctor()""
+  .locals init (A<object>.S2 V_0,
+                A<object>.S3 V_1)
+  IL_0000:  newobj     ""A<object>.S2..ctor()""
   IL_0005:  stloc.0
   IL_0006:  ldloca.s   V_0
-  IL_0008:  call       ""readonly int A<object>.S1.X.get""
+  IL_0008:  call       ""readonly int A<object>.S2.X.get""
   IL_000d:  call       ""void System.Console.WriteLine(int)""
-  IL_0012:  newobj     ""A<object>.S2..ctor()""
-  IL_0017:  stloc.1
-  IL_0018:  ldloca.s   V_1
-  IL_001a:  call       ""readonly int A<object>.S2.X.get""
-  IL_001f:  call       ""void System.Console.WriteLine(int)""
-  IL_0024:  ldloca.s   V_2
-  IL_0026:  dup
-  IL_0027:  initobj    ""A<object>.S3""
-  IL_002d:  call       ""readonly int A<object>.S3.X.get""
-  IL_0032:  call       ""void System.Console.WriteLine(int)""
-  IL_0037:  ret
-}");
-            verifier.VerifyIL("A<T>.S1..ctor()",
-@"{
-  // Code size        8 (0x8)
-  .maxstack  2
-  IL_0000:  ldarg.0
-  IL_0001:  ldc.i4.1
-  IL_0002:  stfld      ""int A<T>.S1.<X>k__BackingField""
-  IL_0007:  ret
+  IL_0012:  ldloca.s   V_1
+  IL_0014:  dup
+  IL_0015:  initobj    ""A<object>.S3""
+  IL_001b:  call       ""readonly int A<object>.S3.X.get""
+  IL_0020:  call       ""void System.Console.WriteLine(int)""
+  IL_0025:  ret
 }");
             verifier.VerifyIL("A<T>.S2..ctor()",
 @"{
@@ -1364,9 +1385,9 @@ struct S4
 
             var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
-                // (2,8): error CS0171: Field 'S1.Y' must be fully assigned before control is returned to the caller
+                // (2,8): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
                 // struct S1
-                Diagnostic(ErrorCode.ERR_UnassignedThis, "S1").WithArguments("S1.Y").WithLocation(2, 8),
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S1").WithLocation(2, 8),
                 // (4,21): error CS8773: Feature 'struct field initializers' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //     internal object X = null;
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "X").WithArguments("struct field initializers", "10.0").WithLocation(4, 21),
@@ -1397,9 +1418,9 @@ struct S4
 
             var expectedDiagnostics = new[]
             {
-                // (2,8): error CS0171: Field 'S1.Y' must be fully assigned before control is returned to the caller
+                // (2,8): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
                 // struct S1
-                Diagnostic(ErrorCode.ERR_UnassignedThis, "S1").WithArguments("S1.Y").WithLocation(2, 8),
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S1").WithLocation(2, 8),
                 // (11,12): error CS0171: Field 'S2.Y' must be fully assigned before control is returned to the caller
                 //     public S2() { }
                 Diagnostic(ErrorCode.ERR_UnassignedThis, "S2").WithArguments("S2.Y").WithLocation(11, 12),
@@ -1447,9 +1468,9 @@ struct S4
 
             var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
-                // (2,8): error CS0843: Auto-implemented property 'S1.Y' must be fully assigned before control is returned to the caller.
+                // (2,8): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
                 // struct S1
-                Diagnostic(ErrorCode.ERR_UnassignedThisAutoProperty, "S1").WithArguments("S1.Y").WithLocation(2, 8),
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S1").WithLocation(2, 8),
                 // (4,21): error CS8773: Feature 'struct field initializers' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //     internal object X { get; } = null;
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "X").WithArguments("struct field initializers", "10.0").WithLocation(4, 21),
@@ -1480,9 +1501,9 @@ struct S4
 
             var expectedDiagnostics = new[]
             {
-                // (2,8): error CS0843: Auto-implemented property 'S1.Y' must be fully assigned before control is returned to the caller.
+                // (2,8): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
                 // struct S1
-                Diagnostic(ErrorCode.ERR_UnassignedThisAutoProperty, "S1").WithArguments("S1.Y").WithLocation(2, 8),
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S1").WithLocation(2, 8),
                 // (11,12): error CS0843: Auto-implemented property 'S2.Y' must be fully assigned before control is returned to the caller.
                 //     public S2() { }
                 Diagnostic(ErrorCode.ERR_UnassignedThisAutoProperty, "S2").WithArguments("S2.Y").WithLocation(11, 12),
@@ -1531,9 +1552,9 @@ record struct S4
 
             var expectedDiagnostics = new[]
             {
-                // (2,15): error CS0171: Field 'S1.Y' must be fully assigned before control is returned to the caller
+                // (2,15): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
                 // record struct S1
-                Diagnostic(ErrorCode.ERR_UnassignedThis, "S1").WithArguments("S1.Y").WithLocation(2, 15),
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S1").WithLocation(2, 15),
                 // (11,12): error CS0843: Auto-implemented property 'S2.Y' must be fully assigned before control is returned to the caller.
                 //     public S2() { }
                 Diagnostic(ErrorCode.ERR_UnassignedThisAutoProperty, "S2").WithArguments("S2.Y").WithLocation(11, 12),
@@ -1760,9 +1781,9 @@ record struct S
 
             var expectedDiagnostics = new[]
             {
-                // (10,15): error CS0843: Auto-implemented property 'S.P1' must be fully assigned before control is returned to the caller.
+                // (10,15): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
                 // record struct S
-                Diagnostic(ErrorCode.ERR_UnassignedThisAutoProperty, "S").WithArguments("S.P1").WithLocation(10, 15)
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S").WithLocation(10, 15)
             };
 
             var comp = CreateCompilation(new[] { source, IsExternalInitTypeDefinition }, parseOptions: TestOptions.Regular10);
@@ -1772,21 +1793,121 @@ record struct S
             comp.VerifyDiagnostics(expectedDiagnostics);
         }
 
+        /// <summary>
+        /// Should still report binding errors in field initializers
+        /// even if there is no explicit constructor.
+        /// </summary>
+        [Fact]
+        public void FieldInitializers_14()
+        {
+            var source =
+@"struct S
+{
+    private object F = Unknown();
+}";
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (1,8): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
+                // struct S
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S").WithLocation(1, 8),
+                // (3,20): warning CS0169: The field 'S.F' is never used
+                //     private object F = Unknown();
+                Diagnostic(ErrorCode.WRN_UnreferencedField, "F").WithArguments("S.F").WithLocation(3, 20),
+                // (3,24): error CS0103: The name 'Unknown' does not exist in the current context
+                //     private object F = Unknown();
+                Diagnostic(ErrorCode.ERR_NameNotInContext, "Unknown").WithArguments("Unknown").WithLocation(3, 24));
+        }
+
+        [Fact]
+        public void FieldInitializers_15()
+        {
+            var source =
+@"struct S0
+{
+    static S0() { }
+    public int F = 1;
+}";
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (1,8): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
+                // struct S0
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S0").WithLocation(1, 8),
+                // (4,16): warning CS0649: Field 'S0.F' is never assigned to, and will always have its default value 0
+                //     public int F = 1;
+                Diagnostic(ErrorCode.WRN_UnassignedInternalField, "F").WithArguments("S0.F", "0").WithLocation(4, 16));
+        }
+
+        [Fact]
+        public void FieldInitializers_16()
+        {
+            var source =
+@"using System;
+struct S1
+{
+    static S1() { }
+    public S1() { }
+    public int F = 1;
+}
+struct S2
+{
+    static S2() { }
+    public S2(object o) { }
+    public int F = 2;
+}
+class Program
+{
+    static void Main()
+    {
+        Console.WriteLine(new S1().F);
+        Console.WriteLine(new S2().F);
+    }
+}";
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, verify: Verification.Skipped, expectedOutput:
+@"1
+0");
+        }
+
         [Fact]
-        public void ExpressionTrees()
+        public void ExpressionTrees_01()
         {
             var source =
 @"#pragma warning disable 649
 using System;
 using System.Linq.Expressions;
-struct S0
+struct S1
 {
-    int X;
+    int X = 1;
     public override string ToString() => X.ToString();
 }
-struct S1
+class Program
 {
-    int X = 1;
+    static void Main()
+    {
+        Report(() => new S1());
+    }
+    static void Report<T>(Expression<Func<T>> e)
+    {
+        var t = e.Compile().Invoke();
+        Console.WriteLine(t);
+    }
+}";
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (4,8): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
+                // struct S1
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S1").WithLocation(4, 8));
+        }
+
+        [Fact]
+        public void ExpressionTrees_02()
+        {
+            var source =
+@"#pragma warning disable 649
+using System;
+using System.Linq.Expressions;
+struct S0
+{
+    int X;
     public override string ToString() => X.ToString();
 }
 struct S2
@@ -1800,7 +1921,6 @@ class Program
     static void Main()
     {
         Report(() => new S0());
-        Report(() => new S1());
         Report(() => new S2());
     }
     static void Report<T>(Expression<Func<T>> e)
@@ -1812,11 +1932,10 @@ static void Report<T>(Expression<Func<T>> e)
 
             var verifier = CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
 @"0
-1
 2");
             verifier.VerifyIL("Program.Main",
 @"{
-  // Code size      111 (0x6f)
+  // Code size       71 (0x47)
   .maxstack  2
   IL_0000:  ldtoken    ""S0""
   IL_0005:  call       ""System.Type System.Type.GetTypeFromHandle(System.RuntimeTypeHandle)""
@@ -1824,23 +1943,15 @@ .maxstack  2
   IL_000f:  call       ""System.Linq.Expressions.ParameterExpression[] System.Array.Empty<System.Linq.Expressions.ParameterExpression>()""
   IL_0014:  call       ""System.Linq.Expressions.Expression<System.Func<S0>> System.Linq.Expressions.Expression.Lambda<System.Func<S0>>(System.Linq.Expressions.Expression, params System.Linq.Expressions.ParameterExpression[])""
   IL_0019:  call       ""void Program.Report<S0>(System.Linq.Expressions.Expression<System.Func<S0>>)""
-  IL_001e:  ldtoken    ""S1..ctor()""
+  IL_001e:  ldtoken    ""S2..ctor()""
   IL_0023:  call       ""System.Reflection.MethodBase System.Reflection.MethodBase.GetMethodFromHandle(System.RuntimeMethodHandle)""
   IL_0028:  castclass  ""System.Reflection.ConstructorInfo""
   IL_002d:  call       ""System.Linq.Expressions.Expression[] System.Array.Empty<System.Linq.Expressions.Expression>()""
   IL_0032:  call       ""System.Linq.Expressions.NewExpression System.Linq.Expressions.Expression.New(System.Reflection.ConstructorInfo, System.Collections.Generic.IEnumerable<System.Linq.Expressions.Expression>)""
   IL_0037:  call       ""System.Linq.Expressions.ParameterExpression[] System.Array.Empty<System.Linq.Expressions.ParameterExpression>()""
-  IL_003c:  call       ""System.Linq.Expressions.Expression<System.Func<S1>> System.Linq.Expressions.Expression.Lambda<System.Func<S1>>(System.Linq.Expressions.Expression, params System.Linq.Expressions.ParameterExpression[])""
-  IL_0041:  call       ""void Program.Report<S1>(System.Linq.Expressions.Expression<System.Func<S1>>)""
-  IL_0046:  ldtoken    ""S2..ctor()""
-  IL_004b:  call       ""System.Reflection.MethodBase System.Reflection.MethodBase.GetMethodFromHandle(System.RuntimeMethodHandle)""
-  IL_0050:  castclass  ""System.Reflection.ConstructorInfo""
-  IL_0055:  call       ""System.Linq.Expressions.Expression[] System.Array.Empty<System.Linq.Expressions.Expression>()""
-  IL_005a:  call       ""System.Linq.Expressions.NewExpression System.Linq.Expressions.Expression.New(System.Reflection.ConstructorInfo, System.Collections.Generic.IEnumerable<System.Linq.Expressions.Expression>)""
-  IL_005f:  call       ""System.Linq.Expressions.ParameterExpression[] System.Array.Empty<System.Linq.Expressions.ParameterExpression>()""
-  IL_0064:  call       ""System.Linq.Expressions.Expression<System.Func<S2>> System.Linq.Expressions.Expression.Lambda<System.Func<S2>>(System.Linq.Expressions.Expression, params System.Linq.Expressions.ParameterExpression[])""
-  IL_0069:  call       ""void Program.Report<S2>(System.Linq.Expressions.Expression<System.Func<S2>>)""
-  IL_006e:  ret
+  IL_003c:  call       ""System.Linq.Expressions.Expression<System.Func<S2>> System.Linq.Expressions.Expression.Lambda<System.Func<S2>>(System.Linq.Expressions.Expression, params System.Linq.Expressions.ParameterExpression[])""
+  IL_0041:  call       ""void Program.Report<S2>(System.Linq.Expressions.Expression<System.Func<S2>>)""
+  IL_0046:  ret
 }");
         }
 
@@ -1848,11 +1959,7 @@ .maxstack  2
         public void Retargeting_01()
         {
             var sourceA =
-@"public struct S1
-{
-    public int X = 1;
-}
-public struct S2
+@"public struct S2
 {
     public int X = 2;
     public S2() { }
@@ -1865,7 +1972,7 @@ public S3(object _) { }
             var comp = CreateCompilation(sourceA, targetFramework: TargetFramework.Mscorlib40);
             var refA = comp.ToMetadataReference();
 
-            var typeA = comp.GetMember<FieldSymbol>("S1.X").Type;
+            var typeA = comp.GetMember<FieldSymbol>("S2.X").Type;
             var corLibA = comp.Assembly.CorLibrary;
             Assert.Equal(corLibA, typeA.ContainingAssembly);
 
@@ -1875,21 +1982,19 @@ class Program
 {
     static void Main()
     {
-        Console.WriteLine(new S1().X);
         Console.WriteLine(new S2().X);
         Console.WriteLine(new S3().X);
     }
 }";
             comp = CreateCompilation(sourceB, references: new[] { refA }, options: TestOptions.ReleaseExe, parseOptions: TestOptions.Regular9, targetFramework: TargetFramework.Mscorlib45);
             CompileAndVerify(comp, expectedOutput:
-@"1
-2
+@"2
 0");
 
             var corLibB = comp.Assembly.CorLibrary;
             Assert.NotEqual(corLibA, corLibB);
 
-            var field = comp.GetMember<FieldSymbol>("S1.X");
+            var field = comp.GetMember<FieldSymbol>("S2.X");
             Assert.IsType<Microsoft.CodeAnalysis.CSharp.Symbols.Retargeting.RetargetingFieldSymbol>(field);
             var typeB = (NamedTypeSymbol)field.Type;
             Assert.Equal(corLibB, typeB.ContainingAssembly);
@@ -1953,6 +2058,25 @@ struct S0
 {
     object F0 = Utils.GetValue();
 }
+static class Utils
+{
+    internal static object? GetValue() => null;
+}";
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (2,8): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
+                // struct S0
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S0").WithLocation(2, 8),
+                // (4,12): warning CS0169: The field 'S0.F0' is never used
+                //     object F0 = Utils.GetValue();
+                Diagnostic(ErrorCode.WRN_UnreferencedField, "F0").WithArguments("S0.F0").WithLocation(4, 12));
+        }
+
+        [Fact]
+        public void NullableAnalysis_03()
+        {
+            var source =
+@"#nullable enable
 struct S1
 {
     object F1 = Utils.GetValue();
@@ -1971,17 +2095,14 @@ static class Utils
             var comp = CreateCompilation(source);
             comp.VerifyDiagnostics(
                 // (4,17): warning CS8601: Possible null reference assignment.
-                //     object F0 = Utils.GetValue();
-                Diagnostic(ErrorCode.WRN_NullReferenceAssignment, "Utils.GetValue()").WithLocation(4, 17),
-                // (8,17): warning CS8601: Possible null reference assignment.
                 //     object F1 = Utils.GetValue();
-                Diagnostic(ErrorCode.WRN_NullReferenceAssignment, "Utils.GetValue()").WithLocation(8, 17),
-                // (13,17): warning CS8601: Possible null reference assignment.
+                Diagnostic(ErrorCode.WRN_NullReferenceAssignment, "Utils.GetValue()").WithLocation(4, 17),
+                // (9,17): warning CS8601: Possible null reference assignment.
                 //     object F2 = Utils.GetValue();
-                Diagnostic(ErrorCode.WRN_NullReferenceAssignment, "Utils.GetValue()").WithLocation(13, 17),
-                // (14,24): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                Diagnostic(ErrorCode.WRN_NullReferenceAssignment, "Utils.GetValue()").WithLocation(9, 17),
+                // (10,24): warning CS8625: Cannot convert null literal to non-nullable reference type.
                 //     public S2() : this(null) { }
-                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(14, 24));
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(10, 24));
         }
 
         [Fact]
@@ -2026,9 +2147,9 @@ unsafe struct S5
                 // (20,12): error CS0171: Field 'S3.X' must be fully assigned before control is returned to the caller
                 //     public S3() { }
                 Diagnostic(ErrorCode.ERR_UnassignedThis, "S3").WithArguments("S3.X").WithLocation(20, 12),
-                // (24,9): warning CS0414: The field 'S4.X' is assigned but its value is never used
-                //     int X = 4;
-                Diagnostic(ErrorCode.WRN_UnreferencedFieldAssg, "X").WithArguments("S4.X").WithLocation(24, 9),
+                // (22,15): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
+                // unsafe struct S4
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S4").WithLocation(22, 15),
                 // (29,9): warning CS0414: The field 'S5.X' is assigned but its value is never used
                 //     int X;
                 Diagnostic(ErrorCode.WRN_UnreferencedFieldAssg, "X").WithArguments("S5.X").WithLocation(29, 9));
@@ -2131,9 +2252,12 @@ static void F3(S3 s = default) { }
 }";
             var comp = CreateCompilation(source);
             comp.VerifyDiagnostics(
-                // (20,27): error CS1736: Default parameter value for 's' must be a compile-time constant
-                //     static void G1(S1 s = new()) { }
-                Diagnostic(ErrorCode.ERR_DefaultValueMustBeConstant, "new()").WithArguments("s").WithLocation(20, 27),
+                // (1,8): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
+                // struct S1
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S1").WithLocation(1, 8),
+                // (3,12): warning CS0169: The field 'S1.X' is never used
+                //     object X = 1;
+                Diagnostic(ErrorCode.WRN_UnreferencedField, "X").WithArguments("S1.X").WithLocation(3, 12),
                 // (21,27): error CS1736: Default parameter value for 's' must be a compile-time constant
                 //     static void G2(S2 s = new()) { }
                 Diagnostic(ErrorCode.ERR_DefaultValueMustBeConstant, "new()").WithArguments("s").WithLocation(21, 27));
@@ -2219,6 +2343,12 @@ class Program
 }";
             var comp = CreateCompilation(source);
             comp.VerifyDiagnostics(
+                // (4,8): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
+                // struct S1
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S1").WithLocation(4, 8),
+                // (6,12): warning CS0169: The field 'S1.X' is never used
+                //     object X = 1;
+                Diagnostic(ErrorCode.WRN_UnreferencedField, "X").WithArguments("S1.X").WithLocation(6, 12),
                 // (14,23): error CS0133: The expression being assigned to 'Program.d0' must be constant
                 //     const object d0 = default(S0);
                 Diagnostic(ErrorCode.ERR_NotConstantExpression, "default(S0)").WithArguments("Program.d0").WithLocation(14, 23),
@@ -2252,7 +2382,6 @@ public interface I
 {
     S0 F0();
     S1 F1();
-    S2 F2();
 }
 public struct S0
 {
@@ -2260,10 +2389,6 @@ public struct S0
 public struct S1
 {
     public S1() { }
-}
-public struct S2
-{
-    object F = 2;
 }";
             var comp = CreateCompilationWithMscorlib40(sourceA);
             var refA = comp.EmitToImageReference(embedInteropTypes: true);
@@ -2275,17 +2400,13 @@ static void M(I i)
     {
         var s0 = i.F0();
         var s1 = i.F1();
-        var s2 = i.F2();
     }
 }";
             comp = CreateCompilationWithMscorlib40(sourceB, references: new[] { refA });
             comp.VerifyEmitDiagnostics(
                 // (6,18): error CS1757: Embedded interop struct 'S1' can contain only public instance fields.
                 //         var s1 = i.F1();
-                Diagnostic(ErrorCode.ERR_InteropStructContainsMethods, "i.F1()").WithArguments("S1").WithLocation(6, 18),
-                // (7,18): error CS1757: Embedded interop struct 'S2' can contain only public instance fields.
-                //         var s2 = i.F2();
-                Diagnostic(ErrorCode.ERR_InteropStructContainsMethods, "i.F2()").WithArguments("S2").WithLocation(7, 18));
+                Diagnostic(ErrorCode.ERR_InteropStructContainsMethods, "i.F1()").WithArguments("S1").WithLocation(6, 18));
         }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/StructsTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/StructsTests.cs
index fe3f30038aab7..0a597493a170f 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/StructsTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/StructsTests.cs
@@ -27,20 +27,23 @@ public struct A
 }
 ";
             CreateCompilation(text, parseOptions: TestOptions.Regular9).VerifyDiagnostics(
+                // (2,15): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
+                // public struct A
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "A").WithLocation(2, 15),
                 // (4,7): error CS8773: Feature 'struct field initializers' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //     A a = new A();   // CS8036
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "a").WithArguments("struct field initializers", "10.0").WithLocation(4, 7),
                 // (4,7): error CS0523: Struct member 'A.a' of type 'A' causes a cycle in the struct layout
                 //     A a = new A();   // CS8036
                 Diagnostic(ErrorCode.ERR_StructLayoutCycle, "a").WithArguments("A.a", "A").WithLocation(4, 7),
-                // (4,7): warning CS0414: The field 'A.a' is assigned but its value is never used
+                // (4,7): warning CS0169: The field 'A.a' is never used
                 //     A a = new A();   // CS8036
-                Diagnostic(ErrorCode.WRN_UnreferencedFieldAssg, "a").WithArguments("A.a").WithLocation(4, 7));
+                Diagnostic(ErrorCode.WRN_UnreferencedField, "a").WithArguments("A.a").WithLocation(4, 7));
         }
 
         [WorkItem(1075325, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1075325"), WorkItem(343, "CodePlex")]
         [Fact()]
-        public void TestInitEventStruct()
+        public void TestInitEventStruct_01()
         {
             var text = @"
 struct S {
@@ -53,10 +56,40 @@ void M()
 }
 ";
             CreateCompilation(text, parseOptions: TestOptions.Regular9).VerifyDiagnostics(
+                // (2,8): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
+                // struct S {
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S").WithLocation(2, 8),
                 // (3,25): error CS8773: Feature 'struct field initializers' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //     event System.Action E = null;
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "E").WithArguments("struct field initializers", "10.0").WithLocation(3, 25));
 
+            CreateCompilation(text).VerifyDiagnostics(
+                // (2,8): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
+                // struct S {
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S").WithLocation(2, 8));
+        }
+
+        [Fact()]
+        public void TestInitEventStruct_02()
+        {
+            var text = @"
+struct S {
+    event System.Action E = null;
+    public S() { }
+    void M()
+    {
+        E();
+    }
+}
+";
+            CreateCompilation(text, parseOptions: TestOptions.Regular9).VerifyDiagnostics(
+                // (3,25): error CS8773: Feature 'struct field initializers' is not available in C# 9.0. Please use language version 10.0 or greater.
+                //     event System.Action E = null;
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "E").WithArguments("struct field initializers", "10.0").WithLocation(3, 25),
+                // (4,12): error CS8773: Feature 'parameterless struct constructors' is not available in C# 9.0. Please use language version 10.0 or greater.
+                //     public S() { }
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "S").WithArguments("parameterless struct constructors", "10.0").WithLocation(4, 12));
+
             CreateCompilation(text).VerifyDiagnostics();
         }
 
@@ -360,7 +393,7 @@ public void RetargetedSynthesizedStructConstructor()
             var @struct = c2.GlobalNamespace.GetMember<RetargetingNamedTypeSymbol>("S");
             var method = (RetargetingMethodSymbol)@struct.GetMembers().Single();
 
-            Assert.True(method.IsDefaultValueTypeConstructor(requireZeroInit: false));
+            Assert.True(method.IsDefaultValueTypeConstructor());
 
             //TODO (tomat)
             CompileAndVerify(c2).VerifyIL("C.M", @"
@@ -634,6 +667,9 @@ public void StructNonAutoPropertyInitializer()
 
             var comp = CreateCompilation(text, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
+                // (1,8): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
+                // struct S
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S").WithLocation(1, 8),
                 // (3,16): error CS8773: Feature 'struct field initializers' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //     public int I { get { throw null; } set {} } = 9;
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "I").WithArguments("struct field initializers", "10.0").WithLocation(3, 16),
@@ -643,6 +679,9 @@ public void StructNonAutoPropertyInitializer()
 
             comp = CreateCompilation(text);
             comp.VerifyDiagnostics(
+                // (1,8): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
+                // struct S
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S").WithLocation(1, 8),
                 // (3,16): error CS8050: Only auto-implemented properties can have initializers.
                 //     public int I { get { throw null; } set {} } = 9;
                 Diagnostic(ErrorCode.ERR_InitializerOnNonAutoProperty, "I").WithArguments("S.I").WithLocation(3, 16));
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/PropertyTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/PropertyTests.cs
index 807042a2694db..86097b7a6e966 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/PropertyTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/PropertyTests.cs
@@ -157,12 +157,15 @@ struct S
                 // (4,9): error CS8773: Feature 'struct field initializers' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //     int a = 2;
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "a").WithArguments("struct field initializers", "10.0").WithLocation(4, 9),
+                // (2,8): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
+                // struct S
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S").WithLocation(2, 8),
                 // (5,9): error CS0102: The type 'S' already contains a definition for 'a'
                 //     int a { get { return 1; } set {} }
                 Diagnostic(ErrorCode.ERR_DuplicateNameInClass, "a").WithArguments("S", "a").WithLocation(5, 9),
-                // (4,9): warning CS0414: The field 'S.a' is assigned but its value is never used
+                // (4,9): warning CS0169: The field 'S.a' is never used
                 //     int a = 2;
-                Diagnostic(ErrorCode.WRN_UnreferencedFieldAssg, "a").WithArguments("S.a").WithLocation(4, 9));
+                Diagnostic(ErrorCode.WRN_UnreferencedField, "a").WithArguments("S.a").WithLocation(4, 9));
         }
 
         [Fact]
@@ -205,6 +208,9 @@ struct S
 
             var comp = CreateCompilation(text, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
+                // (2,8): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
+                // struct S
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "S").WithLocation(2, 8),
                 // (4,16): error CS8773: Feature 'struct field initializers' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //     public int P { get; set; } = 1;
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "P").WithArguments("struct field initializers", "10.0").WithLocation(4, 16),
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolErrorTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolErrorTests.cs
index 124d50b7412eb..8460615ecac40 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolErrorTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolErrorTests.cs
@@ -10656,24 +10656,36 @@ public struct @cly
 ";
             var comp = CreateCompilation(text, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
+                // (10,19): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
+                //     public struct @cly
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "@cly").WithLocation(10, 19),
                 // (12,13): error CS8773: Feature 'struct field initializers' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         clx a = new clx();   // CS8036
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "a").WithArguments("struct field initializers", "10.0").WithLocation(12, 13),
+                // (12,13): warning CS0169: The field 'cly.a' is never used
+                //         clx a = new clx();   // CS8036
+                Diagnostic(ErrorCode.WRN_UnreferencedField, "a").WithArguments("x.cly.a").WithLocation(12, 13),
                 // (13,13): error CS8773: Feature 'struct field initializers' is not available in C# 9.0. Please use language version 10.0 or greater.
                 //         int i = 7;           // CS8036
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "i").WithArguments("struct field initializers", "10.0").WithLocation(13, 13),
-                // (13,13): warning CS0414: The field 'cly.i' is assigned but its value is never used
+                // (13,13): warning CS0169: The field 'cly.i' is never used
                 //         int i = 7;           // CS8036
-                Diagnostic(ErrorCode.WRN_UnreferencedFieldAssg, "i").WithArguments("x.cly.i").WithLocation(13, 13),
+                Diagnostic(ErrorCode.WRN_UnreferencedField, "i").WithArguments("x.cly.i").WithLocation(13, 13),
                 // (15,20): warning CS0414: The field 'cly.s' is assigned but its value is never used
                 //         static int s = 2;    // no error
                 Diagnostic(ErrorCode.WRN_UnreferencedFieldAssg, "s").WithArguments("x.cly.s").WithLocation(15, 20));
 
             comp = CreateCompilation(text);
             comp.VerifyDiagnostics(
-                // (13,13): warning CS0414: The field 'cly.i' is assigned but its value is never used
+                // (10,19): error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
+                //     public struct @cly
+                Diagnostic(ErrorCode.ERR_StructHasInitializersAndNoDeclaredConstructor, "@cly").WithLocation(10, 19),
+                // (12,13): warning CS0169: The field 'cly.a' is never used
+                //         clx a = new clx();   // CS8036
+                Diagnostic(ErrorCode.WRN_UnreferencedField, "a").WithArguments("x.cly.a").WithLocation(12, 13),
+                // (13,13): warning CS0169: The field 'cly.i' is never used
                 //         int i = 7;           // CS8036
-                Diagnostic(ErrorCode.WRN_UnreferencedFieldAssg, "i").WithArguments("x.cly.i").WithLocation(13, 13),
+                Diagnostic(ErrorCode.WRN_UnreferencedField, "i").WithArguments("x.cly.i").WithLocation(13, 13),
                 // (15,20): warning CS0414: The field 'cly.s' is assigned but its value is never used
                 //         static int s = 2;    // no error
                 Diagnostic(ErrorCode.WRN_UnreferencedFieldAssg, "s").WithArguments("x.cly.s").WithLocation(15, 20));

From e8a47642ec687648fece6a7fac4aa7dbaf9ed620 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Wed, 5 Jan 2022 16:20:55 -0800
Subject: [PATCH 259/444] Move suggestion mode configuration to state reset
 service

---
 .../AbstractEditorTest.cs                     |  2 --
 .../AbstractIntegrationTest.cs                |  1 -
 .../InProcess/EditorInProcess.cs              | 35 +++++++++++++------
 .../InProcess/StateResetInProcess.cs          | 13 +++----
 4 files changed, 28 insertions(+), 23 deletions(-)

diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/AbstractEditorTest.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/AbstractEditorTest.cs
index 92db1c1eb0ec6..4315df2e2ffb2 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/AbstractEditorTest.cs
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/AbstractEditorTest.cs
@@ -7,7 +7,6 @@
 using Microsoft.VisualStudio.IntegrationTest.Utilities;
 using Roslyn.Test.Utilities;
 using Roslyn.Utilities;
-using Roslyn.VisualStudio.IntegrationTests.InProcess;
 
 namespace Roslyn.VisualStudio.IntegrationTests
 {
@@ -52,7 +51,6 @@ not WellKnownProjectTemplates.WpfApplication and
                     not WellKnownProjectTemplates.CSharpNetCoreClassLibrary and
                     not WellKnownProjectTemplates.VisualBasicNetCoreClassLibrary)
                 {
-                    await TestServices.Editor.SetUseSuggestionModeAsync(false, HangMitigatingCancellationToken);
                     await ClearEditorAsync(HangMitigatingCancellationToken);
                 }
             }
diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/AbstractIntegrationTest.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/AbstractIntegrationTest.cs
index daffce0aa899a..6f9b4f7b8d3e1 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/AbstractIntegrationTest.cs
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/AbstractIntegrationTest.cs
@@ -4,7 +4,6 @@
 
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.Extensibility.Testing;
-using Roslyn.VisualStudio.IntegrationTests.InProcess;
 using Xunit;
 
 namespace Roslyn.VisualStudio.IntegrationTests
diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/EditorInProcess.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/EditorInProcess.cs
index 37c69d509cf96..52d868cd329e8 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/EditorInProcess.cs
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/EditorInProcess.cs
@@ -78,14 +78,19 @@ public async Task<bool> IsUseSuggestionModeOnAsync(CancellationToken cancellatio
             await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
 
             var textView = await GetActiveTextViewAsync(cancellationToken);
+            return await IsUseSuggestionModeOnAsync(forDebuggerTextView: IsDebuggerTextView(textView), cancellationToken);
+        }
 
-            var subjectBuffer = textView.GetBufferContainingCaret();
-            Assumes.Present(subjectBuffer);
+        public async Task<bool> IsUseSuggestionModeOnAsync(bool forDebuggerTextView, CancellationToken cancellationToken)
+        {
+            await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+
+            var editorOptionsFactory = await GetComponentModelServiceAsync<IEditorOptionsFactoryService>(cancellationToken);
+            var options = editorOptionsFactory.GlobalOptions;
 
-            var options = textView.Options.GlobalOptions;
             EditorOptionKey<bool> optionKey;
             bool defaultOption;
-            if (IsDebuggerTextView(textView))
+            if (forDebuggerTextView)
             {
                 optionKey = new EditorOptionKey<bool>(PredefinedCompletionNames.SuggestionModeInDebuggerCompletionOptionName);
                 defaultOption = true;
@@ -102,19 +107,24 @@ public async Task<bool> IsUseSuggestionModeOnAsync(CancellationToken cancellatio
             }
 
             return options.GetOptionValue(optionKey);
-
-            static bool IsDebuggerTextView(IWpfTextView textView)
-                => textView.Roles.Contains("DEBUGVIEW");
         }
 
         public async Task SetUseSuggestionModeAsync(bool value, CancellationToken cancellationToken)
         {
-            if (await IsUseSuggestionModeOnAsync(cancellationToken) != value)
+            await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+
+            var textView = await GetActiveTextViewAsync(cancellationToken);
+            await SetUseSuggestionModeAsync(forDebuggerTextView: IsDebuggerTextView(textView), value, cancellationToken);
+        }
+
+        public async Task SetUseSuggestionModeAsync(bool forDebuggerTextView, bool value, CancellationToken cancellationToken)
+        {
+            if (await IsUseSuggestionModeOnAsync(forDebuggerTextView, cancellationToken) != value)
             {
                 var dispatcher = await GetRequiredGlobalServiceAsync<SUIHostCommandDispatcher, IOleCommandTarget>(cancellationToken);
                 ErrorHandler.ThrowOnFailure(dispatcher.Exec(typeof(VSConstants.VSStd2KCmdID).GUID, (uint)VSConstants.VSStd2KCmdID.ToggleConsumeFirstCompletionMode, (uint)OLECMDEXECOPT.OLECMDEXECOPT_DODEFAULT, IntPtr.Zero, IntPtr.Zero));
 
-                if (await IsUseSuggestionModeOnAsync(cancellationToken) != value)
+                if (await IsUseSuggestionModeOnAsync(forDebuggerTextView, cancellationToken) != value)
                 {
                     throw new InvalidOperationException($"{WellKnownCommandNames.Edit_ToggleCompletionMode} did not leave the editor in the expected state.");
                 }
@@ -126,8 +136,8 @@ public async Task SetUseSuggestionModeAsync(bool value, CancellationToken cancel
                 // integration tests run slowly.
                 await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
 
-                var view = await GetActiveTextViewAsync(cancellationToken);
-                var options = view.Options.GlobalOptions;
+                var editorOptionsFactory = await GetComponentModelServiceAsync<IEditorOptionsFactoryService>(cancellationToken);
+                var options = editorOptionsFactory.GlobalOptions;
                 options.SetOptionValue(DefaultOptions.ResponsiveCompletionOptionId, false);
 
                 var latencyGuardOptionKey = new EditorOptionKey<bool>("EnableTypingLatencyGuard");
@@ -135,6 +145,9 @@ public async Task SetUseSuggestionModeAsync(bool value, CancellationToken cancel
             }
         }
 
+        private static bool IsDebuggerTextView(ITextView textView)
+            => textView.Roles.Contains("DEBUGVIEW");
+
         #region Navigation bars
 
         public async Task ExpandNavigationBarAsync(NavigationBarDropdownKind index, CancellationToken cancellationToken)
diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/StateResetInProcess.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/StateResetInProcess.cs
index 08daa1cac3fb0..c040870b6303b 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/StateResetInProcess.cs
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/StateResetInProcess.cs
@@ -2,17 +2,12 @@
 // 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.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Editor.Options;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.VisualStudio.Extensibility.Testing;
-using Microsoft.VisualStudio.LanguageServices;
 
 namespace Roslyn.VisualStudio.IntegrationTests.InProcess
 {
@@ -25,11 +20,11 @@ public async Task ResetGlobalOptionsAsync(CancellationToken cancellationToken)
             globalOptions.SetGlobalOption(new OptionKey(NavigationBarViewOptions.ShowNavigationBar, LanguageNames.CSharp), true);
         }
 
-        public Task ResetHostSettingsAsync(CancellationToken cancellationToken)
+        public async Task ResetHostSettingsAsync(CancellationToken cancellationToken)
         {
-            _ = cancellationToken;
-
-            return Task.CompletedTask;
+            // Suggestion mode defaults to on for debugger views, and off for other views.
+            await TestServices.Editor.SetUseSuggestionModeAsync(forDebuggerTextView: true, true, cancellationToken);
+            await TestServices.Editor.SetUseSuggestionModeAsync(forDebuggerTextView: false, false, cancellationToken);
         }
     }
 }

From 1b2c4929b000539de8e300727fc46b18be85c220 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Thu, 6 Jan 2022 13:28:18 -0800
Subject: [PATCH 260/444] Update test

---
 .../CSharp/Portable/Parser/LanguageParser.cs  |  39 +++--
 .../Parsing/LambdaParameterParsingTests.cs    | 155 ++++++++----------
 2 files changed, 98 insertions(+), 96 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
index 83fb8dbdc83c6..903e4b0aaf8a9 100644
--- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
+++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
@@ -11671,17 +11671,21 @@ private bool ScanExplicitlyTypedLambda(Precedence precedence)
                         return false;
                     }
 
+                    // eat the parameter name.
                     if (this.IsTrueIdentifier())
                     {
-                        // eat the identifier
-                        this.EatToken();
-                    }
-                    if (this.CurrentToken.Kind == SyntaxKind.ExclamationToken
-                        && this.PeekToken(1).Kind == SyntaxKind.ExclamationToken)
-                    {
-                        this.EatToken();
                         this.EatToken();
                     }
+
+                    // eat a !! if present.
+                    this.ParseParameterNullCheck(out _, out var equalsToken);
+                    equalsToken ??= TryEatToken(SyntaxKind.EqualsToken);
+
+                    // If we have an `=` then parse out a default value.  Note: this is not legal, but this allows us to
+                    // to be resilient to the user writing this so we don't go completely off the rails.
+                    if (equalsToken != null)
+                        this.ParseExpressionCore();
+
                     switch (this.CurrentToken.Kind)
                     {
                         case SyntaxKind.CommaToken:
@@ -13105,10 +13109,23 @@ private ParameterSyntax ParseLambdaParameter()
             var identifier = this.ParseIdentifierToken();
             ParseParameterNullCheck(out var exclamationExclamationToken, out var equalsToken);
 
-            // 'equalsToken' should always be null here. Otherwise, it means while we were scanning
-            // for potential lambdas, we saw an `!!=` or `!=` sign in the parameter list and allowed
-            // it. However, that should never happen as ScanParenthesizedLambda only allows !! only.
-            Debug.Assert(equalsToken == null);
+            // If we didn't already consume an equals sign as part of !!=, then try to scan one out now. Note: this is
+            // not legal code.  But we detect it so that we can give the user a good message, and so we don't completely
+            // off the rails.
+            //
+            // Note: we add the `= value` as skipped trivia to either the identifier or `!!` (if we have the latter).
+            // This allows us to handle this code without ever showing it the binding phases.  We could consider
+            // actually binding this in the future if it would be helpful and if we're ok paying the testing cost of
+            // checking this at the semantic layers.
+            equalsToken ??= TryEatToken(SyntaxKind.EqualsToken);
+
+            if (equalsToken != null)
+            {
+                equalsToken = AddError(equalsToken, ErrorCode.ERR_DefaultValueNotAllowed);
+
+                ref var nodeToAttachTo = ref exclamationExclamationToken != null ? ref exclamationExclamationToken : ref identifier;
+                nodeToAttachTo = AddTrailingSkippedSyntax(nodeToAttachTo, _syntaxFactory.EqualsValueClause(equalsToken, this.ParseExpressionCore()));
+            }
 
             var parameter = _syntaxFactory.Parameter(attributes, modifiers.ToList(), paramType, identifier, exclamationExclamationToken, @default: null);
             _pool.Free(modifiers);
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
index 2fee51e71946b..db23ea050c280 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
@@ -2388,9 +2388,9 @@ public void TestNullCheckedDefaultValueSimpleLambda()
         public void TestNullCheckedDefaultValueParenthesizedLamda1()
         {
             UsingDeclaration("Func<string, string> func0 = (x!! = null) => x;", options: TestOptions.RegularPreview,
-                    // (1,43): error CS1003: Syntax error, ',' expected
+                    // (1,35): error CS1065: Default values are not valid in this context.
                     // Func<string, string> func0 = (x!! = null) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 43));
+                    Diagnostic(ErrorCode.ERR_DefaultValueNotAllowed, "=").WithLocation(1, 35));
             N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
@@ -2419,30 +2419,23 @@ public void TestNullCheckedDefaultValueParenthesizedLamda1()
                         N(SyntaxKind.EqualsValueClause);
                         {
                             N(SyntaxKind.EqualsToken);
-                            N(SyntaxKind.ParenthesizedExpression);
+                            N(SyntaxKind.ParenthesizedLambdaExpression);
                             {
-                                N(SyntaxKind.OpenParenToken);
-                                N(SyntaxKind.SimpleAssignmentExpression);
+                                N(SyntaxKind.ParameterList);
                                 {
-                                    N(SyntaxKind.SuppressNullableWarningExpression);
-                                    {
-                                        N(SyntaxKind.SuppressNullableWarningExpression);
-                                        {
-                                            N(SyntaxKind.IdentifierName);
-                                            {
-                                                N(SyntaxKind.IdentifierToken, "x");
-                                            }
-                                            N(SyntaxKind.ExclamationToken);
-                                        }
-                                        N(SyntaxKind.ExclamationToken);
-                                    }
-                                    N(SyntaxKind.EqualsToken);
-                                    N(SyntaxKind.NullLiteralExpression);
+                                    N(SyntaxKind.OpenParenToken);
+                                    N(SyntaxKind.Parameter);
                                     {
-                                        N(SyntaxKind.NullKeyword);
+                                        N(SyntaxKind.IdentifierToken, "x");
+                                        N(SyntaxKind.ExclamationExclamationToken);
                                     }
+                                    N(SyntaxKind.CloseParenToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
                                 }
-                                N(SyntaxKind.CloseParenToken);
                             }
                         }
                     }
@@ -2456,9 +2449,9 @@ public void TestNullCheckedDefaultValueParenthesizedLamda1()
         public void TestNullCheckedDefaultValueParenthesizedLamda2()
         {
             UsingDeclaration("Func<string, string> func0 = (y, x!! = null) => x;", options: TestOptions.RegularPreview,
-                    // (1,46): error CS1003: Syntax error, ',' expected
+                    // (1,38): error CS1065: Default values are not valid in this context.
                     // Func<string, string> func0 = (y, x!! = null) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 46));
+                    Diagnostic(ErrorCode.ERR_DefaultValueNotAllowed, "=").WithLocation(1, 38));
             N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
@@ -2487,41 +2480,28 @@ public void TestNullCheckedDefaultValueParenthesizedLamda2()
                         N(SyntaxKind.EqualsValueClause);
                         {
                             N(SyntaxKind.EqualsToken);
-                            N(SyntaxKind.TupleExpression);
+                            N(SyntaxKind.ParenthesizedLambdaExpression);
                             {
-                                N(SyntaxKind.OpenParenToken);
-                                N(SyntaxKind.Argument);
+                                N(SyntaxKind.ParameterList);
                                 {
-                                    N(SyntaxKind.IdentifierName);
+                                    N(SyntaxKind.OpenParenToken);
+                                    N(SyntaxKind.Parameter);
                                     {
                                         N(SyntaxKind.IdentifierToken, "y");
                                     }
-                                }
-                                N(SyntaxKind.CommaToken);
-                                N(SyntaxKind.Argument);
-                                {
-                                    N(SyntaxKind.SimpleAssignmentExpression);
+                                    N(SyntaxKind.CommaToken);
+                                    N(SyntaxKind.Parameter);
                                     {
-                                        N(SyntaxKind.SuppressNullableWarningExpression);
-                                        {
-                                            N(SyntaxKind.SuppressNullableWarningExpression);
-                                            {
-                                                N(SyntaxKind.IdentifierName);
-                                                {
-                                                    N(SyntaxKind.IdentifierToken, "x");
-                                                }
-                                                N(SyntaxKind.ExclamationToken);
-                                            }
-                                            N(SyntaxKind.ExclamationToken);
-                                        }
-                                        N(SyntaxKind.EqualsToken);
-                                        N(SyntaxKind.NullLiteralExpression);
-                                        {
-                                            N(SyntaxKind.NullKeyword);
-                                        }
+                                        N(SyntaxKind.IdentifierToken, "x");
+                                        N(SyntaxKind.ExclamationExclamationToken);
                                     }
+                                    N(SyntaxKind.CloseParenToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
                                 }
-                                N(SyntaxKind.CloseParenToken);
                             }
                         }
                     }
@@ -2535,15 +2515,9 @@ public void TestNullCheckedDefaultValueParenthesizedLamda2()
         public void TestNullCheckedDefaultValueParenthesizedLamdaWithType1()
         {
             UsingDeclaration("Func<string, string> func0 = (string x!! = null) => x;", options: TestOptions.RegularPreview,
-                    // (1,31): error CS1525: Invalid expression term 'string'
-                    // Func<string, string> func0 = (string x!! = null) => x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "string").WithArguments("string").WithLocation(1, 31),
-                    // (1,38): error CS1026: ) expected
-                    // Func<string, string> func0 = (string x!! = null) => x;
-                    Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 38),
-                    // (1,38): error CS1003: Syntax error, ',' expected
+                    // (1,42): error CS1065: Default values are not valid in this context.
                     // Func<string, string> func0 = (string x!! = null) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 38));
+                    Diagnostic(ErrorCode.ERR_DefaultValueNotAllowed, "=").WithLocation(1, 42));
             N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
@@ -2572,14 +2546,27 @@ public void TestNullCheckedDefaultValueParenthesizedLamdaWithType1()
                         N(SyntaxKind.EqualsValueClause);
                         {
                             N(SyntaxKind.EqualsToken);
-                            N(SyntaxKind.ParenthesizedExpression);
+                            N(SyntaxKind.ParenthesizedLambdaExpression);
                             {
-                                N(SyntaxKind.OpenParenToken);
-                                N(SyntaxKind.PredefinedType);
+                                N(SyntaxKind.ParameterList);
                                 {
-                                    N(SyntaxKind.StringKeyword);
+                                    N(SyntaxKind.OpenParenToken);
+                                    N(SyntaxKind.Parameter);
+                                    {
+                                        N(SyntaxKind.PredefinedType);
+                                        {
+                                            N(SyntaxKind.StringKeyword);
+                                        }
+                                        N(SyntaxKind.IdentifierToken, "x");
+                                        N(SyntaxKind.ExclamationExclamationToken);
+                                    }
+                                    N(SyntaxKind.CloseParenToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
                                 }
-                                M(SyntaxKind.CloseParenToken);
                             }
                         }
                     }
@@ -2593,15 +2580,9 @@ public void TestNullCheckedDefaultValueParenthesizedLamdaWithType1()
         public void TestNullCheckedDefaultValueParenthesizedLamdaWithType2()
         {
             UsingDeclaration("Func<string, string> func0 = (string y, string x!! = null) => x;", options: TestOptions.RegularPreview,
-                // (1,41): error CS1525: Invalid expression term 'string'
-                // Func<string, string> func0 = (string y, string x!! = null) => x;
-                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "string").WithArguments("string").WithLocation(1, 41),
-                // (1,48): error CS1026: ) expected
-                // Func<string, string> func0 = (string y, string x!! = null) => x;
-                Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 48),
-                // (1,48): error CS1003: Syntax error, ',' expected
-                // Func<string, string> func0 = (string y, string x!! = null) => x;
-                Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 48));
+                    // (1,52): error CS1065: Default values are not valid in this context.
+                    // Func<string, string> func0 = (string y, string x!! = null) => x;
+                    Diagnostic(ErrorCode.ERR_DefaultValueNotAllowed, "=").WithLocation(1, 52));
             N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
@@ -2630,32 +2611,36 @@ public void TestNullCheckedDefaultValueParenthesizedLamdaWithType2()
                         N(SyntaxKind.EqualsValueClause);
                         {
                             N(SyntaxKind.EqualsToken);
-                            N(SyntaxKind.TupleExpression);
+                            N(SyntaxKind.ParenthesizedLambdaExpression);
                             {
-                                N(SyntaxKind.OpenParenToken);
-                                N(SyntaxKind.Argument);
+                                N(SyntaxKind.ParameterList);
                                 {
-                                    N(SyntaxKind.DeclarationExpression);
+                                    N(SyntaxKind.OpenParenToken);
+                                    N(SyntaxKind.Parameter);
                                     {
                                         N(SyntaxKind.PredefinedType);
                                         {
                                             N(SyntaxKind.StringKeyword);
                                         }
-                                        N(SyntaxKind.SingleVariableDesignation);
+                                        N(SyntaxKind.IdentifierToken, "y");
+                                    }
+                                    N(SyntaxKind.CommaToken);
+                                    N(SyntaxKind.Parameter);
+                                    {
+                                        N(SyntaxKind.PredefinedType);
                                         {
-                                            N(SyntaxKind.IdentifierToken, "y");
+                                            N(SyntaxKind.StringKeyword);
                                         }
+                                        N(SyntaxKind.IdentifierToken, "x");
+                                        N(SyntaxKind.ExclamationExclamationToken);
                                     }
+                                    N(SyntaxKind.CloseParenToken);
                                 }
-                                N(SyntaxKind.CommaToken);
-                                N(SyntaxKind.Argument);
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
                                 {
-                                    N(SyntaxKind.PredefinedType);
-                                    {
-                                        N(SyntaxKind.StringKeyword);
-                                    }
+                                    N(SyntaxKind.IdentifierToken, "x");
                                 }
-                                M(SyntaxKind.CloseParenToken);
                             }
                         }
                     }

From 49825a49cabb9b487844c8c09051039ec9de98e9 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Thu, 6 Jan 2022 14:04:30 -0800
Subject: [PATCH 261/444] Add tests

---
 .../CSharp/Portable/Parser/LanguageParser.cs  |   5 +-
 .../Parsing/LambdaParameterParsingTests.cs    | 133 +++++++++---------
 2 files changed, 69 insertions(+), 69 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
index 903e4b0aaf8a9..0393584674aba 100644
--- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
+++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
@@ -13165,6 +13165,8 @@ private bool ShouldParseLambdaParameterType(bool hasModifier)
                 //      (a)
                 //      (a =>
                 //      (a {
+                //      (a !!    or    (a !!=
+                //      (a =
                 //
                 // In all other cases, parse out a type.
                 var peek1 = this.PeekToken(1);
@@ -13172,7 +13174,8 @@ private bool ShouldParseLambdaParameterType(bool hasModifier)
                     peek1.Kind != SyntaxKind.CloseParenToken &&
                     peek1.Kind != SyntaxKind.EqualsGreaterThanToken &&
                     peek1.Kind != SyntaxKind.OpenBraceToken &&
-                    peek1.Kind != SyntaxKind.ExclamationToken)
+                    peek1.Kind != SyntaxKind.ExclamationToken &&
+                    peek1.Kind != SyntaxKind.EqualsToken)
                 {
                     return true;
                 }
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
index db23ea050c280..947ab7d870ac6 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
@@ -2060,9 +2060,9 @@ public void TestDefaultValueSimpleLambda()
         public void TestDefaultValueParenthesizedLamda1()
         {
             UsingDeclaration("Func<string, string> func0 = (x = null) => x;", options: TestOptions.RegularPreview,
-                    // (1,41): error CS1003: Syntax error, ',' expected
-                    // Func<string, string> func0 = (x = null) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 41));
+                // (1,33): error CS1065: Default values are not valid in this context.
+                // Func<string, string> func0 = (x = null) => x;
+                Diagnostic(ErrorCode.ERR_DefaultValueNotAllowed, "=").WithLocation(1, 33));
             N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
@@ -2091,22 +2091,22 @@ public void TestDefaultValueParenthesizedLamda1()
                         N(SyntaxKind.EqualsValueClause);
                         {
                             N(SyntaxKind.EqualsToken);
-                            N(SyntaxKind.ParenthesizedExpression);
+                            N(SyntaxKind.ParenthesizedLambdaExpression);
                             {
-                                N(SyntaxKind.OpenParenToken);
-                                N(SyntaxKind.SimpleAssignmentExpression);
+                                N(SyntaxKind.ParameterList);
                                 {
-                                    N(SyntaxKind.IdentifierName);
+                                    N(SyntaxKind.OpenParenToken);
+                                    N(SyntaxKind.Parameter);
                                     {
                                         N(SyntaxKind.IdentifierToken, "x");
                                     }
-                                    N(SyntaxKind.EqualsToken);
-                                    N(SyntaxKind.NullLiteralExpression);
-                                    {
-                                        N(SyntaxKind.NullKeyword);
-                                    }
+                                    N(SyntaxKind.CloseParenToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
                                 }
-                                N(SyntaxKind.CloseParenToken);
                             }
                         }
                     }
@@ -2120,9 +2120,9 @@ public void TestDefaultValueParenthesizedLamda1()
         public void TestDefaultValueParenthesizedLamda2()
         {
             UsingDeclaration("Func<string, string> func0 = (y, x = null) => x;", options: TestOptions.RegularPreview,
-                    // (1,44): error CS1003: Syntax error, ',' expected
+                    // (1,36): error CS1065: Default values are not valid in this context.
                     // Func<string, string> func0 = (y, x = null) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 44));
+                    Diagnostic(ErrorCode.ERR_DefaultValueNotAllowed, "=").WithLocation(1, 36));
             N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
@@ -2151,33 +2151,27 @@ public void TestDefaultValueParenthesizedLamda2()
                         N(SyntaxKind.EqualsValueClause);
                         {
                             N(SyntaxKind.EqualsToken);
-                            N(SyntaxKind.TupleExpression);
+                            N(SyntaxKind.ParenthesizedLambdaExpression);
                             {
-                                N(SyntaxKind.OpenParenToken);
-                                N(SyntaxKind.Argument);
+                                N(SyntaxKind.ParameterList);
                                 {
-                                    N(SyntaxKind.IdentifierName);
+                                    N(SyntaxKind.OpenParenToken);
+                                    N(SyntaxKind.Parameter);
                                     {
                                         N(SyntaxKind.IdentifierToken, "y");
                                     }
-                                }
-                                N(SyntaxKind.CommaToken);
-                                N(SyntaxKind.Argument);
-                                {
-                                    N(SyntaxKind.SimpleAssignmentExpression);
+                                    N(SyntaxKind.CommaToken);
+                                    N(SyntaxKind.Parameter);
                                     {
-                                        N(SyntaxKind.IdentifierName);
-                                        {
-                                            N(SyntaxKind.IdentifierToken, "x");
-                                        }
-                                        N(SyntaxKind.EqualsToken);
-                                        N(SyntaxKind.NullLiteralExpression);
-                                        {
-                                            N(SyntaxKind.NullKeyword);
-                                        }
+                                        N(SyntaxKind.IdentifierToken, "x");
                                     }
+                                    N(SyntaxKind.CloseParenToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
                                 }
-                                N(SyntaxKind.CloseParenToken);
                             }
                         }
                     }
@@ -2191,15 +2185,9 @@ public void TestDefaultValueParenthesizedLamda2()
         public void TestDefaultValueParenthesizedLamdaWithType1()
         {
             UsingDeclaration("Func<string, string> func0 = (string x = null) => x;", options: TestOptions.RegularPreview,
-                    // (1,31): error CS1525: Invalid expression term 'string'
-                    // Func<string, string> func0 = (string x = null) => x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "string").WithArguments("string").WithLocation(1, 31),
-                    // (1,38): error CS1026: ) expected
-                    // Func<string, string> func0 = (string x = null) => x;
-                    Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 38),
-                    // (1,38): error CS1003: Syntax error, ',' expected
+                    // (1,40): error CS1065: Default values are not valid in this context.
                     // Func<string, string> func0 = (string x = null) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 38));
+                    Diagnostic(ErrorCode.ERR_DefaultValueNotAllowed, "=").WithLocation(1, 40));
             N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
@@ -2228,14 +2216,26 @@ public void TestDefaultValueParenthesizedLamdaWithType1()
                         N(SyntaxKind.EqualsValueClause);
                         {
                             N(SyntaxKind.EqualsToken);
-                            N(SyntaxKind.ParenthesizedExpression);
+                            N(SyntaxKind.ParenthesizedLambdaExpression);
                             {
-                                N(SyntaxKind.OpenParenToken);
-                                N(SyntaxKind.PredefinedType);
+                                N(SyntaxKind.ParameterList);
                                 {
-                                    N(SyntaxKind.StringKeyword);
+                                    N(SyntaxKind.OpenParenToken);
+                                    N(SyntaxKind.Parameter);
+                                    {
+                                        N(SyntaxKind.PredefinedType);
+                                        {
+                                            N(SyntaxKind.StringKeyword);
+                                        }
+                                        N(SyntaxKind.IdentifierToken, "x");
+                                    }
+                                    N(SyntaxKind.CloseParenToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
                                 }
-                                M(SyntaxKind.CloseParenToken);
                             }
                         }
                     }
@@ -2249,15 +2249,9 @@ public void TestDefaultValueParenthesizedLamdaWithType1()
         public void TestDefaultValueParenthesizedLamdaWithType2()
         {
             UsingDeclaration("Func<string, string> func0 = (string y, string x = null) => x;", options: TestOptions.RegularPreview,
-                    // (1,41): error CS1525: Invalid expression term 'string'
+                    // (1,50): error CS1065: Default values are not valid in this context.
                     // Func<string, string> func0 = (string y, string x = null) => x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "string").WithArguments("string").WithLocation(1, 41),
-                    // (1,48): error CS1026: ) expected
-                    // Func<string, string> func0 = (string y, string x = null) => x;
-                    Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 48),
-                    // (1,48): error CS1003: Syntax error, ',' expected
-                    // Func<string, string> func0 = (string y, string x = null) => x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 48));
+                    Diagnostic(ErrorCode.ERR_DefaultValueNotAllowed, "=").WithLocation(1, 50));
             N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
@@ -2286,32 +2280,35 @@ public void TestDefaultValueParenthesizedLamdaWithType2()
                         N(SyntaxKind.EqualsValueClause);
                         {
                             N(SyntaxKind.EqualsToken);
-                            N(SyntaxKind.TupleExpression);
+                            N(SyntaxKind.ParenthesizedLambdaExpression);
                             {
-                                N(SyntaxKind.OpenParenToken);
-                                N(SyntaxKind.Argument);
+                                N(SyntaxKind.ParameterList);
                                 {
-                                    N(SyntaxKind.DeclarationExpression);
+                                    N(SyntaxKind.OpenParenToken);
+                                    N(SyntaxKind.Parameter);
                                     {
                                         N(SyntaxKind.PredefinedType);
                                         {
                                             N(SyntaxKind.StringKeyword);
                                         }
-                                        N(SyntaxKind.SingleVariableDesignation);
+                                        N(SyntaxKind.IdentifierToken, "y");
+                                    }
+                                    N(SyntaxKind.CommaToken);
+                                    N(SyntaxKind.Parameter);
+                                    {
+                                        N(SyntaxKind.PredefinedType);
                                         {
-                                            N(SyntaxKind.IdentifierToken, "y");
+                                            N(SyntaxKind.StringKeyword);
                                         }
+                                        N(SyntaxKind.IdentifierToken, "x");
                                     }
+                                    N(SyntaxKind.CloseParenToken);
                                 }
-                                N(SyntaxKind.CommaToken);
-                                N(SyntaxKind.Argument);
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
                                 {
-                                    N(SyntaxKind.PredefinedType);
-                                    {
-                                        N(SyntaxKind.StringKeyword);
-                                    }
+                                    N(SyntaxKind.IdentifierToken, "x");
                                 }
-                                M(SyntaxKind.CloseParenToken);
                             }
                         }
                     }

From e79b92ec681e5fb05c63878e1b5b611969d11619 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: Thu, 6 Jan 2022 14:16:47 -0800
Subject: [PATCH 262/444] Call InitializeTelemetrySession on background thread
 (#58399) (#58674)

---
 .../VisualStudioWorkspaceImpl.cs              | 20 +++++++++++++++++++
 src/VisualStudio/Core/Def/RoslynPackage.cs    | 10 ----------
 2 files changed, 20 insertions(+), 10 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
index 3005c1111fee6..438705020b740 100644
--- a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
+++ b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
@@ -19,11 +19,13 @@
 using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Shared.Utilities;
+using Microsoft.CodeAnalysis.Telemetry;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.ComponentModelHost;
 using Microsoft.VisualStudio.Composition;
@@ -33,11 +35,14 @@
 using Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem.MetadataReferences;
 using Microsoft.VisualStudio.LanguageServices.Implementation.TaskList;
 using Microsoft.VisualStudio.LanguageServices.Implementation.Venus;
+using Microsoft.VisualStudio.LanguageServices.Telemetry;
 using Microsoft.VisualStudio.LanguageServices.Utilities;
 using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Shell.Interop;
+using Microsoft.VisualStudio.Telemetry;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Projection;
+using Microsoft.VisualStudio.Threading;
 using Roslyn.Utilities;
 using VSLangProj;
 using VSLangProj140;
@@ -197,6 +202,12 @@ public async Task InitializeUIAffinitizedServicesAsync(IAsyncServiceProvider asy
             // Create services that are bound to the UI thread
             await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(_threadingContext.DisposalToken);
 
+            // Fetch the session synchronously on the UI thread; if this doesn't happen before we try using this on
+            // the background thread then we will experience hangs like we see in this bug:
+            // https://devdiv.visualstudio.com/DefaultCollection/DevDiv/_workitems?_a=edit&id=190808 or
+            // https://devdiv.visualstudio.com/DevDiv/_workitems?id=296981&_a=edit
+            var telemetrySession = TelemetryService.DefaultSession;
+
             var solutionClosingContext = UIContext.FromUIContextGuid(VSConstants.UICONTEXT.SolutionClosing_guid);
             solutionClosingContext.UIContextChanged += (_, e) => _solutionClosing = e.Activated;
 
@@ -215,6 +226,15 @@ public async Task InitializeUIAffinitizedServicesAsync(IAsyncServiceProvider asy
             await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(_threadingContext.DisposalToken);
 
             openFileTracker.ProcessQueuedWorkOnUIThread();
+
+            // Switch to a background thread to avoid loading option providers on UI thread (telemetry is reading options).
+            await TaskScheduler.Default;
+
+            var telemetryService = (VisualStudioWorkspaceTelemetryService)Services.GetRequiredService<IWorkspaceTelemetryService>();
+            telemetryService.InitializeTelemetrySession(telemetrySession);
+
+            Logger.Log(FunctionId.Run_Environment,
+                KeyValueLogMessage.Create(m => m["Version"] = FileVersionInfo.GetVersionInfo(typeof(VisualStudioWorkspace).Assembly.Location).FileVersion));
         }
 
         public void QueueCheckForFilesBeingOpen(ImmutableArray<string> newFileNames)
diff --git a/src/VisualStudio/Core/Def/RoslynPackage.cs b/src/VisualStudio/Core/Def/RoslynPackage.cs
index 20b0357de6aca..3b8914b47e096 100644
--- a/src/VisualStudio/Core/Def/RoslynPackage.cs
+++ b/src/VisualStudio/Core/Def/RoslynPackage.cs
@@ -157,16 +157,6 @@ protected override async Task InitializeAsync(CancellationToken cancellationToke
 
             _workspace = this.ComponentModel.GetService<VisualStudioWorkspace>();
 
-            // Fetch the session synchronously on the UI thread; if this doesn't happen before we try using this on
-            // the background thread then we will experience hangs like we see in this bug:
-            // https://devdiv.visualstudio.com/DefaultCollection/DevDiv/_workitems?_a=edit&id=190808 or
-            // https://devdiv.visualstudio.com/DevDiv/_workitems?id=296981&_a=edit
-            var telemetryService = (VisualStudioWorkspaceTelemetryService)_workspace.Services.GetRequiredService<IWorkspaceTelemetryService>();
-            telemetryService.InitializeTelemetrySession(TelemetryService.DefaultSession);
-
-            Logger.Log(FunctionId.Run_Environment,
-                KeyValueLogMessage.Create(m => m["Version"] = FileVersionInfo.GetVersionInfo(typeof(VisualStudioWorkspace).Assembly.Location).FileVersion));
-
             InitializeColors();
 
             // load some services that have to be loaded in UI thread

From d43e2ff3d764ac4f3206ff31186e5c2269820a0e Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Thu, 6 Jan 2022 15:49:02 -0800
Subject: [PATCH 263/444] Insert casts to ensure that runtime types (And
 values) are not impacted when converting switch to expression

---
 ...entToExpressionCodeFixProvider.Rewriter.cs | 90 +++++++++++++------
 ...tchStatementToExpressionCodeFixProvider.cs |  4 +-
 ...ConvertSwitchStatementToExpressionTests.cs | 72 +++++++++++++++
 3 files changed, 135 insertions(+), 31 deletions(-)

diff --git a/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.Rewriter.cs b/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.Rewriter.cs
index a2025f8344208..90a588cf3117f 100644
--- a/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.Rewriter.cs
+++ b/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.Rewriter.cs
@@ -2,15 +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.
 
-#nullable disable
-
-using System;
 using System.Diagnostics;
 using System.Linq;
+using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Formatting;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.ConvertSwitchStatementToExpression
@@ -22,12 +20,18 @@ internal sealed partial class ConvertSwitchStatementToExpressionCodeFixProvider
     {
         private sealed class Rewriter : CSharpSyntaxVisitor<ExpressionSyntax>
         {
+            private readonly SemanticModel _semanticModel;
             private readonly bool _isAllThrowStatements;
+            private readonly CancellationToken _cancellationToken;
 
-            private ExpressionSyntax _assignmentTargetOpt;
+            private ExpressionSyntax? _assignmentTargetOpt;
 
-            private Rewriter(bool isAllThrowStatements)
-                => _isAllThrowStatements = isAllThrowStatements;
+            private Rewriter(SemanticModel semanticModel, bool isAllThrowStatements, CancellationToken cancellationToken)
+            {
+                _semanticModel = semanticModel;
+                _isAllThrowStatements = isAllThrowStatements;
+                _cancellationToken = cancellationToken;
+            }
 
             public static StatementSyntax Rewrite(
                 SwitchStatementSyntax switchStatement,
@@ -35,7 +39,8 @@ public static StatementSyntax Rewrite(
                 ITypeSymbol declaratorToRemoveTypeOpt,
                 SyntaxKind nodeToGenerate,
                 bool shouldMoveNextStatementToSwitchExpression,
-                bool generateDeclaration)
+                bool generateDeclaration,
+                CancellationToken cancellationToken)
             {
                 if (switchStatement.ContainsDirectives)
                 {
@@ -43,10 +48,11 @@ public static StatementSyntax Rewrite(
                     return switchStatement;
                 }
 
-                var rewriter = new Rewriter(isAllThrowStatements: nodeToGenerate == SyntaxKind.ThrowStatement);
+                var rewriter = new Rewriter(model, isAllThrowStatements: nodeToGenerate == SyntaxKind.ThrowStatement, cancellationToken);
 
                 // Rewrite the switch statement as a switch expression.
-                var switchExpression = rewriter.RewriteSwitchStatement(switchStatement, model,
+                var switchExpression = rewriter.RewriteSwitchStatement(
+                    switchStatement, topLevel: true,
                     allowMoveNextStatementToSwitchExpression: shouldMoveNextStatementToSwitchExpression);
 
                 // Generate the final statement to wrap the switch expression, e.g. a "return" or an assignment.
@@ -85,7 +91,7 @@ private StatementSyntax GetFinalStatement(
 
             private ExpressionStatementSyntax GenerateAssignment(ExpressionSyntax switchExpression, SyntaxKind assignmentKind, SyntaxTriviaList leadingTrivia)
             {
-                Debug.Assert(_assignmentTargetOpt != null);
+                Contract.ThrowIfNull(_assignmentTargetOpt);
 
                 return ExpressionStatement(
                     AssignmentExpression(assignmentKind,
@@ -96,12 +102,12 @@ private ExpressionStatementSyntax GenerateAssignment(ExpressionSyntax switchExpr
 
             private StatementSyntax GenerateVariableDeclaration(ExpressionSyntax switchExpression, ITypeSymbol declaratorToRemoveTypeOpt)
             {
-                Debug.Assert(_assignmentTargetOpt is IdentifierNameSyntax);
+                Contract.ThrowIfFalse(_assignmentTargetOpt is IdentifierNameSyntax);
 
                 // There is a probability that we cannot use var if the declaration type is a reference type or nullable type.
                 // In these cases, we generate the explicit type for now and decide later whether or not to use var.
                 var cannotUseVar = declaratorToRemoveTypeOpt != null && (declaratorToRemoveTypeOpt.IsReferenceType || declaratorToRemoveTypeOpt.IsNullable());
-                var type = cannotUseVar ? declaratorToRemoveTypeOpt.GenerateTypeSyntax() : IdentifierName("var");
+                var type = cannotUseVar ? declaratorToRemoveTypeOpt!.GenerateTypeSyntax() : IdentifierName("var");
 
                 return LocalDeclarationStatement(
                     VariableDeclaration(
@@ -121,7 +127,7 @@ private SwitchExpressionArmSyntax GetSwitchExpressionArm(SwitchSectionSyntax nod
                     expression: RewriteStatements(node.Statements));
             }
 
-            private static PatternSyntax GetPattern(SyntaxList<SwitchLabelSyntax> switchLabels, out WhenClauseSyntax whenClauseOpt)
+            private static PatternSyntax GetPattern(SyntaxList<SwitchLabelSyntax> switchLabels, out WhenClauseSyntax? whenClauseOpt)
             {
                 if (switchLabels.Count == 1)
                     return GetPattern(switchLabels[0], out whenClauseOpt);
@@ -149,7 +155,7 @@ private static PatternSyntax GetPattern(SyntaxList<SwitchLabelSyntax> switchLabe
                 return totalPattern;
             }
 
-            private static PatternSyntax GetPattern(SwitchLabelSyntax switchLabel, out WhenClauseSyntax whenClauseOpt)
+            private static PatternSyntax GetPattern(SwitchLabelSyntax switchLabel, out WhenClauseSyntax? whenClauseOpt)
             {
                 switch (switchLabel.Kind())
                 {
@@ -174,22 +180,41 @@ private static PatternSyntax GetPattern(SwitchLabelSyntax switchLabel, out WhenC
             public override ExpressionSyntax VisitAssignmentExpression(AssignmentExpressionSyntax node)
             {
                 _assignmentTargetOpt ??= node.Left;
-                return node.Right;
+                return CastIfChangeInRuntimeRepresentation(node.Right);
+            }
+
+            private ExpressionSyntax CastIfChangeInRuntimeRepresentation(ExpressionSyntax node)
+            {
+                var typeInfo = _semanticModel.GetTypeInfo(node, _cancellationToken);
+                if (typeInfo.ConvertedType is not null &&
+                    typeInfo.Type is not null &&
+                    !Equals(typeInfo.ConvertedType, typeInfo.Type))
+                {
+                    var conversion = _semanticModel.Compilation.ClassifyConversion(typeInfo.Type, typeInfo.ConvertedType);
+                    if (!conversion.IsIdentityOrImplicitReference())
+                        return node.Cast(typeInfo.ConvertedType);
+                }
+
+                return node;
             }
 
             private ExpressionSyntax RewriteStatements(SyntaxList<StatementSyntax> statements)
             {
                 Debug.Assert(statements.Count is 1 or 2);
                 Debug.Assert(!statements[0].IsKind(SyntaxKind.BreakStatement));
-                return Visit(statements[0]);
+                var result = Visit(statements[0]);
+                Contract.ThrowIfNull(result);
+                return result;
             }
 
             public override ExpressionSyntax VisitSwitchStatement(SwitchStatementSyntax node)
-                => RewriteSwitchStatement(node, null);
+                => RewriteSwitchStatement(node, topLevel: false);
 
-            private ExpressionSyntax RewriteSwitchStatement(SwitchStatementSyntax node, SemanticModel model, bool allowMoveNextStatementToSwitchExpression = true)
+            private ExpressionSyntax RewriteSwitchStatement(
+                SwitchStatementSyntax node,
+                bool topLevel,
+                bool allowMoveNextStatementToSwitchExpression = true)
             {
-
                 var switchArms = node.Sections
                     // The default label must come last in the switch expression.
                     .OrderBy(section => section.Labels.Any(label => IsDefaultSwitchLabel(label)))
@@ -204,14 +229,17 @@ private ExpressionSyntax RewriteSwitchStatement(SwitchStatementSyntax node, Sema
                     var nextStatement = node.GetNextStatement();
                     if (nextStatement.IsKind(SyntaxKind.ThrowStatement, SyntaxKind.ReturnStatement))
                     {
+                        var armExpression = Visit(nextStatement);
+                        Contract.ThrowIfNull(armExpression);
+
                         switchArms.Add(
                             (tokensForLeadingTrivia: new[] { nextStatement.GetFirstToken() },
                              tokensForTrailingTrivia: new[] { nextStatement.GetLastToken() },
-                             SwitchExpressionArm(DiscardPattern(), Visit(nextStatement))));
+                             SwitchExpressionArm(DiscardPattern(), armExpression)));
                     }
                 }
                 // add explicit cast if necessary 
-                var switchStatement = AddCastIfNecessary(model, node);
+                var switchStatement = topLevel ? AddCastIfNecessary(node) : node;
 
                 return SwitchExpression(
                     switchStatement.Expression.Parenthesize(),
@@ -223,12 +251,12 @@ private ExpressionSyntax RewriteSwitchStatement(SwitchStatementSyntax node, Sema
                     Token(SyntaxKind.CloseBraceToken));
             }
 
-            private static SwitchStatementSyntax AddCastIfNecessary(SemanticModel model, SwitchStatementSyntax node)
+            private SwitchStatementSyntax AddCastIfNecessary(SwitchStatementSyntax node)
             {
                 // If the swith statement expression is being implicitly converted then we need to explicitly cast the expression
                 // before rewriting as a switch expression
-                var expressionType = model.GetSymbolInfo(node.Expression).Symbol.GetSymbolType();
-                var expressionConvertedType = model.GetTypeInfo(node.Expression).ConvertedType;
+                var expressionType = _semanticModel.GetSymbolInfo(node.Expression).Symbol.GetSymbolType();
+                var expressionConvertedType = _semanticModel.GetTypeInfo(node.Expression).ConvertedType;
 
                 if (expressionConvertedType != null &&
                     !SymbolEqualityComparer.Default.Equals(expressionConvertedType, expressionType))
@@ -244,20 +272,24 @@ private static SwitchStatementSyntax AddCastIfNecessary(SemanticModel model, Swi
 
             public override ExpressionSyntax VisitReturnStatement(ReturnStatementSyntax node)
             {
-                Debug.Assert(node.Expression != null);
-                return node.Expression;
+                Contract.ThrowIfNull(node.Expression);
+                return CastIfChangeInRuntimeRepresentation(node.Expression);
             }
 
             public override ExpressionSyntax VisitThrowStatement(ThrowStatementSyntax node)
             {
-                Debug.Assert(node.Expression != null);
+                Contract.ThrowIfNull(node.Expression);
                 // If this is an all-throw switch statement, we return the expression rather than
                 // creating a throw expression so we can wrap the switch expression inside a throw expression.
                 return _isAllThrowStatements ? node.Expression : ThrowExpression(node.Expression);
             }
 
             public override ExpressionSyntax VisitExpressionStatement(ExpressionStatementSyntax node)
-                => Visit(node.Expression);
+            {
+                var result = Visit(node.Expression);
+                Contract.ThrowIfNull(result);
+                return result;
+            }
 
             public override ExpressionSyntax DefaultVisit(SyntaxNode node)
                 => throw ExceptionUtilities.UnexpectedValue(node.Kind());
diff --git a/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.cs
index df534932a3bdc..f249c69cf6c9c 100644
--- a/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.cs
@@ -21,7 +21,6 @@
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
-using Microsoft.CodeAnalysis.Simplification;
 using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.CodeAnalysis.CSharp.ConvertSwitchStatementToExpression
@@ -97,7 +96,8 @@ protected override async Task FixAllAsync(
                 var switchExpression = Rewriter.Rewrite(
                    switchStatement, semanticModel, declaratorToRemoveTypeOpt, nodeToGenerate,
                    shouldMoveNextStatementToSwitchExpression: shouldRemoveNextStatement,
-                   generateDeclaration: declaratorToRemoveLocationOpt is object);
+                   generateDeclaration: declaratorToRemoveLocationOpt is not null,
+                   cancellationToken);
 
                 editor.ReplaceNode(switchStatement, switchExpression.WithAdditionalAnnotations(Formatter.Annotation));
 
diff --git a/src/Analyzers/CSharp/Tests/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionTests.cs b/src/Analyzers/CSharp/Tests/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionTests.cs
index d60e131fb31e3..8b6143d222b70 100644
--- a/src/Analyzers/CSharp/Tests/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionTests.cs
+++ b/src/Analyzers/CSharp/Tests/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionTests.cs
@@ -2165,6 +2165,78 @@ int M()
             _ => 0,
         };
     }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertSwitchStatementToExpression)]
+        [WorkItem(58636, "https://github.com/dotnet/roslyn/issues/58636")]
+        public async Task TestRuntimeTypeConversion_Assignment1()
+        {
+            await VerifyCS.VerifyCodeFixAsync(
+@"class Program
+{
+    void M(string s)
+    {
+        object result;
+
+        [|switch|] (s)
+        {
+        case ""a"":
+            result = 1234;
+            break;
+        case ""b"":
+            result = 3.14;
+            break;
+        default:
+            throw new System.Exception();
+        }
+    }
+}",
+@"class Program
+{
+    void M(string s)
+    {
+        object result = s switch
+        {
+            ""a"" => 1234,
+            ""b"" => (object)3.14,
+            _ => throw new System.Exception(),
+        };
+    }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertSwitchStatementToExpression)]
+        [WorkItem(58636, "https://github.com/dotnet/roslyn/issues/58636")]
+        public async Task TestRuntimeTypeConversion_Return1()
+        {
+            await VerifyCS.VerifyCodeFixAsync(
+@"class Program
+{
+    object M(string s)
+    {
+        [|switch|] (s)
+        {
+        case ""a"":
+            return 1234;
+        case ""b"":
+            return 3.14;
+        default:
+            throw new System.Exception();
+        }
+    }
+}",
+@"class Program
+{
+    object M(string s)
+    {
+        return s switch
+        {
+            ""a"" => 1234,
+            ""b"" => (object)3.14,
+            _ => throw new System.Exception(),
+        };
+    }
 }");
         }
     }

From e692744409ac7da2c016891cd3709f6ddc4ef56a Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Thu, 6 Jan 2022 15:53:22 -0800
Subject: [PATCH 264/444] Add tests

---
 ...entToExpressionCodeFixProvider.Rewriter.cs |  8 +-
 ...ConvertSwitchStatementToExpressionTests.cs | 79 +++++++++++++++++++
 2 files changed, 85 insertions(+), 2 deletions(-)

diff --git a/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.Rewriter.cs b/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.Rewriter.cs
index 90a588cf3117f..9abec10a04fc9 100644
--- a/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.Rewriter.cs
+++ b/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.Rewriter.cs
@@ -185,6 +185,10 @@ public override ExpressionSyntax VisitAssignmentExpression(AssignmentExpressionS
 
             private ExpressionSyntax CastIfChangeInRuntimeRepresentation(ExpressionSyntax node)
             {
+                // If the existing return/assign had an conversion involved that changed the runtime representation of
+                // the type (or value), then insert that same cast explicitly in the final result.  This is needed as
+                // switch statements do not use best-common-type, but switch expressions can use it.  We don't want the
+                // original conversion to be lost because a new best-common-type conversion is added.
                 var typeInfo = _semanticModel.GetTypeInfo(node, _cancellationToken);
                 if (typeInfo.ConvertedType is not null &&
                     typeInfo.Type is not null &&
@@ -253,8 +257,8 @@ private ExpressionSyntax RewriteSwitchStatement(
 
             private SwitchStatementSyntax AddCastIfNecessary(SwitchStatementSyntax node)
             {
-                // If the swith statement expression is being implicitly converted then we need to explicitly cast the expression
-                // before rewriting as a switch expression
+                // If the switch statement expression is being implicitly converted then we need to explicitly cast the
+                // expression before rewriting as a switch expression
                 var expressionType = _semanticModel.GetSymbolInfo(node.Expression).Symbol.GetSymbolType();
                 var expressionConvertedType = _semanticModel.GetTypeInfo(node.Expression).ConvertedType;
 
diff --git a/src/Analyzers/CSharp/Tests/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionTests.cs b/src/Analyzers/CSharp/Tests/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionTests.cs
index 8b6143d222b70..757343c29a0fa 100644
--- a/src/Analyzers/CSharp/Tests/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionTests.cs
+++ b/src/Analyzers/CSharp/Tests/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionTests.cs
@@ -2206,6 +2206,48 @@ void M(string s)
 }");
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertSwitchStatementToExpression)]
+        [WorkItem(58636, "https://github.com/dotnet/roslyn/issues/58636")]
+        public async Task TestRuntimeTypeConversion_Assignment2()
+        {
+            await VerifyCS.VerifyCodeFixAsync(
+@"class Program
+{
+    void M(string s)
+    {
+        object result;
+
+        [|switch|] (s)
+        {
+        case ""a"":
+            result = 1234;
+            break;
+        case ""b"":
+            result = 3.14;
+            break;
+        case ""c"":
+            result = true;
+            break;
+        default:
+            throw new System.Exception();
+        }
+    }
+}",
+@"class Program
+{
+    void M(string s)
+    {
+        object result = s switch
+        {
+            ""a"" => 1234,
+            ""b"" => 3.14,
+            ""c"" => true,
+            _ => throw new System.Exception(),
+        };
+    }
+}");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertSwitchStatementToExpression)]
         [WorkItem(58636, "https://github.com/dotnet/roslyn/issues/58636")]
         public async Task TestRuntimeTypeConversion_Return1()
@@ -2237,6 +2279,43 @@ object M(string s)
             _ => throw new System.Exception(),
         };
     }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertSwitchStatementToExpression)]
+        [WorkItem(58636, "https://github.com/dotnet/roslyn/issues/58636")]
+        public async Task TestRuntimeTypeConversion_Return2()
+        {
+            await VerifyCS.VerifyCodeFixAsync(
+@"class Program
+{
+    object M(string s)
+    {
+        [|switch|] (s)
+        {
+        case ""a"":
+            return 1234;
+        case ""b"":
+            return 3.14;
+        case ""c"":
+            return true;
+        default:
+            throw new System.Exception();
+        }
+    }
+}",
+@"class Program
+{
+    object M(string s)
+    {
+        return s switch
+        {
+            ""a"" => 1234,
+            ""b"" => 3.14,
+            ""c"" => true,
+            _ => throw new System.Exception(),
+        };
+    }
 }");
         }
     }

From 9e1320a13a48b8018b70443cbd7ea44e5e566575 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Thu, 6 Jan 2022 15:55:37 -0800
Subject: [PATCH 265/444] Lint

---
 ...entToExpressionCodeFixProvider.Rewriter.cs | 30 +++++++++----------
 ...tchStatementToExpressionCodeFixProvider.cs |  2 +-
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.Rewriter.cs b/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.Rewriter.cs
index 9abec10a04fc9..ea03f11751cd9 100644
--- a/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.Rewriter.cs
+++ b/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.Rewriter.cs
@@ -24,7 +24,7 @@ private sealed class Rewriter : CSharpSyntaxVisitor<ExpressionSyntax>
             private readonly bool _isAllThrowStatements;
             private readonly CancellationToken _cancellationToken;
 
-            private ExpressionSyntax? _assignmentTargetOpt;
+            private ExpressionSyntax? _assignmentTarget;
 
             private Rewriter(SemanticModel semanticModel, bool isAllThrowStatements, CancellationToken cancellationToken)
             {
@@ -82,7 +82,7 @@ private StatementSyntax GetFinalStatement(
                 }
 
                 Debug.Assert(SyntaxFacts.IsAssignmentExpression(nodeToGenerate));
-                Debug.Assert(_assignmentTargetOpt != null);
+                Debug.Assert(_assignmentTarget != null);
 
                 return generateDeclaration
                     ? GenerateVariableDeclaration(switchExpression, declaratorToRemoveTypeOpt)
@@ -91,18 +91,18 @@ private StatementSyntax GetFinalStatement(
 
             private ExpressionStatementSyntax GenerateAssignment(ExpressionSyntax switchExpression, SyntaxKind assignmentKind, SyntaxTriviaList leadingTrivia)
             {
-                Contract.ThrowIfNull(_assignmentTargetOpt);
+                Contract.ThrowIfNull(_assignmentTarget);
 
                 return ExpressionStatement(
                     AssignmentExpression(assignmentKind,
-                        left: _assignmentTargetOpt,
+                        left: _assignmentTarget,
                         right: switchExpression))
                     .WithLeadingTrivia(leadingTrivia);
             }
 
             private StatementSyntax GenerateVariableDeclaration(ExpressionSyntax switchExpression, ITypeSymbol declaratorToRemoveTypeOpt)
             {
-                Contract.ThrowIfFalse(_assignmentTargetOpt is IdentifierNameSyntax);
+                Contract.ThrowIfFalse(_assignmentTarget is IdentifierNameSyntax);
 
                 // There is a probability that we cannot use var if the declaration type is a reference type or nullable type.
                 // In these cases, we generate the explicit type for now and decide later whether or not to use var.
@@ -114,7 +114,7 @@ private StatementSyntax GenerateVariableDeclaration(ExpressionSyntax switchExpre
                         type,
                         variables: SingletonSeparatedList(
                                     VariableDeclarator(
-                                        identifier: ((IdentifierNameSyntax)_assignmentTargetOpt).Identifier,
+                                        identifier: ((IdentifierNameSyntax)_assignmentTarget).Identifier,
                                         argumentList: null,
                                         initializer: EqualsValueClause(switchExpression)))));
             }
@@ -127,15 +127,15 @@ private SwitchExpressionArmSyntax GetSwitchExpressionArm(SwitchSectionSyntax nod
                     expression: RewriteStatements(node.Statements));
             }
 
-            private static PatternSyntax GetPattern(SyntaxList<SwitchLabelSyntax> switchLabels, out WhenClauseSyntax? whenClauseOpt)
+            private static PatternSyntax GetPattern(SyntaxList<SwitchLabelSyntax> switchLabels, out WhenClauseSyntax? whenClause)
             {
                 if (switchLabels.Count == 1)
-                    return GetPattern(switchLabels[0], out whenClauseOpt);
+                    return GetPattern(switchLabels[0], out whenClause);
 
                 if (switchLabels.Any(label => IsDefaultSwitchLabel(label)))
                 {
                     // original group had a catch-all label.  just convert to a discard _ to indicate the same.
-                    whenClauseOpt = null;
+                    whenClause = null;
                     return DiscardPattern();
                 }
 
@@ -151,25 +151,25 @@ private static PatternSyntax GetPattern(SyntaxList<SwitchLabelSyntax> switchLabe
                     totalPattern = BinaryPattern(SyntaxKind.OrPattern, totalPattern.Parenthesize(), nextPatternPart.Parenthesize());
                 }
 
-                whenClauseOpt = null;
+                whenClause = null;
                 return totalPattern;
             }
 
-            private static PatternSyntax GetPattern(SwitchLabelSyntax switchLabel, out WhenClauseSyntax? whenClauseOpt)
+            private static PatternSyntax GetPattern(SwitchLabelSyntax switchLabel, out WhenClauseSyntax? whenClause)
             {
                 switch (switchLabel.Kind())
                 {
                     case SyntaxKind.CasePatternSwitchLabel:
                         var node = (CasePatternSwitchLabelSyntax)switchLabel;
-                        whenClauseOpt = node.WhenClause;
+                        whenClause = node.WhenClause;
                         return node.Pattern;
 
                     case SyntaxKind.CaseSwitchLabel:
-                        whenClauseOpt = null;
+                        whenClause = null;
                         return ConstantPattern(((CaseSwitchLabelSyntax)switchLabel).Value);
 
                     case SyntaxKind.DefaultSwitchLabel:
-                        whenClauseOpt = null;
+                        whenClause = null;
                         return DiscardPattern();
 
                     case var value:
@@ -179,7 +179,7 @@ private static PatternSyntax GetPattern(SwitchLabelSyntax switchLabel, out WhenC
 
             public override ExpressionSyntax VisitAssignmentExpression(AssignmentExpressionSyntax node)
             {
-                _assignmentTargetOpt ??= node.Left;
+                _assignmentTarget ??= node.Left;
                 return CastIfChangeInRuntimeRepresentation(node.Right);
             }
 
diff --git a/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.cs
index f249c69cf6c9c..5448cb0a84c97 100644
--- a/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.cs
@@ -101,7 +101,7 @@ protected override async Task FixAllAsync(
 
                 editor.ReplaceNode(switchStatement, switchExpression.WithAdditionalAnnotations(Formatter.Annotation));
 
-                if (declaratorToRemoveLocationOpt is object)
+                if (declaratorToRemoveLocationOpt is not null)
                 {
                     editor.RemoveNode(declaratorToRemoveLocationOpt.FindNode(cancellationToken));
                 }

From a954ff1992f677a6af33185f4e6e81b4564bd263 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Thu, 6 Jan 2022 15:58:26 -0800
Subject: [PATCH 266/444] NRT

---
 ...entToExpressionCodeFixProvider.Rewriter.cs | 16 +++++-----
 ...tchStatementToExpressionCodeFixProvider.cs | 30 +++++++++----------
 2 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.Rewriter.cs b/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.Rewriter.cs
index ea03f11751cd9..013f93379d15f 100644
--- a/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.Rewriter.cs
+++ b/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.Rewriter.cs
@@ -36,7 +36,7 @@ private Rewriter(SemanticModel semanticModel, bool isAllThrowStatements, Cancell
             public static StatementSyntax Rewrite(
                 SwitchStatementSyntax switchStatement,
                 SemanticModel model,
-                ITypeSymbol declaratorToRemoveTypeOpt,
+                ITypeSymbol? declaratorToRemoveType,
                 SyntaxKind nodeToGenerate,
                 bool shouldMoveNextStatementToSwitchExpression,
                 bool generateDeclaration,
@@ -56,14 +56,14 @@ public static StatementSyntax Rewrite(
                     allowMoveNextStatementToSwitchExpression: shouldMoveNextStatementToSwitchExpression);
 
                 // Generate the final statement to wrap the switch expression, e.g. a "return" or an assignment.
-                return rewriter.GetFinalStatement(switchExpression,
-                    switchStatement.SwitchKeyword.LeadingTrivia, declaratorToRemoveTypeOpt, nodeToGenerate, generateDeclaration);
+                return rewriter.GetFinalStatement(
+                    switchExpression, switchStatement.SwitchKeyword.LeadingTrivia, declaratorToRemoveType, nodeToGenerate, generateDeclaration);
             }
 
             private StatementSyntax GetFinalStatement(
                 ExpressionSyntax switchExpression,
                 SyntaxTriviaList leadingTrivia,
-                ITypeSymbol declaratorToRemoveTypeOpt,
+                ITypeSymbol? declaratorToRemoveType,
                 SyntaxKind nodeToGenerate,
                 bool generateDeclaration)
             {
@@ -85,7 +85,7 @@ private StatementSyntax GetFinalStatement(
                 Debug.Assert(_assignmentTarget != null);
 
                 return generateDeclaration
-                    ? GenerateVariableDeclaration(switchExpression, declaratorToRemoveTypeOpt)
+                    ? GenerateVariableDeclaration(switchExpression, declaratorToRemoveType)
                     : GenerateAssignment(switchExpression, nodeToGenerate, leadingTrivia);
             }
 
@@ -100,14 +100,14 @@ private ExpressionStatementSyntax GenerateAssignment(ExpressionSyntax switchExpr
                     .WithLeadingTrivia(leadingTrivia);
             }
 
-            private StatementSyntax GenerateVariableDeclaration(ExpressionSyntax switchExpression, ITypeSymbol declaratorToRemoveTypeOpt)
+            private StatementSyntax GenerateVariableDeclaration(ExpressionSyntax switchExpression, ITypeSymbol? declaratorToRemoveType)
             {
                 Contract.ThrowIfFalse(_assignmentTarget is IdentifierNameSyntax);
 
                 // There is a probability that we cannot use var if the declaration type is a reference type or nullable type.
                 // In these cases, we generate the explicit type for now and decide later whether or not to use var.
-                var cannotUseVar = declaratorToRemoveTypeOpt != null && (declaratorToRemoveTypeOpt.IsReferenceType || declaratorToRemoveTypeOpt.IsNullable());
-                var type = cannotUseVar ? declaratorToRemoveTypeOpt!.GenerateTypeSyntax() : IdentifierName("var");
+                var cannotUseVar = declaratorToRemoveType != null && (declaratorToRemoveType.IsReferenceType || declaratorToRemoveType.IsNullable());
+                var type = cannotUseVar ? declaratorToRemoveType!.GenerateTypeSyntax() : IdentifierName("var");
 
                 return LocalDeclarationStatement(
                     VariableDeclaration(
diff --git a/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.cs
index 5448cb0a84c97..575f193c8b116 100644
--- a/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System;
 using System.Collections.Immutable;
 using System.Composition;
@@ -22,6 +20,7 @@
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.ConvertSwitchStatementToExpression
 {
@@ -79,39 +78,40 @@ protected override async Task FixAllAsync(
                 var nodeToGenerate = (SyntaxKind)int.Parse(properties[Constants.NodeToGenerateKey]);
                 var shouldRemoveNextStatement = bool.Parse(properties[Constants.ShouldRemoveNextStatementKey]);
 
-                var declaratorToRemoveLocationOpt = diagnostic.AdditionalLocations.ElementAtOrDefault(1);
-                var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+                var declaratorToRemoveLocation = diagnostic.AdditionalLocations.ElementAtOrDefault(1);
+                var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
 
-                SyntaxNode declaratorToRemoveNodeOpt = null;
-                ITypeSymbol declaratorToRemoveTypeOpt = null;
+                SyntaxNode? declaratorToRemoveNode = null;
+                ITypeSymbol? declaratorToRemoveType = null;
 
-                if (declaratorToRemoveLocationOpt != null)
+                if (declaratorToRemoveLocation != null)
                 {
-                    declaratorToRemoveNodeOpt = declaratorToRemoveLocationOpt.FindNode(cancellationToken);
-                    declaratorToRemoveTypeOpt = semanticModel.GetDeclaredSymbol(declaratorToRemoveNodeOpt, cancellationToken).GetSymbolType();
+                    declaratorToRemoveNode = declaratorToRemoveLocation.FindNode(cancellationToken);
+                    declaratorToRemoveType = semanticModel.GetDeclaredSymbol(declaratorToRemoveNode, cancellationToken).GetSymbolType();
                 }
 
                 var switchStatement = (SwitchStatementSyntax)switchLocation.FindNode(getInnermostNodeForTie: true, cancellationToken);
 
                 var switchExpression = Rewriter.Rewrite(
-                   switchStatement, semanticModel, declaratorToRemoveTypeOpt, nodeToGenerate,
+                   switchStatement, semanticModel, declaratorToRemoveType, nodeToGenerate,
                    shouldMoveNextStatementToSwitchExpression: shouldRemoveNextStatement,
-                   generateDeclaration: declaratorToRemoveLocationOpt is not null,
+                   generateDeclaration: declaratorToRemoveLocation is not null,
                    cancellationToken);
 
                 editor.ReplaceNode(switchStatement, switchExpression.WithAdditionalAnnotations(Formatter.Annotation));
 
-                if (declaratorToRemoveLocationOpt is not null)
+                if (declaratorToRemoveLocation is not null)
                 {
-                    editor.RemoveNode(declaratorToRemoveLocationOpt.FindNode(cancellationToken));
+                    editor.RemoveNode(declaratorToRemoveLocation.FindNode(cancellationToken));
                 }
 
                 if (shouldRemoveNextStatement)
                 {
                     // Already morphed into the top-level switch expression.
-                    SyntaxNode nextStatement = switchStatement.GetNextStatement();
+                    var nextStatement = switchStatement.GetNextStatement();
+                    Contract.ThrowIfNull(nextStatement);
                     Debug.Assert(nextStatement.IsKind(SyntaxKind.ThrowStatement, SyntaxKind.ReturnStatement));
-                    editor.RemoveNode(nextStatement.IsParentKind(SyntaxKind.GlobalStatement) ? nextStatement.Parent : nextStatement);
+                    editor.RemoveNode(nextStatement.IsParentKind(SyntaxKind.GlobalStatement) ? nextStatement.GetRequiredParent() : nextStatement);
                 }
             }
         }

From fa282271646fc48b72eab627b7b29eb509e6c23e Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Thu, 6 Jan 2022 16:47:06 -0800
Subject: [PATCH 267/444] NRT

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

diff --git a/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.cs
index 575f193c8b116..c648b541302cf 100644
--- a/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.cs
@@ -75,8 +75,8 @@ protected override async Task FixAllAsync(
                 spans.Add(switchLocation.SourceSpan);
 
                 var properties = diagnostic.Properties;
-                var nodeToGenerate = (SyntaxKind)int.Parse(properties[Constants.NodeToGenerateKey]);
-                var shouldRemoveNextStatement = bool.Parse(properties[Constants.ShouldRemoveNextStatementKey]);
+                var nodeToGenerate = (SyntaxKind)int.Parse(properties[Constants.NodeToGenerateKey]!);
+                var shouldRemoveNextStatement = bool.Parse(properties[Constants.ShouldRemoveNextStatementKey]!);
 
                 var declaratorToRemoveLocation = diagnostic.AdditionalLocations.ElementAtOrDefault(1);
                 var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);

From b3686aa9aa05f0eb9a5f4698b1659291c48eff46 Mon Sep 17 00:00:00 2001
From: Jason Malinowski <jason.malinowski@microsoft.com>
Date: Thu, 6 Jan 2022 17:41:05 -0800
Subject: [PATCH 268/444] Fix typo in folder name

---
 .../CoreTest/{Editting => Editing}/SyntaxEditorTests.cs           | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename src/Workspaces/CoreTest/{Editting => Editing}/SyntaxEditorTests.cs (100%)

diff --git a/src/Workspaces/CoreTest/Editting/SyntaxEditorTests.cs b/src/Workspaces/CoreTest/Editing/SyntaxEditorTests.cs
similarity index 100%
rename from src/Workspaces/CoreTest/Editting/SyntaxEditorTests.cs
rename to src/Workspaces/CoreTest/Editing/SyntaxEditorTests.cs

From 2cb2ed8bf87d6a2f5e62c81265c03bd6914b6d3d Mon Sep 17 00:00:00 2001
From: akhera99 <ankitakhera@microsoft.com>
Date: Thu, 6 Jan 2022 17:49:40 -0800
Subject: [PATCH 269/444] fedback

---
 .../Core.Wpf/InlineHints/InlineHintsTag.cs          | 13 +++++--------
 .../Core.Wpf/InlineHints/InlineHintsTagger.cs       |  2 +-
 .../InlineHints/CSharpInlineTypeHintsService.cs     | 11 +++--------
 3 files changed, 9 insertions(+), 17 deletions(-)

diff --git a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
index f6274976bf373..08d1d55eed9bb 100644
--- a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
@@ -40,7 +40,6 @@ internal class InlineHintsTag : IntraTextAdornmentTag
         public const string TagId = "inline hints";
 
         private readonly ITextView _textView;
-        private readonly ITextBuffer _subjectBuffer;
         private readonly SnapshotSpan _span;
         private readonly InlineHint _hint;
         private readonly InlineHintsTaggerProvider _taggerProvider;
@@ -48,7 +47,6 @@ internal class InlineHintsTag : IntraTextAdornmentTag
         private InlineHintsTag(
             FrameworkElement adornment,
             ITextView textView,
-            ITextBuffer subjectBuffer,
             SnapshotSpan span,
             InlineHint hint,
             InlineHintsTaggerProvider taggerProvider)
@@ -57,7 +55,6 @@ private InlineHintsTag(
                    PositionAffinity.Predecessor)
         {
             _textView = textView;
-            _subjectBuffer = subjectBuffer;
             _span = span;
             _hint = hint;
             _taggerProvider = taggerProvider;
@@ -87,12 +84,11 @@ public static InlineHintsTag Create(
             SnapshotSpan span,
             InlineHintsTaggerProvider taggerProvider,
             IClassificationFormatMap formatMap,
-            ITextBuffer subjectBuffer,
             bool classify)
         {
             return new InlineHintsTag(
                 CreateElement(hint.DisplayParts, textView, format, formatMap, taggerProvider.TypeMap, classify),
-                textView, subjectBuffer, span, hint, taggerProvider);
+                textView, span, hint, taggerProvider);
         }
 
         public async Task<IReadOnlyCollection<object>> CreateDescriptionAsync(CancellationToken cancellationToken)
@@ -272,15 +268,16 @@ private void Adornment_MouseLeftButtonDown(object sender, MouseButtonEventArgs e
             {
                 e.Handled = true;
                 var replacementValue = _hint.ReplacementTextChange!.Value;
+                var subjectBuffer = _span.Snapshot.TextBuffer;
 
-                if (_subjectBuffer.CurrentSnapshot.Length > replacementValue.Span.End)
+                if (subjectBuffer.CurrentSnapshot.Length > replacementValue.Span.End)
                 {
-                    _subjectBuffer.Replace(new VisualStudio.Text.Span(replacementValue.Span.Start, replacementValue.Span.Length), replacementValue.NewText);
+                    subjectBuffer.Replace(new VisualStudio.Text.Span(replacementValue.Span.Start, replacementValue.Span.Length), replacementValue.NewText);
                 }
                 else
                 {
                     Internal.Log.Logger.Log(FunctionId.Inline_Hints_DoubleClick,
-                        $"replacement span end:{replacementValue.Span.End} is greater than or equal to current snapshot length:{_subjectBuffer.CurrentSnapshot.Length}");
+                        $"replacement span end:{replacementValue.Span.End} is greater than or equal to current snapshot length:{subjectBuffer.CurrentSnapshot.Length}");
                 }
             }
         }
diff --git a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTagger.cs b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTagger.cs
index a3ce0935f5412..f3d5a74fb41d5 100644
--- a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTagger.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTagger.cs
@@ -157,7 +157,7 @@ public IEnumerable<ITagSpan<IntraTextAdornmentTag>> GetTags(NormalizedSnapshotSp
                         if (_cache[i].tagSpan is not { } hintTagSpan)
                         {
                             var parameterHintUITag = InlineHintsTag.Create(
-                                    _cache[i].mappingTagSpan.Tag.Hint, Format, _textView, tagSpan, _taggerProvider, _formatMap, snapshot.TextBuffer, classify);
+                                    _cache[i].mappingTagSpan.Tag.Hint, Format, _textView, tagSpan, _taggerProvider, _formatMap, classify);
                             hintTagSpan = new TagSpan<IntraTextAdornmentTag>(tagSpan, parameterHintUITag);
                             _cache[i] = (_cache[i].mappingTagSpan, hintTagSpan);
                         }
diff --git a/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs b/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs
index 89f865cfad8d3..9f88bf8b4ecd5 100644
--- a/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs
+++ b/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs
@@ -82,14 +82,9 @@ public CSharpInlineTypeHintsService(IGlobalOptionService globalOptions)
                     if (parameter?.ContainingSymbol is IMethodSymbol { MethodKind: MethodKind.AnonymousFunction } &&
                         IsValidType(parameter?.Type))
                     {
-                        if (parameterNode.Parent!.Parent.IsKind(SyntaxKind.ParenthesizedLambdaExpression))
-                        {
-                            return new(parameter.Type, span, textChange: new TextChange(span, parameter.Type.ToDisplayString(s_minimalTypeStyle) + " "), trailingSpace: true);
-                        }
-                        else
-                        {
-                            return new(parameter.Type, span, textChange: null, trailingSpace: true);
-                        }
+                        return parameterNode.Parent?.Parent?.Kind() is SyntaxKind.ParenthesizedLambdaExpression
+                            ? new TypeHint(parameter.Type, span, textChange: new TextChange(span, parameter.Type.ToDisplayString(s_minimalTypeStyle) + " "), trailingSpace: true)
+                            : new TypeHint(parameter.Type, span, textChange: null, trailingSpace: true);
                     }
                 }
             }

From 350e378e9cbd3d7e8503f71e37cf305a65c29b67 Mon Sep 17 00:00:00 2001
From: Jason Malinowski <jason.malinowski@microsoft.com>
Date: Thu, 6 Jan 2022 18:10:39 -0800
Subject: [PATCH 270/444] Delete
 Microsoft.CodeAnalysis.Workspaces.Desktop.UnitTests

The only code in here is testing CommandLineProject, but that was
forwarded into Microsoft.CodeAnalysis.Workspaces awhile ago. So
after moving these tests, the project is empty.

The only thing that could be tested in
Microsoft.CodeAnalysis.Workspaces.Desktop is our MEFv1 host services,
but we already have enough implicit testing on that as it is. (Famous
last words.)
---
 Roslyn.sln                                    |  7 ----
 .../CommandLineProjectTests.cs                |  0
 .../CommandLineProjectWorkspaceTests.cs       |  0
 ...alysis.Workspaces.Desktop.UnitTests.csproj | 35 -------------------
 4 files changed, 42 deletions(-)
 rename src/Workspaces/{DesktopTest => CoreTest/CommandLineProject}/CommandLineProjectTests.cs (100%)
 rename src/Workspaces/{DesktopTest => CoreTest/CommandLineProject}/CommandLineProjectWorkspaceTests.cs (100%)
 delete mode 100644 src/Workspaces/DesktopTest/Microsoft.CodeAnalysis.Workspaces.Desktop.UnitTests.csproj

diff --git a/Roslyn.sln b/Roslyn.sln
index 756545af8ffae..ac71fe97c7d3a 100644
--- a/Roslyn.sln
+++ b/Roslyn.sln
@@ -372,8 +372,6 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Comp
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Installer.Package", "src\Setup\Installer\Installer.Package.csproj", "{6A68FDF9-24B3-4CB6-A808-96BF50D1BCE5}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Workspaces.Desktop.UnitTests", "src\Workspaces\DesktopTest\Microsoft.CodeAnalysis.Workspaces.Desktop.UnitTests.csproj", "{23405307-7EFF-4774-8B11-8F5885439761}"
-EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Insertion", "Insertion", "{AFA5F921-0650-45E8-B293-51A0BB89DEA0}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DevDivInsertionFiles", "src\Setup\DevDivInsertionFiles\DevDivInsertionFiles.csproj", "{6362616E-6A47-48F0-9EE0-27800B306ACB}"
@@ -1148,10 +1146,6 @@ Global
 		{6A68FDF9-24B3-4CB6-A808-96BF50D1BCE5}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{6A68FDF9-24B3-4CB6-A808-96BF50D1BCE5}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{6A68FDF9-24B3-4CB6-A808-96BF50D1BCE5}.Release|Any CPU.Build.0 = Release|Any CPU
-		{23405307-7EFF-4774-8B11-8F5885439761}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{23405307-7EFF-4774-8B11-8F5885439761}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{23405307-7EFF-4774-8B11-8F5885439761}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{23405307-7EFF-4774-8B11-8F5885439761}.Release|Any CPU.Build.0 = Release|Any CPU
 		{6362616E-6A47-48F0-9EE0-27800B306ACB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{6362616E-6A47-48F0-9EE0-27800B306ACB}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{6362616E-6A47-48F0-9EE0-27800B306ACB}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -1479,7 +1473,6 @@ Global
 		{B9843F65-262E-4F40-A0BC-2CBEF7563A44} = {C52D8057-43AF-40E6-A01B-6CDBB7301985}
 		{03607817-6800-40B6-BEAA-D6F437CD62B7} = {BE25E872-1667-4649-9D19-96B83E75A44E}
 		{6A68FDF9-24B3-4CB6-A808-96BF50D1BCE5} = {BE25E872-1667-4649-9D19-96B83E75A44E}
-		{23405307-7EFF-4774-8B11-8F5885439761} = {55A62CFA-1155-46F1-ADF3-BEEE51B58AB5}
 		{AFA5F921-0650-45E8-B293-51A0BB89DEA0} = {8DBA5174-B0AA-4561-82B1-A46607697753}
 		{6362616E-6A47-48F0-9EE0-27800B306ACB} = {AFA5F921-0650-45E8-B293-51A0BB89DEA0}
 		{8977A560-45C2-4EC2-A849-97335B382C74} = {FD0FAF5F-1DED-485C-99FA-84B97F3A8EEC}
diff --git a/src/Workspaces/DesktopTest/CommandLineProjectTests.cs b/src/Workspaces/CoreTest/CommandLineProject/CommandLineProjectTests.cs
similarity index 100%
rename from src/Workspaces/DesktopTest/CommandLineProjectTests.cs
rename to src/Workspaces/CoreTest/CommandLineProject/CommandLineProjectTests.cs
diff --git a/src/Workspaces/DesktopTest/CommandLineProjectWorkspaceTests.cs b/src/Workspaces/CoreTest/CommandLineProject/CommandLineProjectWorkspaceTests.cs
similarity index 100%
rename from src/Workspaces/DesktopTest/CommandLineProjectWorkspaceTests.cs
rename to src/Workspaces/CoreTest/CommandLineProject/CommandLineProjectWorkspaceTests.cs
diff --git a/src/Workspaces/DesktopTest/Microsoft.CodeAnalysis.Workspaces.Desktop.UnitTests.csproj b/src/Workspaces/DesktopTest/Microsoft.CodeAnalysis.Workspaces.Desktop.UnitTests.csproj
deleted file mode 100644
index a7e6ad8e3b516..0000000000000
--- a/src/Workspaces/DesktopTest/Microsoft.CodeAnalysis.Workspaces.Desktop.UnitTests.csproj
+++ /dev/null
@@ -1,35 +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.WindowsDesktop">
-  <PropertyGroup>
-    <OutputType>Library</OutputType>
-    <TargetFramework>net472</TargetFramework>
-    <UseWpf>true</UseWpf>
-    <RootNamespace>Microsoft.CodeAnalysis.UnitTests</RootNamespace>
-  </PropertyGroup>
-  <ItemGroup Label="Project References">    
-    <ProjectReference Include="..\..\Compilers\Core\Portable\Microsoft.CodeAnalysis.csproj" />  
-    <ProjectReference Include="..\..\Compilers\Test\Core\Microsoft.CodeAnalysis.Test.Utilities.csproj" />
-    <ProjectReference Include="..\CoreTestUtilities\Microsoft.CodeAnalysis.Workspaces.Test.Utilities.csproj" />
-    <ProjectReference Include="..\CSharp\Portable\Microsoft.CodeAnalysis.CSharp.Workspaces.csproj" />
-    <ProjectReference Include="..\VisualBasic\Portable\Microsoft.CodeAnalysis.VisualBasic.Workspaces.vbproj" />
-    <ProjectReference Include="..\Core\Portable\Microsoft.CodeAnalysis.Workspaces.csproj" />
-    <ProjectReference Include="..\Core\Desktop\Microsoft.CodeAnalysis.Workspaces.Desktop.csproj" />
-    <ProjectReference Include="..\..\Compilers\Test\Resources\Core\Microsoft.CodeAnalysis.Compiler.Test.Resources.csproj" />
-    <ProjectReference Include="..\..\Compilers\CSharp\Portable\Microsoft.CodeAnalysis.CSharp.csproj" />
-    <ProjectReference Include="..\..\Features\CSharp\Portable\Microsoft.CodeAnalysis.CSharp.Features.csproj" />
-    <ProjectReference Include="..\..\EditorFeatures\Core\Microsoft.CodeAnalysis.EditorFeatures.csproj" />
-    <ProjectReference Include="..\..\EditorFeatures\Text\Microsoft.CodeAnalysis.EditorFeatures.Text.csproj" />
-    <ProjectReference Include="..\..\Features\Core\Portable\Microsoft.CodeAnalysis.Features.csproj" />
-    <ProjectReference Include="..\..\Scripting\Core\Microsoft.CodeAnalysis.Scripting.csproj" />
-    <ProjectReference Include="..\Remote\Core\Microsoft.CodeAnalysis.Remote.Workspaces.csproj" />
-    <ProjectReference Include="..\..\Features\VisualBasic\Portable\Microsoft.CodeAnalysis.VisualBasic.Features.vbproj" />
-    <ProjectReference Include="..\..\Compilers\VisualBasic\Portable\Microsoft.CodeAnalysis.VisualBasic.vbproj" />
-  </ItemGroup>
-  <ItemGroup>
-    <PackageReference Include="Microsoft.CSharp" Version="$(MicrosoftCSharpVersion)" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-</Project>
\ No newline at end of file

From c3e8e6d4f398e344e6acbb5d93c1194b454ee81f Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Thu, 6 Jan 2022 18:23:29 -0800
Subject: [PATCH 271/444] Fix MemoryExtensions.TrimStart (#58587)

---
 .../Test/CommandLine/CommandLineTests.cs       | 18 ++++++++++++++++++
 .../Core/Portable/MemoryExtensions.cs          |  2 +-
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
index 7e18c0095c956..726df7260335e 100644
--- a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
+++ b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
@@ -11638,6 +11638,24 @@ public void CompilingCodeWithInvalidPreProcessorSymbolsShouldProvideDiagnostics(
                 Diagnostic(ErrorCode.WRN_DefineIdentifierRequired).WithArguments("1").WithLocation(1, 1));
         }
 
+        [Fact]
+        public void WhitespaceInDefine()
+        {
+            var parsedArgs = DefaultParse(new[] { "/define:\" a\"", "a.cs" }, WorkingDirectory);
+            parsedArgs.Errors.Verify();
+            Assert.Equal("a", parsedArgs.ParseOptions.PreprocessorSymbols.Single());
+        }
+
+        [Fact]
+        public void WhitespaceInDefine_OnlySpaces()
+        {
+            var parsedArgs = DefaultParse(new[] { "/define:\"   \"", "a.cs" }, WorkingDirectory);
+            parsedArgs.Errors.Verify(
+                Diagnostic(ErrorCode.WRN_DefineIdentifierRequired).WithArguments("   ").WithLocation(1, 1)
+                );
+            Assert.True(parsedArgs.ParseOptions.PreprocessorSymbols.IsEmpty);
+        }
+
         [Fact]
         public void CompilingCodeWithInvalidLanguageVersionShouldProvideDiagnostics()
         {
diff --git a/src/Compilers/Core/Portable/MemoryExtensions.cs b/src/Compilers/Core/Portable/MemoryExtensions.cs
index 6950afbf81243..b17a41d2dca7a 100644
--- a/src/Compilers/Core/Portable/MemoryExtensions.cs
+++ b/src/Compilers/Core/Portable/MemoryExtensions.cs
@@ -37,7 +37,7 @@ internal static ReadOnlyMemory<char> TrimStart(this ReadOnlyMemory<char> memory)
                 index++;
             }
 
-            return memory.Slice(index, span.Length);
+            return memory.Slice(index, span.Length - index);
         }
 
         internal static ReadOnlyMemory<char> TrimEnd(this ReadOnlyMemory<char> memory)

From 36a0c92da22e12c60a1d18e58b0f0af2a23cbf72 Mon Sep 17 00:00:00 2001
From: akhera99 <ankitakhera@microsoft.com>
Date: Thu, 6 Jan 2022 18:24:44 -0800
Subject: [PATCH 272/444] fix bug

---
 .../Test2/InlineHints/AbstractInlineHintsTests.vb               | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb b/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb
index 5e948afd992f8..9f57d63ea537c 100644
--- a/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb
+++ b/src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb
@@ -44,7 +44,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
 
                 Dim outWorkspace = TestWorkspace.Create(output)
                 Dim expectedDocument = outWorkspace.CurrentSolution.GetDocument(outWorkspace.Documents.Single().Id)
-                Await ValidateDoubleClick(annotatedDocument, expectedDocument, inlineHints)
+                Await ValidateDoubleClick(document, expectedDocument, inlineHints)
             End Using
         End Function
 

From 0e5c6795a94ab37fee6a54ad35ef4f3f64e317d0 Mon Sep 17 00:00:00 2001
From: Rikki Gibson <rigibson@microsoft.com>
Date: Thu, 6 Jan 2022 21:17:28 -0800
Subject: [PATCH 273/444] Fix a few param-nullchecking parsing bugs (#58644)

---
 .../CSharp/Portable/Errors/ErrorCode.cs       |   14 +-
 .../Generated/ErrorFacts.Generated.cs         |    2 +-
 .../CSharp/Portable/Parser/LanguageParser.cs  |  315 ++--
 .../Semantics/NullCheckedParameterTests.cs    |  153 +-
 .../Syntax/Parsing/DeclarationParsingTests.cs |  246 ++-
 .../Parsing/LambdaParameterParsingTests.cs    | 1345 +++++++++++++++--
 6 files changed, 1745 insertions(+), 330 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
index 9841798e7de00..c6ac42c8d647c 100644
--- a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
+++ b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
@@ -2007,13 +2007,6 @@ internal enum ErrorCode
         // at runtime.
         ERR_CannotUseRefInUnmanagedCallersOnly = 8977,
 
-        ERR_IncorrectNullCheckSyntax = 8990,
-        ERR_MustNullCheckInImplementation = 8991,
-        ERR_NonNullableValueTypeIsNullChecked = 8992,
-        WRN_NullCheckedHasDefaultNull = 8993,
-        ERR_NullCheckingOnByRefParameter = 8994,
-        WRN_NullCheckingOnNullableType = 8995,
-
         #endregion
 
         #region diagnostics introduced for C# 11.0
@@ -2026,6 +2019,13 @@ internal enum ErrorCode
         ERR_RecordStructConstructorCallsDefaultConstructor = 8982,
         ERR_StructHasInitializersAndNoDeclaredConstructor = 8983,
 
+        ERR_IncorrectNullCheckSyntax = 8990,
+        ERR_MustNullCheckInImplementation = 8991,
+        ERR_NonNullableValueTypeIsNullChecked = 8992,
+        WRN_NullCheckedHasDefaultNull = 8993,
+        ERR_NullCheckingOnByRefParameter = 8994,
+        WRN_NullCheckingOnNullableType = 8995,
+
         #endregion
 
         // Note: you will need to re-generate compiler code after adding warnings (eng\generate-compiler-code.cmd)
diff --git a/src/Compilers/CSharp/Portable/Generated/ErrorFacts.Generated.cs b/src/Compilers/CSharp/Portable/Generated/ErrorFacts.Generated.cs
index 47367286eeac1..ea9c801ae3cbb 100644
--- a/src/Compilers/CSharp/Portable/Generated/ErrorFacts.Generated.cs
+++ b/src/Compilers/CSharp/Portable/Generated/ErrorFacts.Generated.cs
@@ -279,9 +279,9 @@ public static bool IsWarning(ErrorCode code)
                 case ErrorCode.WRN_InterpolatedStringHandlerArgumentAttributeIgnoredOnLambdaParameters:
                 case ErrorCode.WRN_CompileTimeCheckedOverflow:
                 case ErrorCode.WRN_MethGrpToNonDel:
+                case ErrorCode.WRN_LowerCaseTypeName:
                 case ErrorCode.WRN_NullCheckedHasDefaultNull:
                 case ErrorCode.WRN_NullCheckingOnNullableType:
-                case ErrorCode.WRN_LowerCaseTypeName:
                     return true;
                 default:
                     return false;
diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
index 6d44f7e2a1545..32227d5860afa 100644
--- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
+++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
@@ -7,6 +7,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.IO;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.Text;
@@ -14,6 +15,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax
 {
+    using Microsoft.CodeAnalysis.PooledObjects;
     using Microsoft.CodeAnalysis.Syntax.InternalSyntax;
 
     internal partial class LanguageParser : SyntaxParser
@@ -3511,7 +3513,7 @@ private OperatorDeclarationSyntax ParseOperatorDeclaration(
             if (opToken.Kind == SyntaxKind.GreaterThanToken && tk.Kind == SyntaxKind.GreaterThanToken)
             {
                 // no trailing trivia and no leading trivia
-                if (opToken.GetTrailingTriviaWidth() == 0 && tk.GetLeadingTriviaWidth() == 0)
+                if (NoTriviaBetween(opToken, tk))
                 {
                     var opToken2 = this.EatToken();
                     opToken = SyntaxFactory.Token(opToken.GetLeadingTrivia(), SyntaxKind.GreaterThanGreaterThanToken, opToken2.GetTrailingTrivia());
@@ -4385,64 +4387,35 @@ private ParameterSyntax ParseParameter()
             {
                 this.ParseParameterModifiers(modifiers);
 
-                TypeSyntax type;
-                SyntaxToken name;
-                SyntaxToken exclamationExclamation = null;
-                SyntaxToken equals = null;
-                if (this.CurrentToken.Kind != SyntaxKind.ArgListKeyword)
-                {
-                    type = this.ParseType(mode: ParseTypeMode.Parameter);
-                    name = this.ParseIdentifierToken();
-                    if (this.CurrentToken.Kind == SyntaxKind.ExclamationToken)
-                    {
-                        exclamationExclamation = this.EatToken();
-                        if (this.CurrentToken.Kind == SyntaxKind.ExclamationEqualsToken)
-                        {
-                            var exclamationEquals = this.EatToken();
-                            var exclamation2 = SyntaxFactory.Token(exclamationEquals.GetLeadingTrivia(), SyntaxKind.ExclamationToken, null);
-                            exclamationExclamation = MergeTokens(exclamationExclamation, exclamation2, SyntaxKind.ExclamationExclamationToken);
-                            equals = SyntaxFactory.Token(null, SyntaxKind.EqualsToken, exclamationEquals.GetTrailingTrivia());
-                        }
-                        else
-                        {
-                            exclamationExclamation = MergeTokens(exclamationExclamation, this.EatToken(SyntaxKind.ExclamationToken), SyntaxKind.ExclamationExclamationToken);
-                        }
-                    }
-                    else if (this.CurrentToken.Kind == SyntaxKind.OpenBracketToken && this.PeekToken(1).Kind == SyntaxKind.CloseBracketToken)
-                    {
-                        // When the user type "int goo[]", give them a useful error
-                        var open = this.EatToken();
-                        var close = this.EatToken();
-                        open = this.AddError(open, ErrorCode.ERR_BadArraySyntax);
-                        name = AddTrailingSkippedSyntax(name, SyntaxList.List(open, close));
-                    }
-                }
-                else
+                if (this.CurrentToken.Kind == SyntaxKind.ArgListKeyword)
                 {
                     // We store an __arglist parameter as a parameter with null type and whose 
                     // .Identifier has the kind ArgListKeyword.
-                    type = null;
-                    name = this.EatToken(SyntaxKind.ArgListKeyword);
+                    return _syntaxFactory.Parameter(
+                        attributes, modifiers.ToList(), type: null, this.EatToken(SyntaxKind.ArgListKeyword), exclamationExclamationToken: null, @default: null);
                 }
 
-                if (this.CurrentToken.Kind == SyntaxKind.EqualsToken)
-                {
-                    equals = this.EatToken(SyntaxKind.EqualsToken);
-                }
-                if (exclamationExclamation != null)
-                {
-                    exclamationExclamation = (exclamationExclamation.Kind != SyntaxKind.ExclamationExclamationToken)
-                        ? ConvertToMissingWithTrailingTrivia(exclamationExclamation, SyntaxKind.ExclamationExclamationToken)
-                        : CheckFeatureAvailability(exclamationExclamation, MessageID.IDS_ParameterNullChecking);
-                }
-                EqualsValueClauseSyntax def = null;
-                if (!(equals is null))
+                var type = this.ParseType(mode: ParseTypeMode.Parameter);
+                var identifier = this.ParseIdentifierToken();
+
+                // When the user type "int goo[]", give them a useful error
+                if (this.CurrentToken.Kind is SyntaxKind.OpenBracketToken && this.PeekToken(1).Kind is SyntaxKind.CloseBracketToken)
                 {
-                    var value = this.ParseExpressionCore();
-                    def = _syntaxFactory.EqualsValueClause(equals, value: value);
-                    def = CheckFeatureAvailability(def, MessageID.IDS_FeatureOptionalParameter);
+                    identifier = AddTrailingSkippedSyntax(identifier, SyntaxList.List(
+                        this.AddError(this.EatToken(), ErrorCode.ERR_BadArraySyntax),
+                        this.EatToken()));
                 }
-                return _syntaxFactory.Parameter(attributes, modifiers.ToList(), type, name, exclamationExclamation, def);
+
+                ParseParameterNullCheck(out var exclamationExclamationToken, out var equalsToken);
+
+                // If we didn't already consume an equals sign as part of !!=, then try to scan one out now.
+                equalsToken ??= TryEatToken(SyntaxKind.EqualsToken);
+
+                EqualsValueClauseSyntax equalsValueClause = null;
+                if (equalsToken != null)
+                    equalsValueClause = CheckFeatureAvailability(_syntaxFactory.EqualsValueClause(equalsToken, this.ParseExpressionCore()), MessageID.IDS_FeatureOptionalParameter);
+
+                return _syntaxFactory.Parameter(attributes, modifiers.ToList(), type, identifier, exclamationExclamationToken, equalsValueClause);
             }
             finally
             {
@@ -4450,6 +4423,96 @@ private ParameterSyntax ParseParameter()
             }
         }
 
+#nullable enable
+
+        /// <summary>
+        /// Parses the <c>!!</c> following a parameter type and identifier.  If the token
+        /// is followed by <c>!!=</c> or <c>! !=</c>, then the final equals will be returned through <paramref
+        /// name="equalsToken"/>.
+        /// </summary>
+        private void ParseParameterNullCheck(
+            out SyntaxToken? exclamationExclamationToken,
+            out SyntaxToken? equalsToken)
+        {
+            exclamationExclamationToken = null;
+            equalsToken = null;
+
+            if (this.CurrentToken.Kind is SyntaxKind.ExclamationEqualsToken)
+            {
+                // split != into two tokens.
+                var exclamationEquals = this.EatToken();
+
+                // Report that the ! should have been !!
+                exclamationExclamationToken = WithAdditionalDiagnostics(
+                    SyntaxFactory.Token(exclamationEquals.GetLeadingTrivia(), SyntaxKind.ExclamationExclamationToken, "!", "!", trailing: null),
+                    this.GetExpectedTokenError(expected: SyntaxKind.ExclamationExclamationToken, actual: SyntaxKind.ExclamationToken));
+
+                // Return the split out `=` for the consumer to handle.
+                equalsToken = SyntaxFactory.Token(leading: null, SyntaxKind.EqualsToken, exclamationEquals.GetTrailingTrivia());
+            }
+            else if (this.CurrentToken.Kind is SyntaxKind.ExclamationToken)
+            {
+                // We have seen at least !
+                //
+                // We can potentially merge that with an immediately following !! or an immediately following !=
+                // All other cases are in error.
+                var firstExclamation = this.EatToken();
+                if (this.CurrentToken.Kind is SyntaxKind.ExclamationToken)
+                {
+                    // have two !'s in a row.  Merge them (reporting any errors if they cannot merge properly).
+                    exclamationExclamationToken = MergeAdjacent(firstExclamation, this.EatToken(), SyntaxKind.ExclamationExclamationToken);
+                }
+                else if (this.CurrentToken.Kind is SyntaxKind.ExclamationEqualsToken)
+                {
+                    // split != into two tokens.
+                    var exclamationEquals = this.EatToken();
+
+                    exclamationExclamationToken = MergeAdjacent(
+                        firstExclamation,
+                        SyntaxFactory.Token(exclamationEquals.GetLeadingTrivia(), SyntaxKind.ExclamationToken, trailing: null),
+                        SyntaxKind.ExclamationExclamationToken);
+                    equalsToken = SyntaxFactory.Token(leading: null, SyntaxKind.EqualsToken, exclamationEquals.GetTrailingTrivia());
+                }
+                else
+                {
+                    // Report that the ! should have been !!
+                    exclamationExclamationToken = WithAdditionalDiagnostics(
+                        SyntaxFactory.Token(firstExclamation.GetLeadingTrivia(), SyntaxKind.ExclamationExclamationToken, "!", "!", trailing: firstExclamation.GetTrailingTrivia()),
+                        this.GetExpectedTokenError(expected: SyntaxKind.ExclamationExclamationToken, actual: firstExclamation.Kind));
+                }
+            }
+
+            if (exclamationExclamationToken != null)
+                exclamationExclamationToken = CheckFeatureAvailability(exclamationExclamationToken, MessageID.IDS_ParameterNullChecking);
+        }
+
+        /// <summary>
+        /// Merges two successive tokens into a single token with the given <paramref name="kind"/>.  If the two tokens
+        /// have no trivia between them, then the final token will be trivially generated, properly passing on the right
+        /// leading/trailing trivia.  However, if there is trivia between the tokens, then appropriate errors will be
+        /// reported that the tokens cannot merge successfully.
+        /// </summary>
+        private SyntaxToken? MergeAdjacent(SyntaxToken t1, SyntaxToken t2, SyntaxKind kind)
+        {
+            if (NoTriviaBetween(t1, t2))
+                return SyntaxFactory.Token(t1.GetLeadingTrivia(), kind, t2.GetTrailingTrivia());
+
+            var sb = PooledStringBuilder.GetInstance();
+            var writer = new StringWriter(sb.Builder, System.Globalization.CultureInfo.InvariantCulture);
+            t1.WriteTo(writer, leading: false, trailing: true);
+            t2.WriteTo(writer, leading: true, trailing: false);
+            var text = sb.ToStringAndFree();
+
+            return WithAdditionalDiagnostics(
+                SyntaxFactory.Token(t1.GetLeadingTrivia(), kind, text, text, t2.GetTrailingTrivia()),
+                GetExpectedTokenError(kind, t1.Kind));
+        }
+
+        private static bool NoTriviaBetween(SyntaxToken token1, SyntaxToken token2)
+            => token1.GetTrailingTriviaWidth() == 0 && token2.GetLeadingTriviaWidth() == 0;
+
+#nullable disable
+
         private static bool IsParameterModifier(SyntaxKind kind, bool isFunctionPointerParameter = false)
         {
             switch (kind)
@@ -10541,7 +10604,7 @@ private ExpressionSyntax ParseExpressionContinued(ExpressionSyntax leftOperand,
                     && (this.PeekToken(1).Kind == SyntaxKind.GreaterThanToken || this.PeekToken(1).Kind == SyntaxKind.GreaterThanEqualsToken))
                 {
                     // check to see if they really are adjacent
-                    if (this.CurrentToken.GetTrailingTriviaWidth() == 0 && this.PeekToken(1).GetLeadingTriviaWidth() == 0)
+                    if (NoTriviaBetween(this.CurrentToken, this.PeekToken(1)))
                     {
                         if (this.PeekToken(1).Kind == SyntaxKind.GreaterThanToken)
                         {
@@ -11525,26 +11588,26 @@ private bool ScanParenthesizedImplicitlyTypedLambda(Precedence precedence)
 
             bool isParenVarCommaSyntax()
             {
-                var next = this.PeekToken(1);
+                var token1 = this.PeekToken(1);
 
                 // Ensure next token is a variable
-                if (next.Kind == SyntaxKind.IdentifierToken)
+                if (token1.Kind == SyntaxKind.IdentifierToken)
                 {
-                    if (!this.IsInQuery || !IsTokenQueryContextualKeyword(next))
+                    if (!this.IsInQuery || !IsTokenQueryContextualKeyword(token1))
                     {
                         // Variable must be directly followed by a comma if not followed by exclamation
-                        var after = this.PeekToken(2);
+                        var token2 = this.PeekToken(2);
                         // ( x , [...]
-                        if (after.Kind == SyntaxKind.CommaToken)
+                        if (token2.Kind == SyntaxKind.CommaToken)
                         {
                             return true;
                         }
+
+                        var token3 = this.PeekToken(3);
                         // ( x!! , [...]
                         // https://github.com/dotnet/roslyn/issues/58335: https://github.com/dotnet/roslyn/pull/46520#discussion_r466650228
-                        if (after.Kind == SyntaxKind.ExclamationToken
-                            && this.PeekToken(3).Kind == SyntaxKind.ExclamationToken
-                            && after.GetTrailingTriviaWidth() == 0
-                            && this.PeekToken(3).GetLeadingTriviaWidth() == 0
+                        if (token2.Kind == SyntaxKind.ExclamationToken
+                            && token3.Kind == SyntaxKind.ExclamationToken
                             && this.PeekToken(4).Kind == SyntaxKind.CommaToken)
                         {
                             return true;
@@ -11614,9 +11677,7 @@ private bool ScanExplicitlyTypedLambda(Precedence precedence)
                         this.EatToken();
                     }
                     if (this.CurrentToken.Kind == SyntaxKind.ExclamationToken
-                        && this.PeekToken(1).Kind == SyntaxKind.ExclamationToken
-                        && this.CurrentToken.GetTrailingTriviaWidth() == 0
-                        && this.PeekToken(1).GetLeadingTriviaWidth() == 0)
+                        && this.PeekToken(1).Kind == SyntaxKind.ExclamationToken)
                     {
                         this.EatToken();
                         this.EatToken();
@@ -11855,28 +11916,31 @@ private bool IsPossibleLambdaExpression(Precedence precedence)
                 return false;
             }
 
-            SyntaxKind token1 = this.PeekToken(1).Kind;
-            if (token1 == SyntaxKind.EqualsGreaterThanToken)
-            {
-                return true;
-            }
-            if (token1 == SyntaxKind.ExclamationToken
-                && this.PeekToken(2).Kind == SyntaxKind.ExclamationToken
-                && this.PeekToken(3).Kind == SyntaxKind.EqualsGreaterThanToken)
-            {
-                return true;
-            }
+            var token1 = this.PeekToken(1);
 
-            // Broken case but error will be added in lambda function (!=>).
-            if (token1 == SyntaxKind.ExclamationEqualsToken && this.PeekToken(2).Kind == SyntaxKind.GreaterThanToken)
+            // x => 
+            //
+            // Def a lambda.
+            if (token1.Kind == SyntaxKind.EqualsGreaterThanToken)
             {
                 return true;
             }
 
-            // Broken case but error will be added in lambda function (!!=>).
-            if (token1 == SyntaxKind.ExclamationToken
-                && this.PeekToken(2).Kind == SyntaxKind.ExclamationEqualsToken
-                && this.PeekToken(3).Kind == SyntaxKind.GreaterThanToken)
+            var token2 = this.PeekToken(2);
+            var token3 = this.PeekToken(3);
+
+            if ((token1.Kind, token2.Kind, token3.Kind) is
+
+                // x!! =>
+                //
+                // Def a lambda (though possibly has errors).
+                (SyntaxKind.ExclamationToken, SyntaxKind.ExclamationToken, SyntaxKind.EqualsGreaterThanToken)
+
+                // Broken case but error will be added in lambda function (!=>).
+                or (SyntaxKind.ExclamationEqualsToken, SyntaxKind.GreaterThanToken, _)
+
+                // Broken case but error will be added in lambda function (!!=>).
+                or (SyntaxKind.ExclamationToken, SyntaxKind.ExclamationEqualsToken, SyntaxKind.GreaterThanToken))
             {
                 return true;
             }
@@ -12888,52 +12952,36 @@ LambdaExpressionSyntax parseLambdaExpressionWorker()
                 }
                 else
                 {
-                    var name = this.ParseIdentifierToken();
-                    SyntaxToken arrow, exclamationExclamation;
-                    // Case x!! =>
-                    if (this.CurrentToken.Kind == SyntaxKind.ExclamationToken)
+                    // Unparenthesized lambda case
+                    // x => ...
+                    // x!! => ...
+                    var identifier = this.ParseIdentifierToken();
+
+                    ParseParameterNullCheck(out var exclamationExclamationToken, out var equalsToken);
+
+                    SyntaxToken arrow;
+                    if (equalsToken != null)
                     {
-                        exclamationExclamation = this.EatToken();
-                        if (this.CurrentToken.Kind == SyntaxKind.ExclamationEqualsToken)
-                        {
-                            var exclamationEquals = this.EatToken();
-                            var exclamation2 = SyntaxFactory.Token(exclamationEquals.GetLeadingTrivia(), SyntaxKind.ExclamationToken, null);
-                            exclamationExclamation = MergeTokens(exclamationExclamation, exclamation2, SyntaxKind.ExclamationExclamationToken);
+                        // we only get an equals token if we had !!=> or !=> (enforced by IsPossibleLambdaExpression).
+                        // So we must have a greater than token following.  If not, some invariant is badly broken.
 
-                            var equals = SyntaxFactory.Token(null, SyntaxKind.EqualsToken, exclamationEquals.GetTrailingTrivia());
-                            var greaterThan = this.EatToken(SyntaxKind.GreaterThanToken);
-                            arrow = MergeTokens(equals, greaterThan, SyntaxKind.EqualsGreaterThanToken);
-                        }
-                        else
-                        {
-                            exclamationExclamation = MergeTokens(exclamationExclamation, this.EatToken(SyntaxKind.ExclamationToken), SyntaxKind.ExclamationExclamationToken);
-                            arrow = this.EatToken(SyntaxKind.EqualsGreaterThanToken);
-                        }
+                        var greaterThan = this.EatToken();
+                        Debug.Assert(greaterThan.Kind == SyntaxKind.GreaterThanToken);
+                        arrow = MergeAdjacent(equalsToken, greaterThan, SyntaxKind.EqualsGreaterThanToken);
                     }
-                    // Case x=>, x =>
                     else
                     {
+                        // Case x=>, x =>
                         arrow = this.EatToken(SyntaxKind.EqualsGreaterThanToken);
-                        exclamationExclamation = null;
-                    }
-
-                    if (exclamationExclamation != null)
-                    {
-                        exclamationExclamation = (exclamationExclamation.Kind != SyntaxKind.ExclamationExclamationToken)
-                            ? ConvertToMissingWithTrailingTrivia(exclamationExclamation, SyntaxKind.ExclamationExclamationToken)
-                            : CheckFeatureAvailability(exclamationExclamation, MessageID.IDS_ParameterNullChecking);
                     }
 
                     if (arrow != null)
                     {
-                        arrow = (arrow.Kind != SyntaxKind.EqualsGreaterThanToken)
-                            ? ConvertToMissingWithTrailingTrivia(arrow, SyntaxKind.EqualsGreaterThanToken)
-                            : CheckFeatureAvailability(arrow, MessageID.IDS_FeatureLambda);
+                        arrow = CheckFeatureAvailability(arrow, MessageID.IDS_FeatureLambda);
                     }
 
                     var parameter = _syntaxFactory.Parameter(
-                        attributeLists: default, modifiers: default,
-                        type: null, identifier: name, exclamationExclamationToken: exclamationExclamation, @default: null);
+                        attributeLists: default, modifiers: default, type: null, identifier, exclamationExclamationToken, @default: null);
                     var (block, expression) = ParseLambdaBody();
                     return _syntaxFactory.SimpleLambdaExpression(
                         attributes, modifiers, parameter, arrow, block, expression);
@@ -13056,19 +13104,15 @@ private ParameterSyntax ParseLambdaParameter()
                 paramType = ParseType(ParseTypeMode.Parameter);
             }
 
-            SyntaxToken paramName = this.ParseIdentifierToken();
-            SyntaxToken exclamationExclamation = null;
-            if (this.CurrentToken.Kind == SyntaxKind.ExclamationToken)
-            {
-                exclamationExclamation = MergeTokens(this.EatToken(SyntaxKind.ExclamationToken), this.EatToken(SyntaxKind.ExclamationToken), SyntaxKind.ExclamationExclamationToken);
-            }
-            if (exclamationExclamation != null)
-            {
-                exclamationExclamation = (exclamationExclamation.Kind != SyntaxKind.ExclamationExclamationToken)
-                    ? ConvertToMissingWithTrailingTrivia(exclamationExclamation, SyntaxKind.ExclamationExclamationToken)
-                    : CheckFeatureAvailability(exclamationExclamation, MessageID.IDS_ParameterNullChecking);
-            }
-            var parameter = _syntaxFactory.Parameter(attributes, modifiers.ToList(), paramType, paramName, exclamationExclamation, null);
+            var identifier = this.ParseIdentifierToken();
+            ParseParameterNullCheck(out var exclamationExclamationToken, out var equalsToken);
+
+            // 'equalsToken' should always be null here. Otherwise, it means while we were scanning
+            // for potential lambdas, we saw an `!!=` or `!=` in the parameter list and allowed
+            // it. However, that should never happen as ScanParenthesizedLambda allows `!!` only.
+            Debug.Assert(equalsToken == null);
+
+            var parameter = _syntaxFactory.Parameter(attributes, modifiers.ToList(), paramType, identifier, exclamationExclamationToken, @default: null);
             _pool.Free(modifiers);
             return parameter;
         }
@@ -13616,20 +13660,5 @@ internal TNode ConsumeUnexpectedTokens<TNode>(TNode node) where TNode : CSharpSy
             node = this.AddTrailingSkippedSyntax(node, trailingTrash.Node);
             return node;
         }
-
-        private SyntaxToken MergeTokens(SyntaxToken s1, SyntaxToken s2, SyntaxKind kind)
-        {
-            if (s1.GetTrailingTriviaWidth() == 0 && s2.GetLeadingTriviaWidth() == 0)
-            {
-                s1 = SyntaxFactory.Token(s1.GetLeadingTrivia(), kind, s2.GetTrailingTrivia());
-            }
-            else
-            {
-                s2 = this.AddError(s2, ErrorCode.ERR_InvalidExprTerm, s2.Text);
-                s1 = AddTrailingSkippedSyntax(s1, s2);
-            }
-
-            return s1;
-        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs
index f6e02cac45ba2..11099313ee706 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs
@@ -126,62 +126,68 @@ partial class C
         public void NullCheckedBadSyntax()
         {
             var source = @"
-#pragma warning disable CS8893  
 partial class C
 {
-    void M0(string name !!=null) { }
-    void M1(string name! !=null) { }
-    void M2(string name!!= null) { }
-    void M3(string name ! !=null) { }
-    void M4(string name ! ! =null) { }
-    void M5(string name! ! =null) { }
-    void M6(string name! != null) { }
-    void M7(string name!
-    != null) { }
+    void M0(string name !!=""a"") { }
+    void M1(string name! !=""a"") { }
+    void M2(string name!!= ""a"") { }
+    void M3(string name ! !=""a"") { }
+    void M4(string name ! ! =""a"") { }
+    void M5(string name! ! =""a"") { }
+    void M6(string name! != ""a"") { }
 }";
             CreateCompilation(source, parseOptions: TestOptions.RegularPreview).VerifyDiagnostics(
-                // (5,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                //     void M0(string name !!=null) { }
-                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(5, 20),
-                // (6,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                //     void M1(string name! !=null) { }
-                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(6, 20),
-                // (6,26): error CS1525: Invalid expression term '!'
-                //     void M1(string name! !=null) { }
-                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(6, 26),
-                // (7,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                //     void M2(string name!!= null) { }
-                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(7, 20),
-                // (8,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                //     void M3(string name ! !=null) { }
-                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(8, 20),
-                // (8,27): error CS1525: Invalid expression term '!'
-                //     void M3(string name ! !=null) { }
-                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(8, 27),
-                // (9,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                //     void M4(string name ! ! =null) { }
-                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(9, 20),
-                // (9,27): error CS1525: Invalid expression term '!'
-                //     void M4(string name ! ! =null) { }
-                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(9, 27),
-                // (10,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                //     void M5(string name! ! =null) { }
-                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(10, 20),
-                // (10,26): error CS1525: Invalid expression term '!'
-                //     void M5(string name! ! =null) { }
-                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(10, 26),
-                // (11,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                //     void M6(string name! != null) { }
-                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(11, 20),
-                // (11,26): error CS1525: Invalid expression term '!'
-                //     void M6(string name! != null) { }
-                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(11, 26),
-                // (12,20): warning CS8993: Parameter 'name' is null-checked but is null by default.
-                //     void M7(string name!
-                Diagnostic(ErrorCode.WRN_NullCheckedHasDefaultNull, "name").WithArguments("name").WithLocation(12, 20),
-                // (13,5): error CS1525: Invalid expression term '!'
-                //     != null) { }
-                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(13, 5));
+                // (5,24): error CS1003: Syntax error, '!!' expected
+                //     void M1(string name! !="a") { }
+                Diagnostic(ErrorCode.ERR_SyntaxError, "! !").WithArguments("!!", "!").WithLocation(5, 24),
+                // (7,25): error CS1003: Syntax error, '!!' expected
+                //     void M3(string name ! !="a") { }
+                Diagnostic(ErrorCode.ERR_SyntaxError, "! !").WithArguments("!!", "!").WithLocation(7, 25),
+                // (8,25): error CS1003: Syntax error, '!!' expected
+                //     void M4(string name ! ! ="a") { }
+                Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(8, 25),
+                // (9,24): error CS1003: Syntax error, '!!' expected
+                //     void M5(string name! ! ="a") { }
+                Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(9, 24),
+                // (10,24): error CS1003: Syntax error, '!!' expected
+                //     void M6(string name! != "a") { }
+                Diagnostic(ErrorCode.ERR_SyntaxError, "! !").WithArguments("!!", "!").WithLocation(10, 24)
+                );
+        }
+
+        [Fact]
+        public void CommentTriviaBetweenExclamations()
+        {
+            var source = @"
+partial class C
+{
+    void M0(string name !/*comment1*/
+    /*comment2*/!) { }
+}";
+            CreateCompilation(source, parseOptions: TestOptions.RegularPreview)
+                .VerifyDiagnostics(
+                    // (4,25): error CS1003: Syntax error, '!!' expected
+                    //     void M0(string name !/*comment1*/
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(4, 25)
+                    );
+        }
+
+        [Fact]
+        public void CommentTriviaSurroundingNotEquals()
+        {
+            var source = @"
+partial class C
+{
+    void M0(string name
+        /*comment1*/!=/*comment2*/
+        ""a"") { }
+}";
+            CreateCompilation(source, parseOptions: TestOptions.RegularPreview)
+                .VerifyDiagnostics(
+                    // (4,12): error CS1003: Syntax error, '!!' expected
+                    //     void M0(string name
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments("!!", "!").WithLocation(4, 12)
+                    );
         }
 
         [Fact]
@@ -497,33 +503,18 @@ public void M()
     }
 }";
             CreateCompilation(source, parseOptions: TestOptions.RegularPreview).VerifyDiagnostics(
-                    // (7,39): error CS1003: Syntax error, '=>' expected
+                    // (7,39): error CS1003: Syntax error, '!!' expected
                     //         Func<string, string> func0 = x!=> x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!=").WithArguments("=>", "!=").WithLocation(7, 39),
-                    // (7,39): error CS1525: Invalid expression term '!='
-                    //         Func<string, string> func0 = x!=> x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!=").WithArguments("!=").WithLocation(7, 39),
-                    // (7,41): error CS1525: Invalid expression term '>'
-                    //         Func<string, string> func0 = x!=> x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, ">").WithArguments(">").WithLocation(7, 41),
-                    // (8,40): error CS1003: Syntax error, '=>' expected
-                    //         Func<string, string> func1 = x !=> x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!=").WithArguments("=>", "!=").WithLocation(8, 40),
-                    // (8,40): error CS1525: Invalid expression term '!='
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(7, 39),
+                    // (8,40): error CS1003: Syntax error, '!!' expected
                     //         Func<string, string> func1 = x !=> x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!=").WithArguments("!=").WithLocation(8, 40),
-                    // (8,42): error CS1525: Invalid expression term '>'
-                    //         Func<string, string> func1 = x !=> x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, ">").WithArguments(">").WithLocation(8, 42),
-                    // (9,40): error CS1003: Syntax error, '=>' expected
-                    //         Func<string, string> func2 = x != > x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!=").WithArguments("=>", "!=").WithLocation(9, 40),
-                    // (9,40): error CS1525: Invalid expression term '!='
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(8, 40),
+                    // (9,40): error CS1003: Syntax error, '!!' expected
                     //         Func<string, string> func2 = x != > x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!=").WithArguments("!=").WithLocation(9, 40),
-                    // (9,43): error CS1525: Invalid expression term '>'
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(9, 40),
+                    // (9,41): error CS1003: Syntax error, '=>' expected
                     //         Func<string, string> func2 = x != > x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, ">").WithArguments(">").WithLocation(9, 43),
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments("=>", "=").WithLocation(9, 41),
                     // (10,38): error CS0103: The name 'x' does not exist in the current context
                     //         Func<string, string> func3 = x! => x;
                     Diagnostic(ErrorCode.ERR_NameNotInContext, "x").WithArguments("x").WithLocation(10, 38),
@@ -554,15 +545,15 @@ public void M()
                     // (11,45): error CS0201: Only assignment, call, increment, decrement, await, and new object expressions can be used as a statement
                     //         Func<string, string> func4 = x ! => x;
                     Diagnostic(ErrorCode.ERR_IllegalStatement, "x").WithLocation(11, 45),
-                    // (13,44): error CS1525: Invalid expression term '>'
+                    // (13,42): error CS1003: Syntax error, '=>' expected
                     //         Func<string, string> func6 = x !!= > x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, ">").WithArguments(">").WithLocation(13, 44),
-                    // (15,41): error CS1525: Invalid expression term '!'
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments("=>", "=").WithLocation(13, 42),
+                    // (15,39): error CS1003: Syntax error, '!!' expected
                     //         Func<string, string> func8 = x! !=> x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(15, 41),
-                    // (16,41): error CS1525: Invalid expression term '!'
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(15, 39),
+                    // (16,39): error CS1003: Syntax error, '!!' expected
                     //         Func<string, string> func9 = x! ! => x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(16, 41));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "! ").WithArguments("!!", "!").WithLocation(16, 39));
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs
index 6d98f3a528743..8fa08646a5360 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs
@@ -7272,6 +7272,83 @@ public void TestMethodDeclarationNullValidation()
             }
         }
 
+        [Fact]
+        public void TestMethodDeclarationNullValidation_SingleExclamation()
+        {
+            UsingStatement(@"void M(string name!) { }", options: TestOptions.RegularPreview,
+                    // (1,19): error CS1003: Syntax error, '!!' expected
+                    // void M(string name!) { }
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 19));
+
+            N(SyntaxKind.LocalFunctionStatement);
+            {
+                N(SyntaxKind.PredefinedType);
+                {
+                    N(SyntaxKind.VoidKeyword);
+                }
+                N(SyntaxKind.IdentifierToken, "M");
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.StringKeyword);
+                        }
+                        N(SyntaxKind.IdentifierToken, "name");
+                        N(SyntaxKind.ExclamationExclamationToken);
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestMethodDeclarationNullValidation_SingleExclamation_ExtraTrivia()
+        {
+            UsingStatement(@"void M(string name
+                /*comment1*/!/*comment2*/) { }", options: TestOptions.RegularPreview,
+                // (2,1): error CS1003: Syntax error, '!!' expected
+                //                 /*comment1*/!/*comment2*/) { }
+                Diagnostic(ErrorCode.ERR_SyntaxError, " ").WithArguments("!!", "!").WithLocation(2, 1));
+
+            N(SyntaxKind.LocalFunctionStatement);
+            {
+                N(SyntaxKind.PredefinedType);
+                {
+                    N(SyntaxKind.VoidKeyword);
+                }
+                N(SyntaxKind.IdentifierToken, "M");
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.StringKeyword);
+                        }
+                        N(SyntaxKind.IdentifierToken, "name");
+                        N(SyntaxKind.ExclamationExclamationToken);
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
+
         [Fact]
         public void TestOptParamMethodDeclarationWithNullValidation()
         {
@@ -7383,8 +7460,102 @@ public void TestNullCheckedArgList()
                     N(SyntaxKind.CloseBraceToken);
                 }
             }
+            EOF();
+        }
+
+        [Fact]
+        public void TestArgListWithBrackets()
+        {
+            UsingStatement(@"void M(__arglist[]) { }", options: TestOptions.RegularPreview,
+                    // (1,17): error CS1003: Syntax error, ',' expected
+                    // void M(__arglist[]) { }
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "[").WithArguments(",", "[").WithLocation(1, 17),
+                    // (1,18): error CS1001: Identifier expected
+                    // void M(__arglist[]) { }
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, "]").WithLocation(1, 18),
+                    // (1,19): error CS1031: Type expected
+                    // void M(__arglist[]) { }
+                    Diagnostic(ErrorCode.ERR_TypeExpected, ")").WithLocation(1, 19),
+                    // (1,19): error CS1001: Identifier expected
+                    // void M(__arglist[]) { }
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, ")").WithLocation(1, 19));
+            N(SyntaxKind.LocalFunctionStatement);
+            {
+                N(SyntaxKind.PredefinedType);
+                {
+                    N(SyntaxKind.VoidKeyword);
+                }
+                N(SyntaxKind.IdentifierToken, "M");
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.ArgListKeyword);
+                    }
+                    M(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.AttributeList);
+                        {
+                            N(SyntaxKind.OpenBracketToken);
+                            M(SyntaxKind.Attribute);
+                            {
+                                M(SyntaxKind.IdentifierName);
+                                {
+                                    M(SyntaxKind.IdentifierToken);
+                                }
+                            }
+                            N(SyntaxKind.CloseBracketToken);
+                        }
+                        M(SyntaxKind.IdentifierName);
+                        {
+                            M(SyntaxKind.IdentifierToken);
+                        }
+                        M(SyntaxKind.IdentifierToken);
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
         }
 
+        [Fact]
+        public void TestArgListWithDefaultValue()
+        {
+            UsingStatement(@"void M(__arglist = null) { }", options: TestOptions.RegularPreview,
+                    // (1,18): error CS1003: Syntax error, ',' expected
+                    // void M(__arglist = null) { }
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments(",", "=").WithLocation(1, 18));
+            N(SyntaxKind.LocalFunctionStatement);
+            {
+                N(SyntaxKind.PredefinedType);
+                {
+                    N(SyntaxKind.VoidKeyword);
+                }
+                N(SyntaxKind.IdentifierToken, "M");
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.ArgListKeyword);
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
 
         [Fact]
         public void TestNullCheckedArgWithLeadingSpace()
@@ -7554,9 +7725,9 @@ public void TestNullCheckedArgWithTrailingNewLine()
         public void TestNullCheckedArgWithSpaceInbetween()
         {
             UsingStatement(@"void M(string name! !=null) { }", options: TestOptions.RegularPreview,
-                    // (1,21): error CS1525: Invalid expression term '!'
+                    // (1,19): error CS1003: Syntax error, '!!' expected
                     // void M(string name! !=null) { }
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(1, 21));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "! !=").WithArguments("!!", "!").WithLocation(1, 19));
             N(SyntaxKind.LocalFunctionStatement);
             {
                 N(SyntaxKind.PredefinedType);
@@ -7574,7 +7745,7 @@ public void TestNullCheckedArgWithSpaceInbetween()
                             N(SyntaxKind.StringKeyword);
                         }
                         N(SyntaxKind.IdentifierToken, "name");
-                        M(SyntaxKind.ExclamationExclamationToken);
+                        N(SyntaxKind.ExclamationExclamationToken);
                         N(SyntaxKind.EqualsValueClause);
                         {
                             N(SyntaxKind.EqualsToken);
@@ -7592,6 +7763,7 @@ public void TestNullCheckedArgWithSpaceInbetween()
                     N(SyntaxKind.CloseBraceToken);
                 }
             }
+            EOF();
         }
 
         [Fact]
@@ -7639,9 +7811,9 @@ public void TestNullCheckedArgWithSpaceAfterParam()
         public void TestNullCheckedArgWithSpaceAfterBangs()
         {
             UsingStatement(@"void M(string name! ! =null) { }", options: TestOptions.RegularPreview,
-                    // (1,21): error CS1525: Invalid expression term '!'
+                    // (1,19): error CS1003: Syntax error, '!!' expected
                     // void M(string name! ! =null) { }
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(1, 21));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 19));
             N(SyntaxKind.LocalFunctionStatement);
             {
                 N(SyntaxKind.PredefinedType);
@@ -7659,7 +7831,7 @@ public void TestNullCheckedArgWithSpaceAfterBangs()
                             N(SyntaxKind.StringKeyword);
                         }
                         N(SyntaxKind.IdentifierToken, "name");
-                        M(SyntaxKind.ExclamationExclamationToken);
+                        N(SyntaxKind.ExclamationExclamationToken);
                         N(SyntaxKind.EqualsValueClause);
                         {
                             N(SyntaxKind.EqualsToken);
@@ -7677,15 +7849,16 @@ public void TestNullCheckedArgWithSpaceAfterBangs()
                     N(SyntaxKind.CloseBraceToken);
                 }
             }
+            EOF();
         }
 
         [Fact]
         public void TestNullCheckedArgWithSpaceBeforeBangs()
         {
             UsingStatement(@"void M(string name ! !=null) { }", options: TestOptions.RegularPreview,
-                    // (1,22): error CS1525: Invalid expression term '!'
+                    // (1,20): error CS1003: Syntax error, '!!' expected
                     // void M(string name ! !=null) { }
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(1, 22));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "! !=").WithArguments("!!", "!").WithLocation(1, 20));
             N(SyntaxKind.LocalFunctionStatement);
             {
                 N(SyntaxKind.PredefinedType);
@@ -7703,7 +7876,7 @@ public void TestNullCheckedArgWithSpaceBeforeBangs()
                             N(SyntaxKind.StringKeyword);
                         }
                         N(SyntaxKind.IdentifierToken, "name");
-                        M(SyntaxKind.ExclamationExclamationToken);
+                        N(SyntaxKind.ExclamationExclamationToken);
                         N(SyntaxKind.EqualsValueClause);
                         {
                             N(SyntaxKind.EqualsToken);
@@ -7721,6 +7894,7 @@ public void TestNullCheckedArgWithSpaceBeforeBangs()
                     N(SyntaxKind.CloseBraceToken);
                 }
             }
+            EOF();
         }
 
         [Fact]
@@ -7764,6 +7938,60 @@ public void TestNullCheckedArgWithSpaceAfterEquals()
             }
         }
 
+        [Fact]
+        public void TestMethodDeclarationNullValidation_ExtraEquals()
+        {
+            UsingStatement(@"void M(string name!!= = null) { }", options: TestOptions.RegularPreview,
+                // (1,23): error CS1525: Invalid expression term '='
+                // void M(string name!!= = null) { }
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "=").WithArguments("=").WithLocation(1, 23));
+
+            N(SyntaxKind.LocalFunctionStatement);
+            {
+                N(SyntaxKind.PredefinedType);
+                {
+                    N(SyntaxKind.VoidKeyword);
+                }
+                N(SyntaxKind.IdentifierToken, "M");
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.PredefinedType);
+                        {
+                            N(SyntaxKind.StringKeyword);
+                        }
+                        N(SyntaxKind.IdentifierToken, "name");
+                        N(SyntaxKind.ExclamationExclamationToken);
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.SimpleAssignmentExpression);
+                            {
+                                M(SyntaxKind.IdentifierName);
+                                {
+                                    M(SyntaxKind.IdentifierToken);
+                                }
+                                N(SyntaxKind.EqualsToken);
+                                N(SyntaxKind.NullLiteralExpression);
+                                {
+                                    N(SyntaxKind.NullKeyword);
+                                }
+                            }
+                        }
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
+
         [Fact]
         public void TestNullCheckedMethod()
         {
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
index 63f1721dfc3ff..3ab00d619c16f 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/LambdaParameterParsingTests.cs
@@ -1227,15 +1227,9 @@ public void TestNullCheckedDiscard()
         public void TestNullCheckedSyntaxCorrection0()
         {
             UsingDeclaration("Func<string, string> func0 = x!=> x;", options: TestOptions.RegularPreview,
-                    // (1,31): error CS1003: Syntax error, '=>' expected
+                    // (1,31): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func0 = x!=> x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!=").WithArguments("=>", "!=").WithLocation(1, 31),
-                    // (1,31): error CS1525: Invalid expression term '!='
-                    // Func<string, string> func0 = x!=> x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!=").WithArguments("!=").WithLocation(1, 31),
-                    // (1,33): error CS1525: Invalid expression term '>'
-                    // Func<string, string> func0 = x!=> x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, ">").WithArguments(">").WithLocation(1, 33));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 31));
             N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
@@ -1269,27 +1263,12 @@ public void TestNullCheckedSyntaxCorrection0()
                                 N(SyntaxKind.Parameter);
                                 {
                                     N(SyntaxKind.IdentifierToken, "x");
+                                    N(SyntaxKind.ExclamationExclamationToken);
                                 }
-                                M(SyntaxKind.EqualsGreaterThanToken);
-                                N(SyntaxKind.NotEqualsExpression);
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
                                 {
-                                    M(SyntaxKind.IdentifierName);
-                                    {
-                                        M(SyntaxKind.IdentifierToken);
-                                    }
-                                    N(SyntaxKind.ExclamationEqualsToken);
-                                    N(SyntaxKind.GreaterThanExpression);
-                                    {
-                                        M(SyntaxKind.IdentifierName);
-                                        {
-                                            M(SyntaxKind.IdentifierToken);
-                                        }
-                                        N(SyntaxKind.GreaterThanToken);
-                                        N(SyntaxKind.IdentifierName);
-                                        {
-                                            N(SyntaxKind.IdentifierToken, "x");
-                                        }
-                                    }
+                                    N(SyntaxKind.IdentifierToken, "x");
                                 }
                             }
                         }
@@ -1297,21 +1276,16 @@ public void TestNullCheckedSyntaxCorrection0()
                 }
                 N(SyntaxKind.SemicolonToken);
             }
+            EOF();
         }
 
         [Fact]
         public void TestNullCheckedSyntaxCorrection1()
         {
             UsingDeclaration("Func<string, string> func1 = x !=> x;", options: TestOptions.RegularPreview,
-                    // (1,32): error CS1003: Syntax error, '=>' expected
+                    // (1,32): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func1 = x !=> x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!=").WithArguments("=>", "!=").WithLocation(1, 32),
-                    // (1,32): error CS1525: Invalid expression term '!='
-                    // Func<string, string> func1 = x !=> x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!=").WithArguments("!=").WithLocation(1, 32),
-                    // (1,34): error CS1525: Invalid expression term '>'
-                    // Func<string, string> func1 = x !=> x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, ">").WithArguments(">").WithLocation(1, 34));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 32));
             N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
@@ -1345,27 +1319,12 @@ public void TestNullCheckedSyntaxCorrection1()
                                 N(SyntaxKind.Parameter);
                                 {
                                     N(SyntaxKind.IdentifierToken, "x");
+                                    N(SyntaxKind.ExclamationExclamationToken);
                                 }
-                                M(SyntaxKind.EqualsGreaterThanToken);
-                                N(SyntaxKind.NotEqualsExpression);
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
                                 {
-                                    M(SyntaxKind.IdentifierName);
-                                    {
-                                        M(SyntaxKind.IdentifierToken);
-                                    }
-                                    N(SyntaxKind.ExclamationEqualsToken);
-                                    N(SyntaxKind.GreaterThanExpression);
-                                    {
-                                        M(SyntaxKind.IdentifierName);
-                                        {
-                                            M(SyntaxKind.IdentifierToken);
-                                        }
-                                        N(SyntaxKind.GreaterThanToken);
-                                        N(SyntaxKind.IdentifierName);
-                                        {
-                                            N(SyntaxKind.IdentifierToken, "x");
-                                        }
-                                    }
+                                    N(SyntaxKind.IdentifierToken, "x");
                                 }
                             }
                         }
@@ -1373,21 +1332,19 @@ public void TestNullCheckedSyntaxCorrection1()
                 }
                 N(SyntaxKind.SemicolonToken);
             }
+            EOF();
         }
 
         [Fact]
         public void TestNullCheckedSyntaxCorrection2()
         {
             UsingDeclaration("Func<string, string> func2 = x != > x;", options: TestOptions.RegularPreview,
-                    // (1,32): error CS1003: Syntax error, '=>' expected
+                    // (1,32): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func2 = x != > x;
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!=").WithArguments("=>", "!=").WithLocation(1, 32),
-                    // (1,32): error CS1525: Invalid expression term '!='
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 32),
+                    // (1,33): error CS1003: Syntax error, '=>' expected
                     // Func<string, string> func2 = x != > x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!=").WithArguments("!=").WithLocation(1, 32),
-                    // (1,35): error CS1525: Invalid expression term '>'
-                    // Func<string, string> func2 = x != > x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, ">").WithArguments(">").WithLocation(1, 35));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments("=>", "=").WithLocation(1, 33));
             N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
@@ -1421,27 +1378,12 @@ public void TestNullCheckedSyntaxCorrection2()
                                 N(SyntaxKind.Parameter);
                                 {
                                     N(SyntaxKind.IdentifierToken, "x");
+                                    N(SyntaxKind.ExclamationExclamationToken);
                                 }
-                                M(SyntaxKind.EqualsGreaterThanToken);
-                                N(SyntaxKind.NotEqualsExpression);
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
                                 {
-                                    M(SyntaxKind.IdentifierName);
-                                    {
-                                        M(SyntaxKind.IdentifierToken);
-                                    }
-                                    N(SyntaxKind.ExclamationEqualsToken);
-                                    N(SyntaxKind.GreaterThanExpression);
-                                    {
-                                        M(SyntaxKind.IdentifierName);
-                                        {
-                                            M(SyntaxKind.IdentifierToken);
-                                        }
-                                        N(SyntaxKind.GreaterThanToken);
-                                        N(SyntaxKind.IdentifierName);
-                                        {
-                                            N(SyntaxKind.IdentifierToken, "x");
-                                        }
-                                    }
+                                    N(SyntaxKind.IdentifierToken, "x");
                                 }
                             }
                         }
@@ -1449,6 +1391,7 @@ public void TestNullCheckedSyntaxCorrection2()
                 }
                 N(SyntaxKind.SemicolonToken);
             }
+            EOF();
         }
 
         [Fact]
@@ -1607,9 +1550,9 @@ public void TestNullCheckedSyntaxCorrection5()
         public void TestNullCheckedSyntaxCorrection6()
         {
             UsingDeclaration("Func<string, string> func6 = x !!= > x;", options: TestOptions.RegularPreview,
-                    // (1,36): error CS1525: Invalid expression term '>'
+                    // (1,34): error CS1003: Syntax error, '=>' expected
                     // Func<string, string> func6 = x !!= > x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, ">").WithArguments(">").WithLocation(1, 36));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments("=>", "=").WithLocation(1, 34));
             N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
@@ -1645,7 +1588,7 @@ public void TestNullCheckedSyntaxCorrection6()
                                     N(SyntaxKind.IdentifierToken, "x");
                                     N(SyntaxKind.ExclamationExclamationToken);
                                 }
-                                M(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.EqualsGreaterThanToken);
                                 N(SyntaxKind.IdentifierName);
                                 {
                                     N(SyntaxKind.IdentifierToken, "x");
@@ -1656,6 +1599,7 @@ public void TestNullCheckedSyntaxCorrection6()
                 }
                 N(SyntaxKind.SemicolonToken);
             }
+            EOF();
         }
 
         [Fact]
@@ -1714,9 +1658,9 @@ public void TestNullCheckedSyntaxCorrection7()
         public void TestNullCheckedSyntaxCorrection8()
         {
             UsingDeclaration("Func<string, string> func8 = x! !=> x;", options: TestOptions.RegularPreview,
-                    // (1,33): error CS1525: Invalid expression term '!'
+                    // (1,31): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func8 = x! !=> x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(1, 33));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 31));
             N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
@@ -1750,7 +1694,7 @@ public void TestNullCheckedSyntaxCorrection8()
                                 N(SyntaxKind.Parameter);
                                 {
                                     N(SyntaxKind.IdentifierToken, "x");
-                                    M(SyntaxKind.ExclamationExclamationToken);
+                                    N(SyntaxKind.ExclamationExclamationToken);
                                 }
                                 N(SyntaxKind.EqualsGreaterThanToken);
                                 N(SyntaxKind.IdentifierName);
@@ -1763,15 +1707,16 @@ public void TestNullCheckedSyntaxCorrection8()
                 }
                 N(SyntaxKind.SemicolonToken);
             }
+            EOF();
         }
 
         [Fact]
         public void TestNullCheckedSyntaxCorrection9()
         {
             UsingDeclaration("Func<string, string> func9 = x! ! => x;", options: TestOptions.RegularPreview,
-                    // (1,33): error CS1525: Invalid expression term '!'
+                    // (1,31): error CS1003: Syntax error, '!!' expected
                     // Func<string, string> func9 = x! ! => x;
-                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "!").WithArguments("!").WithLocation(1, 33));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "! ").WithArguments("!!", "!").WithLocation(1, 31));
             N(SyntaxKind.FieldDeclaration);
             {
                 N(SyntaxKind.VariableDeclaration);
@@ -1805,7 +1750,172 @@ public void TestNullCheckedSyntaxCorrection9()
                                 N(SyntaxKind.Parameter);
                                 {
                                     N(SyntaxKind.IdentifierToken, "x");
-                                    M(SyntaxKind.ExclamationExclamationToken);
+                                    N(SyntaxKind.ExclamationExclamationToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestBracesAfterSimpleLambdaName()
+        {
+            UsingDeclaration("Func<string[], string> func0 = x[] => x;", options: TestOptions.RegularPreview,
+                    // (1,34): error CS0443: Syntax error; value expected
+                    // Func<string[], string> func0 = x[] => x;
+                    Diagnostic(ErrorCode.ERR_ValueExpected, "]").WithLocation(1, 34),
+                    // (1,36): error CS1003: Syntax error, ',' expected
+                    // Func<string[], string> func0 = x[] => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 36));
+            N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.ArrayType);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.StringKeyword);
+                                }
+                                N(SyntaxKind.ArrayRankSpecifier);
+                                {
+                                    N(SyntaxKind.OpenBracketToken);
+                                    N(SyntaxKind.OmittedArraySizeExpression);
+                                    {
+                                        N(SyntaxKind.OmittedArraySizeExpressionToken);
+                                    }
+                                    N(SyntaxKind.CloseBracketToken);
+                                }
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.ElementAccessExpression);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                                N(SyntaxKind.BracketedArgumentList);
+                                {
+                                    N(SyntaxKind.OpenBracketToken);
+                                    M(SyntaxKind.Argument);
+                                    {
+                                        M(SyntaxKind.IdentifierName);
+                                        {
+                                            M(SyntaxKind.IdentifierToken);
+                                        }
+                                    }
+                                    N(SyntaxKind.CloseBracketToken);
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestBracesAfterParenthesizedLambdaName()
+        {
+            UsingDeclaration("Func<string[], string> func0 = (x[]) => x;", options: TestOptions.RegularPreview,
+                    // (1,36): error CS1001: Identifier expected
+                    // Func<string[], string> func0 = (x[]) => x;
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, ")").WithLocation(1, 36));
+            N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.ArrayType);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.StringKeyword);
+                                }
+                                N(SyntaxKind.ArrayRankSpecifier);
+                                {
+                                    N(SyntaxKind.OpenBracketToken);
+                                    N(SyntaxKind.OmittedArraySizeExpression);
+                                    {
+                                        N(SyntaxKind.OmittedArraySizeExpressionToken);
+                                    }
+                                    N(SyntaxKind.CloseBracketToken);
+                                }
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.ParenthesizedLambdaExpression);
+                            {
+                                N(SyntaxKind.ParameterList);
+                                {
+                                    N(SyntaxKind.OpenParenToken);
+                                    N(SyntaxKind.Parameter);
+                                    {
+                                        N(SyntaxKind.ArrayType);
+                                        {
+                                            N(SyntaxKind.IdentifierName);
+                                            {
+                                                N(SyntaxKind.IdentifierToken, "x");
+                                            }
+                                            N(SyntaxKind.ArrayRankSpecifier);
+                                            {
+                                                N(SyntaxKind.OpenBracketToken);
+                                                N(SyntaxKind.OmittedArraySizeExpression);
+                                                {
+                                                    N(SyntaxKind.OmittedArraySizeExpressionToken);
+                                                }
+                                                N(SyntaxKind.CloseBracketToken);
+                                            }
+                                        }
+                                        M(SyntaxKind.IdentifierToken);
+                                    }
+                                    N(SyntaxKind.CloseParenToken);
                                 }
                                 N(SyntaxKind.EqualsGreaterThanToken);
                                 N(SyntaxKind.IdentifierName);
@@ -1818,6 +1928,1063 @@ public void TestNullCheckedSyntaxCorrection9()
                 }
                 N(SyntaxKind.SemicolonToken);
             }
+            EOF();
+        }
+
+        [Fact]
+        public void TestBracesAfterParenthesizedLambdaTypeAndName()
+        {
+            UsingDeclaration("Func<string[], string> func0 = (string x[]) => x;", options: TestOptions.RegularPreview,
+                    // (1,33): error CS1525: Invalid expression term 'string'
+                    // Func<string[], string> func0 = (string x[]) => x;
+                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "string").WithArguments("string").WithLocation(1, 33),
+                    // (1,40): error CS1026: ) expected
+                    // Func<string[], string> func0 = (string x[]) => x;
+                    Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 40),
+                    // (1,40): error CS1003: Syntax error, ',' expected
+                    // Func<string[], string> func0 = (string x[]) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 40));
+            N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.ArrayType);
+                            {
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.StringKeyword);
+                                }
+                                N(SyntaxKind.ArrayRankSpecifier);
+                                {
+                                    N(SyntaxKind.OpenBracketToken);
+                                    N(SyntaxKind.OmittedArraySizeExpression);
+                                    {
+                                        N(SyntaxKind.OmittedArraySizeExpressionToken);
+                                    }
+                                    N(SyntaxKind.CloseBracketToken);
+                                }
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.ParenthesizedExpression);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.StringKeyword);
+                                }
+                                M(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestDefaultValueSimpleLambda()
+        {
+            UsingDeclaration("Func<string, string> func0 = x = null => x;", options: TestOptions.RegularPreview,
+                    // (1,39): error CS1003: Syntax error, ',' expected
+                    // Func<string, string> func0 = x = null => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 39));
+            N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.SimpleAssignmentExpression);
+                            {
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                                N(SyntaxKind.EqualsToken);
+                                N(SyntaxKind.NullLiteralExpression);
+                                {
+                                    N(SyntaxKind.NullKeyword);
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestDefaultValueParenthesizedLambda1()
+        {
+            UsingDeclaration("Func<string, string> func0 = (x = null) => x;", options: TestOptions.RegularPreview,
+                    // (1,41): error CS1003: Syntax error, ',' expected
+                    // Func<string, string> func0 = (x = null) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 41));
+            N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.ParenthesizedExpression);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.SimpleAssignmentExpression);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "x");
+                                    }
+                                    N(SyntaxKind.EqualsToken);
+                                    N(SyntaxKind.NullLiteralExpression);
+                                    {
+                                        N(SyntaxKind.NullKeyword);
+                                    }
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestDefaultValueParenthesizedLambda2()
+        {
+            UsingDeclaration("Func<string, string> func0 = (y, x = null) => x;", options: TestOptions.RegularPreview,
+                    // (1,44): error CS1003: Syntax error, ',' expected
+                    // Func<string, string> func0 = (y, x = null) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 44));
+            N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.TupleExpression);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.Argument);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "y");
+                                    }
+                                }
+                                N(SyntaxKind.CommaToken);
+                                N(SyntaxKind.Argument);
+                                {
+                                    N(SyntaxKind.SimpleAssignmentExpression);
+                                    {
+                                        N(SyntaxKind.IdentifierName);
+                                        {
+                                            N(SyntaxKind.IdentifierToken, "x");
+                                        }
+                                        N(SyntaxKind.EqualsToken);
+                                        N(SyntaxKind.NullLiteralExpression);
+                                        {
+                                            N(SyntaxKind.NullKeyword);
+                                        }
+                                    }
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestDefaultValueParenthesizedLambdaWithType1()
+        {
+            UsingDeclaration("Func<string, string> func0 = (string x = null) => x;", options: TestOptions.RegularPreview,
+                    // (1,31): error CS1525: Invalid expression term 'string'
+                    // Func<string, string> func0 = (string x = null) => x;
+                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "string").WithArguments("string").WithLocation(1, 31),
+                    // (1,38): error CS1026: ) expected
+                    // Func<string, string> func0 = (string x = null) => x;
+                    Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 38),
+                    // (1,38): error CS1003: Syntax error, ',' expected
+                    // Func<string, string> func0 = (string x = null) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 38));
+            N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.ParenthesizedExpression);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.StringKeyword);
+                                }
+                                M(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestDefaultValueParenthesizedLambdaWithType2()
+        {
+            UsingDeclaration("Func<string, string> func0 = (string y, string x = null) => x;", options: TestOptions.RegularPreview,
+                    // (1,41): error CS1525: Invalid expression term 'string'
+                    // Func<string, string> func0 = (string y, string x = null) => x;
+                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "string").WithArguments("string").WithLocation(1, 41),
+                    // (1,48): error CS1026: ) expected
+                    // Func<string, string> func0 = (string y, string x = null) => x;
+                    Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 48),
+                    // (1,48): error CS1003: Syntax error, ',' expected
+                    // Func<string, string> func0 = (string y, string x = null) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 48));
+            N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.TupleExpression);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.Argument);
+                                {
+                                    N(SyntaxKind.DeclarationExpression);
+                                    {
+                                        N(SyntaxKind.PredefinedType);
+                                        {
+                                            N(SyntaxKind.StringKeyword);
+                                        }
+                                        N(SyntaxKind.SingleVariableDesignation);
+                                        {
+                                            N(SyntaxKind.IdentifierToken, "y");
+                                        }
+                                    }
+                                }
+                                N(SyntaxKind.CommaToken);
+                                N(SyntaxKind.Argument);
+                                {
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.StringKeyword);
+                                    }
+                                }
+                                M(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestNullCheckedDefaultValueSimpleLambda()
+        {
+            UsingDeclaration("Func<string, string> func0 = x!! = null => x;", options: TestOptions.RegularPreview,
+                    // (1,41): error CS1003: Syntax error, ',' expected
+                    // Func<string, string> func0 = x!! = null => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 41));
+            N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.SimpleAssignmentExpression);
+                            {
+                                N(SyntaxKind.SuppressNullableWarningExpression);
+                                {
+                                    N(SyntaxKind.SuppressNullableWarningExpression);
+                                    {
+                                        N(SyntaxKind.IdentifierName);
+                                        {
+                                            N(SyntaxKind.IdentifierToken, "x");
+                                        }
+                                        N(SyntaxKind.ExclamationToken);
+                                    }
+                                    N(SyntaxKind.ExclamationToken);
+                                }
+                                N(SyntaxKind.EqualsToken);
+                                N(SyntaxKind.NullLiteralExpression);
+                                {
+                                    N(SyntaxKind.NullKeyword);
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestNullCheckedDefaultValueParenthesizedLambda1()
+        {
+            UsingDeclaration("Func<string, string> func0 = (x!! = null) => x;", options: TestOptions.RegularPreview,
+                    // (1,43): error CS1003: Syntax error, ',' expected
+                    // Func<string, string> func0 = (x!! = null) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 43));
+            N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.ParenthesizedExpression);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.SimpleAssignmentExpression);
+                                {
+                                    N(SyntaxKind.SuppressNullableWarningExpression);
+                                    {
+                                        N(SyntaxKind.SuppressNullableWarningExpression);
+                                        {
+                                            N(SyntaxKind.IdentifierName);
+                                            {
+                                                N(SyntaxKind.IdentifierToken, "x");
+                                            }
+                                            N(SyntaxKind.ExclamationToken);
+                                        }
+                                        N(SyntaxKind.ExclamationToken);
+                                    }
+                                    N(SyntaxKind.EqualsToken);
+                                    N(SyntaxKind.NullLiteralExpression);
+                                    {
+                                        N(SyntaxKind.NullKeyword);
+                                    }
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestNullCheckedDefaultValueParenthesizedLambda2()
+        {
+            UsingDeclaration("Func<string, string> func0 = (y, x!! = null) => x;", options: TestOptions.RegularPreview,
+                    // (1,46): error CS1003: Syntax error, ',' expected
+                    // Func<string, string> func0 = (y, x!! = null) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=>").WithArguments(",", "=>").WithLocation(1, 46));
+            N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.TupleExpression);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.Argument);
+                                {
+                                    N(SyntaxKind.IdentifierName);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "y");
+                                    }
+                                }
+                                N(SyntaxKind.CommaToken);
+                                N(SyntaxKind.Argument);
+                                {
+                                    N(SyntaxKind.SimpleAssignmentExpression);
+                                    {
+                                        N(SyntaxKind.SuppressNullableWarningExpression);
+                                        {
+                                            N(SyntaxKind.SuppressNullableWarningExpression);
+                                            {
+                                                N(SyntaxKind.IdentifierName);
+                                                {
+                                                    N(SyntaxKind.IdentifierToken, "x");
+                                                }
+                                                N(SyntaxKind.ExclamationToken);
+                                            }
+                                            N(SyntaxKind.ExclamationToken);
+                                        }
+                                        N(SyntaxKind.EqualsToken);
+                                        N(SyntaxKind.NullLiteralExpression);
+                                        {
+                                            N(SyntaxKind.NullKeyword);
+                                        }
+                                    }
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestNullCheckedDefaultValueParenthesizedLambdaWithType1()
+        {
+            UsingDeclaration("Func<string, string> func0 = (string x!! = null) => x;", options: TestOptions.RegularPreview,
+                    // (1,31): error CS1525: Invalid expression term 'string'
+                    // Func<string, string> func0 = (string x!! = null) => x;
+                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "string").WithArguments("string").WithLocation(1, 31),
+                    // (1,38): error CS1026: ) expected
+                    // Func<string, string> func0 = (string x!! = null) => x;
+                    Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 38),
+                    // (1,38): error CS1003: Syntax error, ',' expected
+                    // Func<string, string> func0 = (string x!! = null) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 38));
+            N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.ParenthesizedExpression);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.PredefinedType);
+                                {
+                                    N(SyntaxKind.StringKeyword);
+                                }
+                                M(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestNullCheckedDefaultValueParenthesizedLambdaWithType2()
+        {
+            UsingDeclaration("Func<string, string> func0 = (string y, string x!! = null) => x;", options: TestOptions.RegularPreview,
+                // (1,41): error CS1525: Invalid expression term 'string'
+                // Func<string, string> func0 = (string y, string x!! = null) => x;
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "string").WithArguments("string").WithLocation(1, 41),
+                // (1,48): error CS1026: ) expected
+                // Func<string, string> func0 = (string y, string x!! = null) => x;
+                Diagnostic(ErrorCode.ERR_CloseParenExpected, "x").WithLocation(1, 48),
+                // (1,48): error CS1003: Syntax error, ',' expected
+                // Func<string, string> func0 = (string y, string x!! = null) => x;
+                Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",", "").WithLocation(1, 48));
+            N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.TupleExpression);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.Argument);
+                                {
+                                    N(SyntaxKind.DeclarationExpression);
+                                    {
+                                        N(SyntaxKind.PredefinedType);
+                                        {
+                                            N(SyntaxKind.StringKeyword);
+                                        }
+                                        N(SyntaxKind.SingleVariableDesignation);
+                                        {
+                                            N(SyntaxKind.IdentifierToken, "y");
+                                        }
+                                    }
+                                }
+                                N(SyntaxKind.CommaToken);
+                                N(SyntaxKind.Argument);
+                                {
+                                    N(SyntaxKind.PredefinedType);
+                                    {
+                                        N(SyntaxKind.StringKeyword);
+                                    }
+                                }
+                                M(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestNullCheckedSpaceBetweenSimpleLambda()
+        {
+            UsingDeclaration("Func<string, string> func0 = x! ! => x;", options: TestOptions.RegularPreview,
+                    // (1,31): error CS1003: Syntax error, '!!' expected
+                    // Func<string, string> func0 = x! ! => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "! ").WithArguments("!!", "!").WithLocation(1, 31));
+            N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.SimpleLambdaExpression);
+                            {
+                                N(SyntaxKind.Parameter);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                    N(SyntaxKind.ExclamationExclamationToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestNullCheckedSpaceBetweenParenthesizedLambda1()
+        {
+            UsingDeclaration("Func<string, string> func0 = (x! !) => x;", options: TestOptions.RegularPreview,
+                    // (1,32): error CS1003: Syntax error, '!!' expected
+                    // Func<string, string> func0 = (x! !) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 32));
+            N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.ParenthesizedLambdaExpression);
+                            {
+                                N(SyntaxKind.ParameterList);
+                                {
+                                    N(SyntaxKind.OpenParenToken);
+                                    N(SyntaxKind.Parameter);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "x");
+                                        N(SyntaxKind.ExclamationExclamationToken);
+                                    }
+                                    N(SyntaxKind.CloseParenToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestNullCheckedSpaceBetweenParenthesizedLambda2()
+        {
+            UsingDeclaration("Func<string, string> func0 = (y, x! !) => x;", options: TestOptions.RegularPreview,
+                    // (1,35): error CS1003: Syntax error, '!!' expected
+                    // Func<string, string> func0 = (y, x! !) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 35));
+            N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.ParenthesizedLambdaExpression);
+                            {
+                                N(SyntaxKind.ParameterList);
+                                {
+                                    N(SyntaxKind.OpenParenToken);
+                                    N(SyntaxKind.Parameter);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "y");
+                                    }
+                                    N(SyntaxKind.CommaToken);
+                                    N(SyntaxKind.Parameter);
+                                    {
+                                        N(SyntaxKind.IdentifierToken, "x");
+                                        N(SyntaxKind.ExclamationExclamationToken);
+                                    }
+                                    N(SyntaxKind.CloseParenToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestNullCheckedSpaceBetweenLambdaWithType1()
+        {
+            UsingDeclaration("Func<string, string> func0 = (string x! !) => x;", options: TestOptions.RegularPreview,
+                    // (1,39): error CS1003: Syntax error, '!!' expected
+                    // Func<string, string> func0 = (string x! !) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 39));
+            N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.ParenthesizedLambdaExpression);
+                            {
+                                N(SyntaxKind.ParameterList);
+                                {
+                                    N(SyntaxKind.OpenParenToken);
+                                    N(SyntaxKind.Parameter);
+                                    {
+                                        N(SyntaxKind.PredefinedType);
+                                        {
+                                            N(SyntaxKind.StringKeyword);
+                                        }
+                                        N(SyntaxKind.IdentifierToken, "x");
+                                        N(SyntaxKind.ExclamationExclamationToken);
+                                    }
+                                    N(SyntaxKind.CloseParenToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestNullCheckedSpaceBetweenLambdaWithType2()
+        {
+            UsingDeclaration("Func<string, string> func0 = (string y, string x! !) => x;", options: TestOptions.RegularPreview,
+                    // (1,49): error CS1003: Syntax error, '!!' expected
+                    // Func<string, string> func0 = (string y, string x! !) => x;
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 49));
+            N(SyntaxKind.FieldDeclaration);
+            {
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.GenericName);
+                    {
+                        N(SyntaxKind.IdentifierToken, "Func");
+                        N(SyntaxKind.TypeArgumentList);
+                        {
+                            N(SyntaxKind.LessThanToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.CommaToken);
+                            N(SyntaxKind.PredefinedType);
+                            {
+                                N(SyntaxKind.StringKeyword);
+                            }
+                            N(SyntaxKind.GreaterThanToken);
+                        }
+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken, "func0");
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.ParenthesizedLambdaExpression);
+                            {
+                                N(SyntaxKind.ParameterList);
+                                {
+                                    N(SyntaxKind.OpenParenToken);
+                                    N(SyntaxKind.Parameter);
+                                    {
+                                        N(SyntaxKind.PredefinedType);
+                                        {
+                                            N(SyntaxKind.StringKeyword);
+                                        }
+                                        N(SyntaxKind.IdentifierToken, "y");
+                                    }
+                                    N(SyntaxKind.CommaToken);
+                                    N(SyntaxKind.Parameter);
+                                    {
+                                        N(SyntaxKind.PredefinedType);
+                                        {
+                                            N(SyntaxKind.StringKeyword);
+                                        }
+                                        N(SyntaxKind.IdentifierToken, "x");
+                                        N(SyntaxKind.ExclamationExclamationToken);
+                                    }
+                                    N(SyntaxKind.CloseParenToken);
+                                }
+                                N(SyntaxKind.EqualsGreaterThanToken);
+                                N(SyntaxKind.IdentifierName);
+                                {
+                                    N(SyntaxKind.IdentifierToken, "x");
+                                }
+                            }
+                        }
+                    }
+                }
+                N(SyntaxKind.SemicolonToken);
+            }
+            EOF();
         }
 
         [Fact]

From fcc0827728b4c39d22f08b725fe32c7188b31030 Mon Sep 17 00:00:00 2001
From: Fred Silberberg <frsilb@microsoft.com>
Date: Fri, 7 Jan 2022 09:56:52 -0800
Subject: [PATCH 274/444] Implement GetTypesByMetadataName (#58366)

Closes https://github.com/dotnet/roslyn/issues/57802. Implements the GetTypesByMetadataName API, which returns all named types in the current compilation and referenced assemblies that match the given CLR metatdata name. Also updates the IDE's GetBestTypeByMetadataName to use this API under the hood, rather than the existing manual walk they were doing, simplyfing that codepath and proving out the API itself.
---
 .../Symbol/Compilation/CompilationAPITests.cs | 277 ++++++++++++++++++
 .../Core/Portable/Compilation/Compilation.cs  | 105 ++++++-
 .../Core/Portable/PublicAPI.Unshipped.txt     |   1 +
 .../Test/Symbol/CompilationAPITests.vb        | 226 ++++++++++++++
 .../Core/Extensions/CompilationExtensions.cs  |  51 ++--
 5 files changed, 625 insertions(+), 35 deletions(-)
 create mode 100644 src/Compilers/VisualBasic/Test/Symbol/CompilationAPITests.vb

diff --git a/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs b/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs
index d1a03c60f4a71..6e608104926e4 100644
--- a/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs
@@ -3036,5 +3036,282 @@ void M1()
         }
 
         #endregion
+
+        #region GetTypesByMetadataName Tests
+
+        [Fact]
+        public void GetTypesByMetadataName_NotInSourceNotInReferences()
+        {
+            var comp = CreateCompilation("");
+            comp.VerifyDiagnostics();
+
+            var types = comp.GetTypesByMetadataName("N.C`1");
+            Assert.Empty(types);
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void GetTypesByMetadataName_SingleInSourceNotInReferences(
+            bool useMetadataReference,
+            [CombinatorialValues("public", "internal")] string accessibility)
+        {
+            var referenceComp = CreateCompilation("");
+
+            var comp = CreateCompilation(
+$@"namespace N;
+{accessibility} class C<T> {{}}", new[] { useMetadataReference ? referenceComp.ToMetadataReference() : referenceComp.EmitToImageReference() });
+
+            comp.VerifyDiagnostics();
+
+            var types = comp.GetTypesByMetadataName("N.C`1");
+
+            Assert.Single(types);
+            AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString());
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void GetTypesByMetadataName_MultipleInSourceNotInReferences(
+            bool useMetadataReference,
+            [CombinatorialValues("public", "internal")] string accessibility)
+        {
+            var referenceComp = CreateCompilation("");
+
+            var comp = CreateCompilation(
+$@"namespace N;
+{accessibility} class C<T> {{}}
+{accessibility} class C<T> {{}}", new[] { useMetadataReference ? referenceComp.ToMetadataReference() : referenceComp.EmitToImageReference() });
+
+            comp.VerifyDiagnostics(
+                // (3,16): error CS0101: The namespace 'N' already contains a definition for 'C'
+                // internal class C<T> {}
+                Diagnostic(ErrorCode.ERR_DuplicateNameInNS, "C").WithArguments("C", "N").WithLocation(3, 8 + accessibility.Length)
+            );
+
+            var types = comp.GetTypesByMetadataName("N.C`1");
+
+            Assert.Single(types);
+            AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString());
+            Assert.Equal(2, types[0].Locations.Length);
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void GetTypesByMetadataName_SingleInSourceSingleInReferences(
+            bool useMetadataReference,
+            [CombinatorialValues("public", "internal")] string accessibility)
+        {
+            string source = $@"namespace N;
+{accessibility} class C<T> {{}}";
+
+            var referenceComp = CreateCompilation(source);
+
+            referenceComp.VerifyDiagnostics();
+
+            MetadataReference reference = useMetadataReference ? referenceComp.ToMetadataReference() : referenceComp.EmitToImageReference();
+            var comp = CreateCompilation(source, new[] { reference });
+            comp.VerifyDiagnostics();
+
+            var types = comp.GetTypesByMetadataName("N.C`1");
+
+            Assert.Equal(2, types.Length);
+            AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString());
+            Assert.Same(comp.Assembly.GetPublicSymbol(), types[0].ContainingAssembly);
+            AssertEx.Equal("N.C<T>", types[1].ToTestDisplayString());
+
+            var assembly1 = comp.GetAssemblyOrModuleSymbol(reference).GetPublicSymbol();
+            Assert.Same(types[1].ContainingAssembly, assembly1);
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void GetTypesByMetadataName_NotInSourceSingleInReferences(
+            bool useMetadataReference,
+            [CombinatorialValues("public", "internal")] string accessibility)
+        {
+            string source = @$"namespace N;
+{accessibility} class C<T> {{}}";
+
+            var referenceComp = CreateCompilation(source);
+
+            referenceComp.VerifyDiagnostics();
+
+            MetadataReference reference = useMetadataReference ? referenceComp.ToMetadataReference() : referenceComp.EmitToImageReference();
+            var comp = CreateCompilation("", new[] { reference });
+            comp.VerifyDiagnostics();
+
+            var types = comp.GetTypesByMetadataName("N.C`1");
+
+
+            Assert.Single(types);
+            AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString());
+
+            var assembly1 = comp.GetAssemblyOrModuleSymbol(reference).GetPublicSymbol();
+            Assert.Same(types[0].ContainingAssembly, assembly1);
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void GetTypesByMetadataName_NotInSourceMultipleInReferences(
+            bool useMetadataReference,
+            [CombinatorialValues("public", "internal")] string accessibility)
+        {
+            string source = @$"namespace N;
+{accessibility} class C<T> {{}}";
+
+            var referenceComp1 = CreateCompilation(source);
+            referenceComp1.VerifyDiagnostics();
+
+            var referenceComp2 = CreateCompilation(source);
+            referenceComp2.VerifyDiagnostics();
+
+            MetadataReference reference1 = getReference(referenceComp1);
+            MetadataReference reference2 = getReference(referenceComp2);
+            var comp = CreateCompilation("", new[] { reference1, reference2 });
+            comp.VerifyDiagnostics();
+
+            var types = comp.GetTypesByMetadataName("N.C`1");
+
+            Assert.Equal(2, types.Length);
+            AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString());
+            AssertEx.Equal("N.C<T>", types[1].ToTestDisplayString());
+
+            var assembly1 = comp.GetAssemblyOrModuleSymbol(reference1).GetPublicSymbol();
+            Assert.Same(types[0].ContainingAssembly, assembly1);
+
+            var assembly2 = comp.GetAssemblyOrModuleSymbol(reference2).GetPublicSymbol();
+            Assert.Same(types[1].ContainingAssembly, assembly2);
+
+            MetadataReference getReference(CSharpCompilation referenceComp1)
+            {
+                return useMetadataReference ? referenceComp1.ToMetadataReference() : referenceComp1.EmitToImageReference();
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void GetTypesByMetadataName_SingleInSourceMultipleInReferences(
+            bool useMetadataReference,
+            [CombinatorialValues("public", "internal")] string accessibility)
+        {
+            string source = @$"namespace N;
+{accessibility} class C<T> {{}}";
+
+            var referenceComp1 = CreateCompilation(source);
+            referenceComp1.VerifyDiagnostics();
+
+            var referenceComp2 = CreateCompilation(source);
+            referenceComp2.VerifyDiagnostics();
+
+            MetadataReference reference1 = getReference(referenceComp1);
+            MetadataReference reference2 = getReference(referenceComp2);
+            var comp = CreateCompilation(source, new[] { reference1, reference2 });
+            comp.VerifyDiagnostics();
+
+            var types = comp.GetTypesByMetadataName("N.C`1");
+
+            Assert.Equal(3, types.Length);
+            AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString());
+            Assert.Same(comp.Assembly.GetPublicSymbol(), types[0].ContainingAssembly);
+            AssertEx.Equal("N.C<T>", types[1].ToTestDisplayString());
+            AssertEx.Equal("N.C<T>", types[2].ToTestDisplayString());
+
+            var assembly1 = comp.GetAssemblyOrModuleSymbol(reference1).GetPublicSymbol();
+            Assert.Same(types[1].ContainingAssembly, assembly1);
+
+            var assembly2 = comp.GetAssemblyOrModuleSymbol(reference2).GetPublicSymbol();
+            Assert.Same(types[2].ContainingAssembly, assembly2);
+
+            MetadataReference getReference(CSharpCompilation referenceComp1)
+            {
+                return useMetadataReference ? referenceComp1.ToMetadataReference() : referenceComp1.EmitToImageReference();
+            }
+        }
+
+        [Fact]
+        public void GetTypesByMetadataName_Ordering()
+        {
+            var corlibSource = @"
+namespace System
+{
+    public class Object {}
+    public class Void {}
+}
+
+public class C {}
+";
+
+            var corlib = CreateEmptyCompilation(corlibSource);
+            var corlibReference = corlib.EmitToImageReference();
+
+            var other = CreateEmptyCompilation(@"public class C {}", new[] { corlibReference });
+            var otherReference = other.EmitToImageReference();
+
+            var current = CreateEmptyCompilation(@"public class C {}", new[] { otherReference, corlibReference });
+            current.VerifyDiagnostics();
+
+            var types = current.GetTypesByMetadataName("C");
+
+            AssertEx.Equal(types.Select(t => t.ToTestDisplayString()), new[] { "C", "C", "C" });
+            Assert.Same(types[0].ContainingAssembly, current.Assembly.GetPublicSymbol());
+
+            var corlibAssembly = current.GetAssemblyOrModuleSymbol(corlibReference).GetPublicSymbol();
+            Assert.Same(types[1].ContainingAssembly, corlibAssembly);
+
+            var otherAssembly = current.GetAssemblyOrModuleSymbol(otherReference).GetPublicSymbol();
+            Assert.Same(types[2].ContainingAssembly, otherAssembly);
+        }
+
+        [Fact]
+        public void GetTypeByMetadataName_CorLibViaExtern()
+        {
+            var corlibSource = @"
+namespace System
+{
+    public class Object {}
+    public class Void {}
+}
+
+public class C {}
+";
+
+            var corlib = CreateEmptyCompilation(corlibSource);
+            var corlibReference = corlib.EmitToImageReference(aliases: ImmutableArray.Create("corlib"));
+
+            var current = CreateEmptyCompilation(@"", new[] { corlibReference });
+            current.VerifyDiagnostics();
+
+            var type = ((Compilation)current).GetTypeByMetadataName("C");
+            Assert.NotNull(type);
+
+            var corlibAssembly = current.GetAssemblyOrModuleSymbol(corlibReference).GetPublicSymbol();
+            Assert.Same(type.ContainingAssembly, corlibAssembly);
+        }
+
+        [Fact]
+        public void GetTypeByMetadataName_OtherViaExtern()
+        {
+            var corlibSource = @"
+namespace System
+{
+    public class Object {}
+    public class Void {}
+}
+";
+
+            var corlib = CreateEmptyCompilation(corlibSource);
+            var corlibReference = corlib.EmitToImageReference();
+
+            var other = CreateEmptyCompilation(@"public class C {}", new[] { corlibReference });
+            var otherReference = other.EmitToImageReference(aliases: ImmutableArray.Create("other"));
+
+            var current = CreateEmptyCompilation(@"", new[] { otherReference, corlibReference });
+            current.VerifyDiagnostics();
+
+            var type = ((Compilation)current).GetTypeByMetadataName("C");
+            Assert.Null(type);
+        }
+
+        #endregion
     }
 }
diff --git a/src/Compilers/Core/Portable/Compilation/Compilation.cs b/src/Compilers/Core/Portable/Compilation/Compilation.cs
index 037ea63240a7d..d48762238a837 100644
--- a/src/Compilers/Core/Portable/Compilation/Compilation.cs
+++ b/src/Compilers/Core/Portable/Compilation/Compilation.cs
@@ -1025,28 +1025,122 @@ public INamedTypeSymbol CreateNativeIntegerTypeSymbol(bool signed)
         private readonly ConcurrentCache<string, INamedTypeSymbol?> _getTypeCache =
             new ConcurrentCache<string, INamedTypeSymbol?>(50, ReferenceEqualityComparer.Instance);
 
+        private readonly ConcurrentCache<string, ImmutableArray<INamedTypeSymbol>> _getTypesCache =
+            new ConcurrentCache<string, ImmutableArray<INamedTypeSymbol>>(50, ReferenceEqualityComparer.Instance);
+
         /// <summary>
         /// Gets the type within the compilation's assembly and all referenced assemblies (other than
         /// those that can only be referenced via an extern alias) using its canonical CLR metadata name.
-        /// </summary>
-        /// <returns>Null if the type can't be found.</returns>
+        /// This lookup follows the following order:
+        /// <list type="number">
+        /// <item><description>If the type is found in the compilation's assembly, that type is returned.</description></item>
+        /// <item><description>
+        /// Next, the core library (the library that defines <c>System.Object</c> and has no assembly references) is searched.
+        /// If the type is found there, that type is returned.
+        /// </description></item>
+        /// <item><description>
+        /// Finally, all remaining referenced non-extern assemblies are searched. If one and only one type matching the provided metadata name is found, that
+        /// single type is returned. Accessibility is ignored for this check.
+        /// </description></item>
+        /// </list>
+        /// </summary>
+        /// <returns>Null if the type can't be found or there was an ambiguity during lookup.</returns>
         /// <remarks>
+        /// <para>
         /// Since VB does not have the concept of extern aliases, it considers all referenced assemblies.
+        /// </para>
+        /// <para>
+        /// In C#, if the core library is referenced as an extern assembly, it will be searched. All other extern-aliased assemblies will not be searched.
+        /// </para>
+        /// <para>
+        /// Because accessibility to the current assembly is ignored when searching for types that match the provided metadata name, if multiple referenced
+        /// assemblies define the same type symbol (as often happens when users copy well-known types from the BCL or other sources) then this API will return null,
+        /// even if all but one of those symbols would be otherwise inaccessible to user-written code in the current assembly. For fine-grained control over ambiguity
+        /// resolution, consider using <see cref="GetTypesByMetadataName(string)" /> instead and filtering the results for the symbol required.
+        /// </para>
+        /// <para>
+        /// Assemblies can contain multiple modules. Within each assembly, the search is performed based on module's position in the module list of that assembly. When
+        /// a match is found in one module in an assembly, no further modules within that assembly are searched.
+        /// </para>
+        /// <para>Type forwarders are ignored, and not considered part of the assembly where the TypeForwardAttribute is written.</para>
         /// </remarks>
         public INamedTypeSymbol? GetTypeByMetadataName(string fullyQualifiedMetadataName)
         {
             if (!_getTypeCache.TryGetValue(fullyQualifiedMetadataName, out INamedTypeSymbol? val))
             {
                 val = CommonGetTypeByMetadataName(fullyQualifiedMetadataName);
-                // Ignore if someone added the same value before us
-                _ = _getTypeCache.TryAdd(fullyQualifiedMetadataName, val);
+                var result = _getTypeCache.TryAdd(fullyQualifiedMetadataName, val);
+                Debug.Assert(result || (_getTypeCache.TryGetValue(fullyQualifiedMetadataName, out var addedType) && ReferenceEquals(addedType, val)));
             }
             return val;
         }
 
         protected abstract INamedTypeSymbol? CommonGetTypeByMetadataName(string metadataName);
 
-#pragma warning disable RS0026 // Do not add multiple public overloads with optional parameters
+        /// <summary>
+        /// Gets all types with the compilation's assembly and all referenced assemblies that have the
+        /// given canonical CLR metadata name. Accessibility to the current assembly is ignored when
+        /// searching for matching type names.
+        /// </summary>
+        /// <returns>Empty array if no types match. Otherwise, all types that match the name, current assembly first if present.</returns>
+        /// <remarks>
+        /// <para>
+        /// Assemblies can contain multiple modules. Within each assembly, the search is performed based on module's position in the module list of that assembly. When
+        /// a match is found in one module in an assembly, no further modules within that assembly are searched.
+        /// </para>
+        /// <para>Type forwarders are ignored, and not considered part of the assembly where the TypeForwardAttribute is written.</para>
+        /// </remarks>
+        public ImmutableArray<INamedTypeSymbol> GetTypesByMetadataName(string fullyQualifiedMetadataName)
+        {
+            if (!_getTypesCache.TryGetValue(fullyQualifiedMetadataName, out ImmutableArray<INamedTypeSymbol> val))
+            {
+                val = getTypesByMetadataNameImpl();
+                var result = _getTypesCache.TryAdd(fullyQualifiedMetadataName, val);
+                Debug.Assert(result
+                    || (_getTypesCache.TryGetValue(fullyQualifiedMetadataName, out var addedArray)
+                        && Enumerable.SequenceEqual(addedArray, val, ReferenceEqualityComparer.Instance)));
+            }
+
+            return val;
+
+            ImmutableArray<INamedTypeSymbol> getTypesByMetadataNameImpl()
+            {
+                ArrayBuilder<INamedTypeSymbol>? typesByMetadataName = null;
+
+                // Start with the current assembly, then corlib, then look through all references, to mimic GetTypeByMetadataName search order.
+
+                addIfNotNull(Assembly.GetTypeByMetadataName(fullyQualifiedMetadataName));
+
+                var corLib = ObjectType.ContainingAssembly;
+
+                if (!ReferenceEquals(corLib, Assembly))
+                {
+                    addIfNotNull(corLib.GetTypeByMetadataName(fullyQualifiedMetadataName));
+                }
+
+                foreach (var referencedAssembly in SourceModule.ReferencedAssemblySymbols)
+                {
+                    if (ReferenceEquals(referencedAssembly, corLib))
+                    {
+                        continue;
+                    }
+
+                    addIfNotNull(referencedAssembly.GetTypeByMetadataName(fullyQualifiedMetadataName));
+                }
+
+                return typesByMetadataName?.ToImmutableAndFree() ?? ImmutableArray<INamedTypeSymbol>.Empty;
+
+                void addIfNotNull(INamedTypeSymbol? toAdd)
+                {
+                    if (toAdd != null)
+                    {
+                        typesByMetadataName ??= ArrayBuilder<INamedTypeSymbol>.GetInstance();
+                        typesByMetadataName.Add(toAdd);
+                    }
+                }
+            }
+        }
+
         /// <summary>
         /// Returns a new INamedTypeSymbol with the given element types and
         /// (optional) element names, locations, and nullable annotations.
@@ -1087,7 +1181,6 @@ public INamedTypeSymbol CreateTupleTypeSymbol(
 
             return CommonCreateTupleTypeSymbol(elementTypes, elementNames, elementLocations, elementNullableAnnotations);
         }
-#pragma warning restore RS0026 // Do not add multiple public overloads with optional parameters
 
         /// <summary>
         /// Returns a new INamedTypeSymbol with the given element types, names, and locations.
diff --git a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
index 02161a15fe460..ad76fcb80cd4d 100644
--- a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
+++ b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
@@ -9,6 +9,7 @@ const Microsoft.CodeAnalysis.WellKnownGeneratorOutputs.ImplementationSourceOutpu
 const Microsoft.CodeAnalysis.WellKnownGeneratorOutputs.SourceOutput = "SourceOutput" -> string!
 const Microsoft.CodeAnalysis.WellKnownMemberNames.PrintMembersMethodName = "PrintMembers" -> string!
 Microsoft.CodeAnalysis.Compilation.EmitDifference(Microsoft.CodeAnalysis.Emit.EmitBaseline! baseline, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.Emit.SemanticEdit>! edits, System.Func<Microsoft.CodeAnalysis.ISymbol!, bool>! isAddedSymbol, System.IO.Stream! metadataStream, System.IO.Stream! ilStream, System.IO.Stream! pdbStream, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.Emit.EmitDifferenceResult!
+Microsoft.CodeAnalysis.Compilation.GetTypesByMetadataName(string! fullyQualifiedMetadataName) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.INamedTypeSymbol!>
 Microsoft.CodeAnalysis.Emit.EmitDifferenceResult.ChangedTypes.get -> System.Collections.Immutable.ImmutableArray<System.Reflection.Metadata.TypeDefinitionHandle>
 Microsoft.CodeAnalysis.Emit.EmitDifferenceResult.UpdatedMethods.get -> System.Collections.Immutable.ImmutableArray<System.Reflection.Metadata.MethodDefinitionHandle>
 Microsoft.CodeAnalysis.Emit.SemanticEditKind.Replace = 4 -> Microsoft.CodeAnalysis.Emit.SemanticEditKind
diff --git a/src/Compilers/VisualBasic/Test/Symbol/CompilationAPITests.vb b/src/Compilers/VisualBasic/Test/Symbol/CompilationAPITests.vb
new file mode 100644
index 0000000000000..b0f3ed506cc9f
--- /dev/null
+++ b/src/Compilers/VisualBasic/Test/Symbol/CompilationAPITests.vb
@@ -0,0 +1,226 @@
+' 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.
+
+Imports Microsoft.CodeAnalysis.Test.Utilities
+Imports Roslyn.Test.Utilities
+
+Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests
+
+    Public Class CompilationAPITests
+        Inherits BasicTestBase
+
+        <Fact()>
+        Public Sub GetTypesByMetadataName_NotInSourceNotInReferences()
+            Dim comp = CreateCompilation("")
+            comp.AssertNoDiagnostics()
+
+            Dim types = comp.GetTypesByMetadataName("N.C`1")
+            Assert.Empty(types)
+        End Sub
+
+        <Theory, CombinatorialData>
+        Public Sub GetTypesByMetadataName_SingleInSourceNotInReferences(useMetadataReferences As Boolean, <CombinatorialValues("Public", "Friend")> accessibility As String)
+            Dim referenceComp = CreateCompilation("")
+
+            Dim source =
+$"Namespace N
+    {accessibility} Class C(Of T)
+    End Class
+End Namespace"
+
+            Dim comp = CreateCompilation(source, {If(useMetadataReferences, referenceComp.ToMetadataReference(), referenceComp.EmitToImageReference())})
+            comp.AssertNoDiagnostics()
+
+            Dim types = comp.GetTypesByMetadataName("N.C`1")
+
+            Assert.Single(types)
+            AssertEx.Equal("N.C(Of T)", types(0).ToTestDisplayString())
+        End Sub
+
+        <Theory, CombinatorialData>
+        Public Sub GetTypesByMetadataName_MultipleInSourceNotInReferences(useMetadataReferences As Boolean, <CombinatorialValues("Public", "Friend")> accessibility As String)
+            Dim referenceComp = CreateCompilation("")
+
+            Dim source =
+$"Namespace N
+    {accessibility} Class C(Of T)
+    End Class
+    {accessibility} Class C(Of T)
+    End Class
+End Namespace"
+
+            Dim comp = CreateCompilation(source, {If(useMetadataReferences, referenceComp.ToMetadataReference(), referenceComp.EmitToImageReference())})
+            comp.AssertTheseDiagnostics(
+<expected>
+BC30179: class 'C' and class 'C' conflict in namespace 'N'.
+    <%= accessibility %> Class C(Of T)
+                 ~
+</expected>)
+
+            Dim types = comp.GetTypesByMetadataName("N.C`1")
+
+            Assert.Single(types)
+            AssertEx.Equal("N.C(Of T)", types(0).ToTestDisplayString())
+            Assert.Equal(2, types(0).Locations.Length)
+        End Sub
+
+        <Theory, CombinatorialData>
+        Public Sub GetTypesByMetadataName_SingleInSourceSingleInReferences(useMetadataReference As Boolean, <CombinatorialValues("Public", "Friend")> accessibility As String)
+            Dim source =
+$"Namespace N
+    {accessibility} Class C(Of T)
+    End Class
+End Namespace"
+
+            Dim referenceComp = CreateCompilation(source)
+            Dim reference As MetadataReference = If(useMetadataReference, referenceComp.ToMetadataReference(), referenceComp.EmitToImageReference())
+            Dim comp = CreateCompilation(source, {reference})
+            comp.AssertNoDiagnostics()
+
+            Dim types = comp.GetTypesByMetadataName("N.C`1")
+
+            Assert.Equal(2, types.Length)
+            AssertEx.Equal("N.C(Of T)", types(0).ToTestDisplayString())
+            Assert.Same(comp.Assembly, types(0).ContainingAssembly)
+            AssertEx.Equal("N.C(Of T)", types(1).ToTestDisplayString())
+
+            Dim referenceAssembly = comp.GetAssemblyOrModuleSymbol(reference)
+            Assert.Same(types(1).ContainingAssembly, referenceAssembly)
+        End Sub
+
+        <Theory, CombinatorialData>
+        Public Sub GetTypesByMetadataName_NotInSourceSingleInReferences(useMetadataReference As Boolean, <CombinatorialValues("Public", "Friend")> accessibility As String)
+            Dim source =
+$"Namespace N
+    {accessibility} Class C(Of T)
+    End Class
+End Namespace"
+
+            Dim referenceComp = CreateCompilation(source)
+            Dim reference As MetadataReference = GetReference(useMetadataReference, referenceComp)
+            Dim comp = CreateCompilation("", {reference})
+            comp.AssertNoDiagnostics()
+
+            Dim types = comp.GetTypesByMetadataName("N.C`1")
+
+            Assert.Single(types)
+            AssertEx.Equal("N.C(Of T)", types(0).ToTestDisplayString())
+
+            Dim referenceAssembly = comp.GetAssemblyOrModuleSymbol(reference)
+            Assert.Same(types(0).ContainingAssembly, referenceAssembly)
+        End Sub
+
+        Private Shared Function GetReference(useMetadataReference As Boolean, referenceComp As VisualBasicCompilation) As MetadataReference
+            Return If(useMetadataReference, referenceComp.ToMetadataReference(), referenceComp.EmitToImageReference())
+        End Function
+
+        <Theory, CombinatorialData>
+        Public Sub GetTypesByMetadataName_NotInSourceMultipleInReferences(useMetadataReference As Boolean, <CombinatorialValues("Public", "Friend")> accessibility As String)
+            Dim source =
+$"Namespace N
+    {accessibility} Class C(Of T)
+    End Class
+End Namespace"
+
+            Dim referenceComp1 = CreateCompilation(source)
+            Dim referenceComp2 = CreateCompilation(source)
+            Dim reference1 As MetadataReference = GetReference(useMetadataReference, referenceComp1)
+            Dim reference2 As MetadataReference = GetReference(useMetadataReference, referenceComp2)
+            Dim comp = CreateCompilation("", {reference1, reference2})
+            comp.AssertNoDiagnostics()
+
+            Dim types = comp.GetTypesByMetadataName("N.C`1")
+
+            Assert.Equal(2, types.Length)
+            AssertEx.Equal("N.C(Of T)", types(0).ToTestDisplayString())
+            AssertEx.Equal("N.C(Of T)", types(1).ToTestDisplayString())
+
+            Dim referenceAssembly1 = comp.GetAssemblyOrModuleSymbol(reference1)
+            Assert.Same(types(0).ContainingAssembly, referenceAssembly1)
+
+            Dim referenceAssembly2 = comp.GetAssemblyOrModuleSymbol(reference2)
+            Assert.Same(types(1).ContainingAssembly, referenceAssembly2)
+
+            If (useMetadataReference) Then
+            Else
+                Assert.False(types(0).IsInSource())
+                Assert.False(types(1).IsInSource())
+            End If
+        End Sub
+
+        <Theory, CombinatorialData>
+        Public Sub GetTypesByMetadataName_SingleInSourceMultipleInReferences(useMetadataReference As Boolean, <CombinatorialValues("Public", "Friend")> accessibility As String)
+            Dim source =
+$"Namespace N
+    {accessibility} Class C(Of T)
+    End Class
+End Namespace"
+
+            Dim referenceComp1 = CreateCompilation(source)
+            Dim referenceComp2 = CreateCompilation(source)
+            Dim reference1 As MetadataReference = GetReference(useMetadataReference, referenceComp1)
+            Dim reference2 As MetadataReference = GetReference(useMetadataReference, referenceComp2)
+            Dim comp = CreateCompilation(source, {reference1, reference2})
+            comp.AssertNoDiagnostics()
+
+            Dim types = comp.GetTypesByMetadataName("N.C`1")
+
+            Assert.Equal(3, types.Length)
+            AssertEx.Equal("N.C(Of T)", types(0).ToTestDisplayString())
+            Assert.Same(comp.Assembly, types(0).ContainingAssembly)
+            AssertEx.Equal("N.C(Of T)", types(1).ToTestDisplayString())
+            AssertEx.Equal("N.C(Of T)", types(2).ToTestDisplayString())
+
+            Dim referenceAssembly1 = comp.GetAssemblyOrModuleSymbol(reference1)
+            Assert.Same(types(1).ContainingAssembly, referenceAssembly1)
+
+            Dim referenceAssembly2 = comp.GetAssemblyOrModuleSymbol(reference2)
+            Assert.Same(types(2).ContainingAssembly, referenceAssembly2)
+        End Sub
+
+        <Fact>
+        Public Sub GetTypesByMetadataName_Ordering()
+            Dim corlibSource = "
+Namespace System
+    Public Class [Object]
+    End Class
+    Public Class [Void]
+    End Class
+End Namespace
+Public Class C
+End Class
+"
+
+            Dim corlib = CreateEmptyCompilation(corlibSource)
+            Dim corlibReference = corlib.EmitToImageReference()
+
+            Dim otherSource = "
+Public Class C
+End Class
+"
+
+            Dim other = CreateEmptyCompilation(otherSource, {corlibReference})
+            Dim otherReference = other.EmitToImageReference()
+
+            Dim currentSource = "
+Public Class C
+End Class
+"
+            Dim current = CreateEmptyCompilation(currentSource, {otherReference, corlibReference})
+            current.AssertNoDiagnostics()
+
+            Dim types = current.GetTypesByMetadataName("C")
+
+            AssertEx.Equal(types.Select(Function(t) t.ToTestDisplayString()), {"C", "C", "C"})
+
+            Assert.Same(current.Assembly, types(0).ContainingAssembly)
+
+            Dim corlibAssembly = current.GetAssemblyOrModuleSymbol(corlibReference)
+            Assert.Same(types(1).ContainingAssembly, corlibAssembly)
+
+            Dim otherAssembly = current.GetAssemblyOrModuleSymbol(otherReference)
+            Assert.Same(types(2).ContainingAssembly, otherAssembly)
+        End Sub
+    End Class
+End Namespace
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/CompilationExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/CompilationExtensions.cs
index 649d9f7bfa377..0384afee7e1fc 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/CompilationExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/CompilationExtensions.cs
@@ -2,6 +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.Diagnostics;
+
 namespace Microsoft.CodeAnalysis.Shared.Extensions
 {
     internal static class CompilationExtensions
@@ -33,42 +35,33 @@ internal static class CompilationExtensions
         /// <returns>The symbol to use for code analysis; otherwise, <see langword="null"/>.</returns>
         public static INamedTypeSymbol? GetBestTypeByMetadataName(this Compilation compilation, string fullyQualifiedMetadataName)
         {
-            // Try to get the unique type with this name, ignoring accessibility
-            var type = compilation.GetTypeByMetadataName(fullyQualifiedMetadataName);
-
-            // Otherwise, try to get the unique type with this name originally defined in 'compilation'
-            type ??= compilation.Assembly.GetTypeByMetadataName(fullyQualifiedMetadataName);
+            INamedTypeSymbol? type = null;
 
-            // Otherwise, try to get the unique accessible type with this name from a reference
-            if (type is null)
+            foreach (var currentType in compilation.GetTypesByMetadataName(fullyQualifiedMetadataName))
             {
-                foreach (var module in compilation.Assembly.Modules)
+                if (ReferenceEquals(currentType.ContainingAssembly, compilation.Assembly))
                 {
-                    foreach (var referencedAssembly in module.ReferencedAssemblySymbols)
-                    {
-                        var currentType = referencedAssembly.GetTypeByMetadataName(fullyQualifiedMetadataName);
-                        if (currentType is null)
-                            continue;
-
-                        switch (currentType.GetResultantVisibility())
-                        {
-                            case Utilities.SymbolVisibility.Public:
-                            case Utilities.SymbolVisibility.Internal when referencedAssembly.GivesAccessTo(compilation.Assembly):
-                                break;
+                    Debug.Assert(type is null);
+                    return currentType;
+                }
 
-                            default:
-                                continue;
-                        }
+                switch (currentType.GetResultantVisibility())
+                {
+                    case Utilities.SymbolVisibility.Public:
+                    case Utilities.SymbolVisibility.Internal when currentType.ContainingAssembly.GivesAccessTo(compilation.Assembly):
+                        break;
 
-                        if (type is object)
-                        {
-                            // Multiple visible types with the same metadata name are present
-                            return null;
-                        }
+                    default:
+                        continue;
+                }
 
-                        type = currentType;
-                    }
+                if (type is object)
+                {
+                    // Multiple visible types with the same metadata name are present
+                    return null;
                 }
+
+                type = currentType;
             }
 
             return type;

From 4052d3c0dba594d91d18c7a8084731ad8c18c2a2 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Thu, 6 Jan 2022 12:24:40 -0800
Subject: [PATCH 275/444] Move responsive completion configuration to state
 reset service

---
 .../InProcess/EditorInProcess.cs                   | 14 --------------
 .../InProcess/StateResetInProcess.cs               | 11 +++++++++++
 2 files changed, 11 insertions(+), 14 deletions(-)

diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/EditorInProcess.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/EditorInProcess.cs
index 52d868cd329e8..e4fffaa3277e4 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/EditorInProcess.cs
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/EditorInProcess.cs
@@ -129,20 +129,6 @@ public async Task SetUseSuggestionModeAsync(bool forDebuggerTextView, bool value
                     throw new InvalidOperationException($"{WellKnownCommandNames.Edit_ToggleCompletionMode} did not leave the editor in the expected state.");
                 }
             }
-
-            if (!value)
-            {
-                // For blocking completion mode, make sure we don't have responsive completion interfering when
-                // integration tests run slowly.
-                await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
-
-                var editorOptionsFactory = await GetComponentModelServiceAsync<IEditorOptionsFactoryService>(cancellationToken);
-                var options = editorOptionsFactory.GlobalOptions;
-                options.SetOptionValue(DefaultOptions.ResponsiveCompletionOptionId, false);
-
-                var latencyGuardOptionKey = new EditorOptionKey<bool>("EnableTypingLatencyGuard");
-                options.SetOptionValue(latencyGuardOptionKey, false);
-            }
         }
 
         private static bool IsDebuggerTextView(ITextView textView)
diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/StateResetInProcess.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/StateResetInProcess.cs
index c040870b6303b..57d5ad9e7e93f 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/StateResetInProcess.cs
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/StateResetInProcess.cs
@@ -8,6 +8,7 @@
 using Microsoft.CodeAnalysis.Editor.Options;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.VisualStudio.Extensibility.Testing;
+using Microsoft.VisualStudio.Text.Editor;
 
 namespace Roslyn.VisualStudio.IntegrationTests.InProcess
 {
@@ -22,9 +23,19 @@ public async Task ResetGlobalOptionsAsync(CancellationToken cancellationToken)
 
         public async Task ResetHostSettingsAsync(CancellationToken cancellationToken)
         {
+            await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+
             // Suggestion mode defaults to on for debugger views, and off for other views.
             await TestServices.Editor.SetUseSuggestionModeAsync(forDebuggerTextView: true, true, cancellationToken);
             await TestServices.Editor.SetUseSuggestionModeAsync(forDebuggerTextView: false, false, cancellationToken);
+
+            // Make sure responsive completion doesn't interfere if integration tests run slowly.
+            var editorOptionsFactory = await GetComponentModelServiceAsync<IEditorOptionsFactoryService>(cancellationToken);
+            var options = editorOptionsFactory.GlobalOptions;
+            options.SetOptionValue(DefaultOptions.ResponsiveCompletionOptionId, false);
+
+            var latencyGuardOptionKey = new EditorOptionKey<bool>("EnableTypingLatencyGuard");
+            options.SetOptionValue(latencyGuardOptionKey, false);
         }
     }
 }

From dc5540219106df3fe54c41e3a56cd57fef31ae6b Mon Sep 17 00:00:00 2001
From: dotnet bot <dotnet-bot@dotnetfoundation.org>
Date: Fri, 7 Jan 2022 12:00:10 -0800
Subject: [PATCH 276/444] Localized file check-in by OneLocBuild Task: Build
 definition ID 327: Build ID 1541625

---
 .../xlf/CSharpAnalyzersResources.cs.xlf       |  6 +-
 .../xlf/CSharpAnalyzersResources.de.xlf       |  6 +-
 .../xlf/CSharpAnalyzersResources.es.xlf       |  6 +-
 .../xlf/CSharpAnalyzersResources.fr.xlf       |  6 +-
 .../xlf/CSharpAnalyzersResources.it.xlf       |  6 +-
 .../xlf/CSharpAnalyzersResources.ja.xlf       |  6 +-
 .../xlf/CSharpAnalyzersResources.ko.xlf       |  6 +-
 .../xlf/CSharpAnalyzersResources.pl.xlf       |  6 +-
 .../xlf/CSharpAnalyzersResources.pt-BR.xlf    |  6 +-
 .../xlf/CSharpAnalyzersResources.ru.xlf       |  6 +-
 .../xlf/CSharpAnalyzersResources.tr.xlf       |  6 +-
 .../xlf/CSharpAnalyzersResources.zh-Hans.xlf  |  6 +-
 .../xlf/CSharpAnalyzersResources.zh-Hant.xlf  |  6 +-
 .../Portable/xlf/CSharpResources.cs.xlf       | 58 +++++++++----------
 .../Portable/xlf/CSharpResources.de.xlf       | 50 ++++++++--------
 .../Portable/xlf/CSharpResources.es.xlf       | 50 ++++++++--------
 .../Portable/xlf/CSharpResources.fr.xlf       | 50 ++++++++--------
 .../Portable/xlf/CSharpResources.it.xlf       | 52 ++++++++---------
 .../Portable/xlf/CSharpResources.ja.xlf       | 52 ++++++++---------
 .../Portable/xlf/CSharpResources.ko.xlf       | 50 ++++++++--------
 .../Portable/xlf/CSharpResources.pl.xlf       | 50 ++++++++--------
 .../Portable/xlf/CSharpResources.pt-BR.xlf    | 50 ++++++++--------
 .../Portable/xlf/CSharpResources.ru.xlf       | 52 ++++++++---------
 .../Portable/xlf/CSharpResources.tr.xlf       | 56 +++++++++---------
 .../Portable/xlf/CSharpResources.zh-Hans.xlf  | 52 ++++++++---------
 .../Portable/xlf/CSharpResources.zh-Hant.xlf  | 50 ++++++++--------
 .../Portable/xlf/CodeAnalysisResources.tr.xlf |  4 +-
 .../Portable/xlf/VBResources.cs.xlf           |  6 +-
 28 files changed, 380 insertions(+), 380 deletions(-)

diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.cs.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.cs.xlf
index be38ae577fa07..71f12b51220f1 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.cs.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.cs.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Property_pattern_can_be_simplified">
         <source>Property pattern can be simplified</source>
-        <target state="new">Property pattern can be simplified</target>
+        <target state="translated">Vzor vlastnosti se dá zjednodušit.</target>
         <note />
       </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
@@ -139,7 +139,7 @@
       </trans-unit>
       <trans-unit id="Simplify_property_pattern">
         <source>Simplify property pattern</source>
-        <target state="new">Simplify property pattern</target>
+        <target state="translated">Zjednodušit vzor vlastnosti</target>
         <note />
       </trans-unit>
       <trans-unit id="Struct_contains_assignment_to_this_outside_of_constructor_Make_readonly_fields_writable">
@@ -289,7 +289,7 @@
       </trans-unit>
       <trans-unit id="Use_tuple_to_swap_values">
         <source>Use tuple to swap values</source>
-        <target state="new">Use tuple to swap values</target>
+        <target state="translated">Prohození hodnot pomocí řazené kolekce členů</target>
         <note />
       </trans-unit>
       <trans-unit id="Using_directives_must_be_placed_inside_of_a_namespace_declaration">
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.de.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.de.xlf
index de593ee65610b..3e5557f631d40 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.de.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.de.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Property_pattern_can_be_simplified">
         <source>Property pattern can be simplified</source>
-        <target state="new">Property pattern can be simplified</target>
+        <target state="translated">Das Eigenschaftsmuster kann vereinfacht werden.</target>
         <note />
       </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
@@ -139,7 +139,7 @@
       </trans-unit>
       <trans-unit id="Simplify_property_pattern">
         <source>Simplify property pattern</source>
-        <target state="new">Simplify property pattern</target>
+        <target state="translated">Eigenschaftenmuster vereinfachen</target>
         <note />
       </trans-unit>
       <trans-unit id="Struct_contains_assignment_to_this_outside_of_constructor_Make_readonly_fields_writable">
@@ -289,7 +289,7 @@
       </trans-unit>
       <trans-unit id="Use_tuple_to_swap_values">
         <source>Use tuple to swap values</source>
-        <target state="new">Use tuple to swap values</target>
+        <target state="translated">Tupel zum Tauschen von Werten verwenden</target>
         <note />
       </trans-unit>
       <trans-unit id="Using_directives_must_be_placed_inside_of_a_namespace_declaration">
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.es.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.es.xlf
index ad0f16fb97f56..a60eefb5c1190 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.es.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.es.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Property_pattern_can_be_simplified">
         <source>Property pattern can be simplified</source>
-        <target state="new">Property pattern can be simplified</target>
+        <target state="translated">El patrón de propiedad puede ser simplificado</target>
         <note />
       </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
@@ -139,7 +139,7 @@
       </trans-unit>
       <trans-unit id="Simplify_property_pattern">
         <source>Simplify property pattern</source>
-        <target state="new">Simplify property pattern</target>
+        <target state="translated">Simplificar el patrón de propiedad</target>
         <note />
       </trans-unit>
       <trans-unit id="Struct_contains_assignment_to_this_outside_of_constructor_Make_readonly_fields_writable">
@@ -289,7 +289,7 @@
       </trans-unit>
       <trans-unit id="Use_tuple_to_swap_values">
         <source>Use tuple to swap values</source>
-        <target state="new">Use tuple to swap values</target>
+        <target state="translated">Utilizar tupla para intercambiar valores</target>
         <note />
       </trans-unit>
       <trans-unit id="Using_directives_must_be_placed_inside_of_a_namespace_declaration">
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.fr.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.fr.xlf
index f9cf8172a54d7..5a3d3b6b42daf 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.fr.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.fr.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Property_pattern_can_be_simplified">
         <source>Property pattern can be simplified</source>
-        <target state="new">Property pattern can be simplified</target>
+        <target state="translated">Le modèle de propriété peut être simplifié</target>
         <note />
       </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
@@ -139,7 +139,7 @@
       </trans-unit>
       <trans-unit id="Simplify_property_pattern">
         <source>Simplify property pattern</source>
-        <target state="new">Simplify property pattern</target>
+        <target state="translated">Simplifier le modèle de propriété</target>
         <note />
       </trans-unit>
       <trans-unit id="Struct_contains_assignment_to_this_outside_of_constructor_Make_readonly_fields_writable">
@@ -289,7 +289,7 @@
       </trans-unit>
       <trans-unit id="Use_tuple_to_swap_values">
         <source>Use tuple to swap values</source>
-        <target state="new">Use tuple to swap values</target>
+        <target state="translated">Utilisez le tuple pour échanger des valeurs</target>
         <note />
       </trans-unit>
       <trans-unit id="Using_directives_must_be_placed_inside_of_a_namespace_declaration">
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.it.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.it.xlf
index 2bced89905496..8a1b6b4cfea43 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.it.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.it.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Property_pattern_can_be_simplified">
         <source>Property pattern can be simplified</source>
-        <target state="new">Property pattern can be simplified</target>
+        <target state="translated">Il modello di proprietà può essere semplificato</target>
         <note />
       </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
@@ -139,7 +139,7 @@
       </trans-unit>
       <trans-unit id="Simplify_property_pattern">
         <source>Simplify property pattern</source>
-        <target state="new">Simplify property pattern</target>
+        <target state="translated">Semplifica il modello di proprietà</target>
         <note />
       </trans-unit>
       <trans-unit id="Struct_contains_assignment_to_this_outside_of_constructor_Make_readonly_fields_writable">
@@ -289,7 +289,7 @@
       </trans-unit>
       <trans-unit id="Use_tuple_to_swap_values">
         <source>Use tuple to swap values</source>
-        <target state="new">Use tuple to swap values</target>
+        <target state="translated">Usa la tupla per scambiare i valori</target>
         <note />
       </trans-unit>
       <trans-unit id="Using_directives_must_be_placed_inside_of_a_namespace_declaration">
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ja.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ja.xlf
index f36328909a864..1a7f9c2a413d5 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ja.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ja.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Property_pattern_can_be_simplified">
         <source>Property pattern can be simplified</source>
-        <target state="new">Property pattern can be simplified</target>
+        <target state="translated">プロパティ パターンは簡略化できます</target>
         <note />
       </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
@@ -139,7 +139,7 @@
       </trans-unit>
       <trans-unit id="Simplify_property_pattern">
         <source>Simplify property pattern</source>
-        <target state="new">Simplify property pattern</target>
+        <target state="translated">プロパティ パターンを簡略化する</target>
         <note />
       </trans-unit>
       <trans-unit id="Struct_contains_assignment_to_this_outside_of_constructor_Make_readonly_fields_writable">
@@ -289,7 +289,7 @@
       </trans-unit>
       <trans-unit id="Use_tuple_to_swap_values">
         <source>Use tuple to swap values</source>
-        <target state="new">Use tuple to swap values</target>
+        <target state="translated">タプルを使用して値をスワップする</target>
         <note />
       </trans-unit>
       <trans-unit id="Using_directives_must_be_placed_inside_of_a_namespace_declaration">
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ko.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ko.xlf
index ce043a110e343..b252cc092ad32 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ko.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ko.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Property_pattern_can_be_simplified">
         <source>Property pattern can be simplified</source>
-        <target state="new">Property pattern can be simplified</target>
+        <target state="translated">속성 패턴을 간소화할 수 있습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
@@ -139,7 +139,7 @@
       </trans-unit>
       <trans-unit id="Simplify_property_pattern">
         <source>Simplify property pattern</source>
-        <target state="new">Simplify property pattern</target>
+        <target state="translated">속성 패턴 간소화</target>
         <note />
       </trans-unit>
       <trans-unit id="Struct_contains_assignment_to_this_outside_of_constructor_Make_readonly_fields_writable">
@@ -289,7 +289,7 @@
       </trans-unit>
       <trans-unit id="Use_tuple_to_swap_values">
         <source>Use tuple to swap values</source>
-        <target state="new">Use tuple to swap values</target>
+        <target state="translated">튜플을 사용하여 값 바꾸기</target>
         <note />
       </trans-unit>
       <trans-unit id="Using_directives_must_be_placed_inside_of_a_namespace_declaration">
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pl.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pl.xlf
index af3991d281da5..58cd26c5b9fab 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pl.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pl.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Property_pattern_can_be_simplified">
         <source>Property pattern can be simplified</source>
-        <target state="new">Property pattern can be simplified</target>
+        <target state="translated">Wzorzec właściwości można uprościć</target>
         <note />
       </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
@@ -139,7 +139,7 @@
       </trans-unit>
       <trans-unit id="Simplify_property_pattern">
         <source>Simplify property pattern</source>
-        <target state="new">Simplify property pattern</target>
+        <target state="translated">Uprość wzorzec właściwości</target>
         <note />
       </trans-unit>
       <trans-unit id="Struct_contains_assignment_to_this_outside_of_constructor_Make_readonly_fields_writable">
@@ -289,7 +289,7 @@
       </trans-unit>
       <trans-unit id="Use_tuple_to_swap_values">
         <source>Use tuple to swap values</source>
-        <target state="new">Use tuple to swap values</target>
+        <target state="translated">Użyj krotki do zamiany wartości</target>
         <note />
       </trans-unit>
       <trans-unit id="Using_directives_must_be_placed_inside_of_a_namespace_declaration">
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pt-BR.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pt-BR.xlf
index 67408b2147adf..ffd17d9a54f55 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pt-BR.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pt-BR.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Property_pattern_can_be_simplified">
         <source>Property pattern can be simplified</source>
-        <target state="new">Property pattern can be simplified</target>
+        <target state="translated">O padrão da propriedade pode ser simplificado</target>
         <note />
       </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
@@ -139,7 +139,7 @@
       </trans-unit>
       <trans-unit id="Simplify_property_pattern">
         <source>Simplify property pattern</source>
-        <target state="new">Simplify property pattern</target>
+        <target state="translated">Simplificar o padrão de propriedade</target>
         <note />
       </trans-unit>
       <trans-unit id="Struct_contains_assignment_to_this_outside_of_constructor_Make_readonly_fields_writable">
@@ -289,7 +289,7 @@
       </trans-unit>
       <trans-unit id="Use_tuple_to_swap_values">
         <source>Use tuple to swap values</source>
-        <target state="new">Use tuple to swap values</target>
+        <target state="translated">Usar a tupla para trocar valores</target>
         <note />
       </trans-unit>
       <trans-unit id="Using_directives_must_be_placed_inside_of_a_namespace_declaration">
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ru.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ru.xlf
index 3e87bac5a4c3b..484acb7397977 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ru.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ru.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Property_pattern_can_be_simplified">
         <source>Property pattern can be simplified</source>
-        <target state="new">Property pattern can be simplified</target>
+        <target state="translated">Шаблон свойства можно упростить</target>
         <note />
       </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
@@ -139,7 +139,7 @@
       </trans-unit>
       <trans-unit id="Simplify_property_pattern">
         <source>Simplify property pattern</source>
-        <target state="new">Simplify property pattern</target>
+        <target state="translated">Упростить шаблон свойства</target>
         <note />
       </trans-unit>
       <trans-unit id="Struct_contains_assignment_to_this_outside_of_constructor_Make_readonly_fields_writable">
@@ -289,7 +289,7 @@
       </trans-unit>
       <trans-unit id="Use_tuple_to_swap_values">
         <source>Use tuple to swap values</source>
-        <target state="new">Use tuple to swap values</target>
+        <target state="translated">Использовать кортеж для переключения значений</target>
         <note />
       </trans-unit>
       <trans-unit id="Using_directives_must_be_placed_inside_of_a_namespace_declaration">
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.tr.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.tr.xlf
index f3a2d5a24347d..85e1699f09fdc 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.tr.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.tr.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Property_pattern_can_be_simplified">
         <source>Property pattern can be simplified</source>
-        <target state="new">Property pattern can be simplified</target>
+        <target state="translated">Özellik deseni basitleştirilebilir</target>
         <note />
       </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
@@ -139,7 +139,7 @@
       </trans-unit>
       <trans-unit id="Simplify_property_pattern">
         <source>Simplify property pattern</source>
-        <target state="new">Simplify property pattern</target>
+        <target state="translated">Özellik desenini basitleştir</target>
         <note />
       </trans-unit>
       <trans-unit id="Struct_contains_assignment_to_this_outside_of_constructor_Make_readonly_fields_writable">
@@ -289,7 +289,7 @@
       </trans-unit>
       <trans-unit id="Use_tuple_to_swap_values">
         <source>Use tuple to swap values</source>
-        <target state="new">Use tuple to swap values</target>
+        <target state="translated">Değerleri değiştirmek için demeti kullanın</target>
         <note />
       </trans-unit>
       <trans-unit id="Using_directives_must_be_placed_inside_of_a_namespace_declaration">
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hans.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hans.xlf
index 7c6167a7e02dc..db39e65cca2d9 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hans.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hans.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Property_pattern_can_be_simplified">
         <source>Property pattern can be simplified</source>
-        <target state="new">Property pattern can be simplified</target>
+        <target state="translated">可以简化属性模式</target>
         <note />
       </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
@@ -139,7 +139,7 @@
       </trans-unit>
       <trans-unit id="Simplify_property_pattern">
         <source>Simplify property pattern</source>
-        <target state="new">Simplify property pattern</target>
+        <target state="translated">简化属性模式</target>
         <note />
       </trans-unit>
       <trans-unit id="Struct_contains_assignment_to_this_outside_of_constructor_Make_readonly_fields_writable">
@@ -289,7 +289,7 @@
       </trans-unit>
       <trans-unit id="Use_tuple_to_swap_values">
         <source>Use tuple to swap values</source>
-        <target state="new">Use tuple to swap values</target>
+        <target state="translated">使用元组交换值</target>
         <note />
       </trans-unit>
       <trans-unit id="Using_directives_must_be_placed_inside_of_a_namespace_declaration">
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hant.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hant.xlf
index 25266870695f0..744d0df29855b 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hant.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hant.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Property_pattern_can_be_simplified">
         <source>Property pattern can be simplified</source>
-        <target state="new">Property pattern can be simplified</target>
+        <target state="translated">可簡化屬性模式</target>
         <note />
       </trans-unit>
       <trans-unit id="Remove_operator_preserves_semantics">
@@ -139,7 +139,7 @@
       </trans-unit>
       <trans-unit id="Simplify_property_pattern">
         <source>Simplify property pattern</source>
-        <target state="new">Simplify property pattern</target>
+        <target state="translated">簡化屬性模式</target>
         <note />
       </trans-unit>
       <trans-unit id="Struct_contains_assignment_to_this_outside_of_constructor_Make_readonly_fields_writable">
@@ -289,7 +289,7 @@
       </trans-unit>
       <trans-unit id="Use_tuple_to_swap_values">
         <source>Use tuple to swap values</source>
-        <target state="new">Use tuple to swap values</target>
+        <target state="translated">使用元組交換值</target>
         <note />
       </trans-unit>
       <trans-unit id="Using_directives_must_be_placed_inside_of_a_namespace_declaration">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
index 610c584388564..ac97305593846 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
@@ -34,7 +34,7 @@
       </trans-unit>
       <trans-unit id="ERR_AddressOfMethodGroupInExpressionTree">
         <source>'&amp;' on method groups cannot be used in expression trees</source>
-        <target state="translated">&amp; pro skupiny metod se nedá použít ve stromech výrazů.</target>
+        <target state="translated">'&amp;' pro skupiny metod se nedá použít ve stromech výrazů.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_AddressOfToNonFunctionPointer">
@@ -224,7 +224,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotBeMadeNullable">
         <source>'{0}' cannot be made nullable.</source>
-        <target state="new">'{0}' cannot be made nullable.</target>
+        <target state="translated">{0} nejde nastavit tak, aby se povolovala hodnota null.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotClone">
@@ -264,7 +264,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotUseRefInUnmanagedCallersOnly">
         <source>Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</source>
-        <target state="new">Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</target>
+        <target state="translated">V signatuře metody s atributem UnmanagedCallersOnly se nedají použít hodnoty ref, in ani out.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotUseSelfAsInterpolatedStringHandlerArgument">
@@ -464,7 +464,7 @@
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsPatternImplicitIndexer">
         <source>An expression tree may not contain a pattern System.Index or System.Range indexer access</source>
-        <target state="new">An expression tree may not contain a pattern System.Index or System.Range indexer access</target>
+        <target state="translated">Strom výrazů možná neobsahuje vzor přístupu indexeru System.Index nebo System.Range.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsRangeExpression">
@@ -629,7 +629,7 @@
       </trans-unit>
       <trans-unit id="ERR_IncorrectNullCheckSyntax">
         <source>Incorrect parameter null checking syntax. Should be '!!'.</source>
-        <target state="new">Incorrect parameter null checking syntax. Should be '!!'.</target>
+        <target state="translated">Nesprávná syntaxe kontroly hodnoty null parametru Hodnota by měla být !!.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InheritingFromRecordWithSealedToString">
@@ -694,7 +694,7 @@
       </trans-unit>
       <trans-unit id="ERR_InterpolatedStringsReferencingInstanceCannotBeInObjectInitializers">
         <source>Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</source>
-        <target state="new">Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</target>
+        <target state="translated">Převody interpolovaných obslužných rutin řetězců, které odkazují na indexovanou instanci, se nedají použít v inicializátorech členů indexeru.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InvalidFuncPointerReturnTypeModifier">
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaExplicitReturnTypeVar">
         <source>The contextual keyword 'var' cannot be used as an explicit lambda return type</source>
-        <target state="new">The contextual keyword 'var' cannot be used as an explicit lambda return type</target>
+        <target state="translated">Kontextové klíčové slovo var se nedá použít jako explicitní návratový typ lambda.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
@@ -794,7 +794,7 @@
       </trans-unit>
       <trans-unit id="ERR_MisplacedSlicePattern">
         <source>Slice patterns may only be used once and directly inside a list pattern.</source>
-        <target state="new">Slice patterns may only be used once and directly inside a list pattern.</target>
+        <target state="translated">Vzory řezů se dají použít jenom jednou a přímo uvnitř vzoru seznamu.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MissingAddressOf">
@@ -854,7 +854,7 @@
       </trans-unit>
       <trans-unit id="ERR_MustNullCheckInImplementation">
         <source>Parameter '{0}' can only have exclamation-point null checking in implementation methods.</source>
-        <target state="new">Parameter '{0}' can only have exclamation-point null checking in implementation methods.</target>
+        <target state="translated">Parametr {0} může mít v implementačních metodách pouze kontrolu hodnot null vykřičníku.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NewBoundWithUnmanaged">
@@ -864,7 +864,7 @@
       </trans-unit>
       <trans-unit id="ERR_NewlinesAreNotAllowedInsideANonVerbatimInterpolatedString">
         <source>Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</source>
-        <target state="new">Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</target>
+        <target state="translated">V jazyce C# {0} se nové řádky uvnitř neliterálního interpolovaného řetězce nepodporují. Použijte prosím verzi jazyka {1} nebo novější.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NoConvToIAsyncDispWrongAsync">
@@ -899,7 +899,7 @@
       </trans-unit>
       <trans-unit id="ERR_NonNullableValueTypeIsNullChecked">
         <source>Parameter '{0}' is a non-nullable value type and cannot be null-checked.</source>
-        <target state="new">Parameter '{0}' is a non-nullable value type and cannot be null-checked.</target>
+        <target state="translated">Parametr '{0}' je typ hodnoty, která nemůže mít hodnotu null, a nemůže mít zaškrtnutou hodnotu null.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NonPrivateAPIInRecord">
@@ -934,7 +934,7 @@
       </trans-unit>
       <trans-unit id="ERR_NullCheckingOnByRefParameter">
         <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="new">By-reference parameter '{0}' cannot be null-checked.</target>
+        <target state="translated">Parametr podle odkazu '{0}' nemůže mít hodnotu null.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
@@ -1069,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
         <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
+        <target state="translated">Konstruktor deklarovaný v „record struct“ se seznamem parametrů musí mít inicializátor „this“, který volá primární konstruktor nebo explicitně deklarovaný konstruktor.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
@@ -1194,7 +1194,7 @@
       </trans-unit>
       <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
         <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
-        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <target state="translated">Položka „struct“ s inicializátory pole musí obsahovat explicitně deklarovaný konstruktor.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
@@ -1264,12 +1264,12 @@
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForListPattern">
         <source>List patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">List patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">Vzory seznamů se nedají používat pro hodnotu typu {0}.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForSlicePattern">
         <source>Slice patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">Slice patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">Vzory řezů se nedají používat pro hodnotu typu {0}.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_WrongArityAsyncReturn">
@@ -1349,7 +1349,7 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureLengthPattern">
         <source>length pattern</source>
-        <target state="new">length pattern</target>
+        <target state="translated">vzor délky</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
@@ -1359,12 +1359,12 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureListPattern">
         <source>list pattern</source>
-        <target state="new">list pattern</target>
+        <target state="translated">vzor seznamu</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureNewLinesInInterpolations">
         <source>newlines in interpolations</source>
-        <target state="new">newlines in interpolations</target>
+        <target state="translated">nové řádky v interpolacích</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureParameterlessStructConstructors">
@@ -1409,7 +1409,7 @@
       </trans-unit>
       <trans-unit id="IDS_ParameterNullChecking">
         <source>parameter null-checking</source>
-        <target state="new">parameter null-checking</target>
+        <target state="translated">kontrola hodnoty null parametru</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_AnalyzerReferencesFramework">
@@ -1524,12 +1524,12 @@
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName">
         <source>The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">Název typu {0} obsahuje jenom malá písmena ASCII. Tyto názvy se můžou stát vyhrazenými pro daný jazyk.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName_Title">
         <source>The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">Název typu obsahuje jenom malá písmena ASCII. Tyto názvy se můžou stát vyhrazenými pro daný jazyk.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
@@ -1544,22 +1544,22 @@
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull">
         <source>Parameter '{0}' is null-checked but is null by default.</source>
-        <target state="new">Parameter '{0}' is null-checked but is null by default.</target>
+        <target state="translated">Parametr {0} má hodnotu null, ale ve výchozím nastavení je null.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull_Title">
         <source>Parameter is null-checked but is null by default.</source>
-        <target state="new">Parameter is null-checked but is null by default.</target>
+        <target state="translated">Parametr má hodnotu null, ale ve výchozím nastavení je null.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType">
         <source>Nullable type '{0}' is null-checked and will throw if null.</source>
-        <target state="new">Nullable type '{0}' is null-checked and will throw if null.</target>
+        <target state="translated">Typ {0} s možnou hodnotou null je zaškrtnut hodnotou null a vyvolá se při hodnotě null.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType_Title">
         <source>Nullable type is null-checked and will throw if null.</source>
-        <target state="new">Nullable type is null-checked and will throw if null.</target>
+        <target state="translated">Typ s možnou hodnotou null je zaškrtnut hodnotou null a vyvolá se při hodnotě null.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1574,7 +1574,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
+        <target state="translated">Parametr {0} se v seznamu parametrů nachází za {1}, ale používá se jako argument pro převody obslužných rutin interpolovaných řetězců. To vyžaduje, aby volající změnil pořadí parametrů s pojmenovanými argumenty na lokalitě volání. Doporučujeme, abyste parametr obslužné rutiny interpolovaného řetězce vložili za všechny ostatní zahrnuté argumenty.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
@@ -3613,7 +3613,7 @@
       </trans-unit>
       <trans-unit id="XML_LessThanInAttributeValue">
         <source>The character '&lt;' cannot be used in an attribute value.</source>
-        <target state="translated">Znak &lt; se nedá použít v hodnotě atributu.</target>
+        <target state="translated">Znak '&lt;' se nedá použít v hodnotě atributu.</target>
         <note />
       </trans-unit>
       <trans-unit id="XML_MissingEqualsAttribute">
@@ -3668,7 +3668,7 @@
       </trans-unit>
       <trans-unit id="XML_CDataEndTagNotAllowed">
         <source>The literal string ']]&gt;' is not allowed in element content.</source>
-        <target state="translated">V obsahu elementu není povolený řetězec literálu ]]&gt;.</target>
+        <target state="translated">V obsahu elementu není povolený řetězec literálu ']]&gt;'.</target>
         <note />
       </trans-unit>
       <trans-unit id="XML_DuplicateAttribute">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
index 267c974849c67..d59ee5981246f 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
@@ -224,7 +224,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotBeMadeNullable">
         <source>'{0}' cannot be made nullable.</source>
-        <target state="new">'{0}' cannot be made nullable.</target>
+        <target state="translated">"{0}" kann keine NULL-Werte zulassen.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotClone">
@@ -264,7 +264,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotUseRefInUnmanagedCallersOnly">
         <source>Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</source>
-        <target state="new">Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</target>
+        <target state="translated">„ref“, „in“ und „out“ können nicht in der Signatur einer Methode verwendet werden, die mit „UnmanagedCallersOnly“ attributiert ist.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotUseSelfAsInterpolatedStringHandlerArgument">
@@ -464,7 +464,7 @@
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsPatternImplicitIndexer">
         <source>An expression tree may not contain a pattern System.Index or System.Range indexer access</source>
-        <target state="new">An expression tree may not contain a pattern System.Index or System.Range indexer access</target>
+        <target state="translated">Eine Ausdrucksbaumstruktur darf keinen System.Index- oder System.Range-Musterindexerzugriff enthalten.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsRangeExpression">
@@ -629,7 +629,7 @@
       </trans-unit>
       <trans-unit id="ERR_IncorrectNullCheckSyntax">
         <source>Incorrect parameter null checking syntax. Should be '!!'.</source>
-        <target state="new">Incorrect parameter null checking syntax. Should be '!!'.</target>
+        <target state="translated">Falsche Syntax für die NULL-Überprüfung des Parameters. Muss „!!“ sein.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InheritingFromRecordWithSealedToString">
@@ -694,7 +694,7 @@
       </trans-unit>
       <trans-unit id="ERR_InterpolatedStringsReferencingInstanceCannotBeInObjectInitializers">
         <source>Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</source>
-        <target state="new">Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</target>
+        <target state="translated">Handler-Konvertierungen interpolierter Zeichenfolgen die auf die Instanz verweisen, die gerade indiziert wird, können nicht in Indexer-Member-Initialisierern verwendet werden.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InvalidFuncPointerReturnTypeModifier">
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaExplicitReturnTypeVar">
         <source>The contextual keyword 'var' cannot be used as an explicit lambda return type</source>
-        <target state="new">The contextual keyword 'var' cannot be used as an explicit lambda return type</target>
+        <target state="translated">Das kontextbezogene Schlüsselwort „var“ kann nicht als expliziter Lambdarückgabetyp verwendet werden.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
@@ -794,7 +794,7 @@
       </trans-unit>
       <trans-unit id="ERR_MisplacedSlicePattern">
         <source>Slice patterns may only be used once and directly inside a list pattern.</source>
-        <target state="new">Slice patterns may only be used once and directly inside a list pattern.</target>
+        <target state="translated">Segmentmuster dürfen nur einmal und direkt innerhalb eines Listenmusters verwendet werden.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MissingAddressOf">
@@ -854,7 +854,7 @@
       </trans-unit>
       <trans-unit id="ERR_MustNullCheckInImplementation">
         <source>Parameter '{0}' can only have exclamation-point null checking in implementation methods.</source>
-        <target state="new">Parameter '{0}' can only have exclamation-point null checking in implementation methods.</target>
+        <target state="translated">Der Parameter „{0}“ kann nur eine Ausrufezeichen-NULL-Überprüfung in den Implementierungsmethoden aufweisen.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NewBoundWithUnmanaged">
@@ -864,7 +864,7 @@
       </trans-unit>
       <trans-unit id="ERR_NewlinesAreNotAllowedInsideANonVerbatimInterpolatedString">
         <source>Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</source>
-        <target state="new">Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</target>
+        <target state="translated">Zeilenumbrüche innerhalb einer nicht ausführlichen interpolierten Zeichenfolge werden in C#-{0} nicht unterstützt. Verwenden Sie die Sprachversion {1} oder höher.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NoConvToIAsyncDispWrongAsync">
@@ -899,7 +899,7 @@
       </trans-unit>
       <trans-unit id="ERR_NonNullableValueTypeIsNullChecked">
         <source>Parameter '{0}' is a non-nullable value type and cannot be null-checked.</source>
-        <target state="new">Parameter '{0}' is a non-nullable value type and cannot be null-checked.</target>
+        <target state="translated">Der Parameter „{0}“ ist ein Non-Nullable-Werttyp und kann nicht auf NULL-Werte überprüft werden.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NonPrivateAPIInRecord">
@@ -934,7 +934,7 @@
       </trans-unit>
       <trans-unit id="ERR_NullCheckingOnByRefParameter">
         <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="new">By-reference parameter '{0}' cannot be null-checked.</target>
+        <target state="translated">Der Verweisparameter „{0}“ kann nicht auf NULL-Werte überprüft werden.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
@@ -1069,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
         <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
+        <target state="translated">Ein in „record struct“ mit Parameterliste deklarierter Konstruktor muss über einen „this“-Initialisierer verfügen, der den primären Konstruktor oder einen explizit deklarierten Konstruktor aufruft.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
@@ -1264,12 +1264,12 @@
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForListPattern">
         <source>List patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">List patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">Listenmuster dürfen nicht für einen Wert vom Typ „{0}“ verwendet werden.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForSlicePattern">
         <source>Slice patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">Slice patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">Segmentmuster dürfen nicht für einen Wert vom Typ „{0}“ verwendet werden.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_WrongArityAsyncReturn">
@@ -1349,7 +1349,7 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureLengthPattern">
         <source>length pattern</source>
-        <target state="new">length pattern</target>
+        <target state="translated">Längenmuster</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
@@ -1359,12 +1359,12 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureListPattern">
         <source>list pattern</source>
-        <target state="new">list pattern</target>
+        <target state="translated">Listenmuster</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureNewLinesInInterpolations">
         <source>newlines in interpolations</source>
-        <target state="new">newlines in interpolations</target>
+        <target state="translated">Zeilenumbrüche in Interpolationen</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureParameterlessStructConstructors">
@@ -1409,7 +1409,7 @@
       </trans-unit>
       <trans-unit id="IDS_ParameterNullChecking">
         <source>parameter null-checking</source>
-        <target state="new">parameter null-checking</target>
+        <target state="translated">NULL-Überprüfung des Parameters</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_AnalyzerReferencesFramework">
@@ -1524,12 +1524,12 @@
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName">
         <source>The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">Der Typname „{0}“ enthält nur ASCII-Zeichen in Kleinbuchstaben. Solche Namen können möglicherweise für die Sprache reserviert werden.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName_Title">
         <source>The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">Der Typname enthält nur ASCII-Zeichen in Kleinbuchstaben. Solche Namen können möglicherweise für die Sprache reserviert werden.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
@@ -1544,22 +1544,22 @@
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull">
         <source>Parameter '{0}' is null-checked but is null by default.</source>
-        <target state="new">Parameter '{0}' is null-checked but is null by default.</target>
+        <target state="translated">Der Parameter „{0}“ wurde auf NULL-Werte überprüft, ist aber standardmäßig NULL.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull_Title">
         <source>Parameter is null-checked but is null by default.</source>
-        <target state="new">Parameter is null-checked but is null by default.</target>
+        <target state="translated">Der Parameter wurde auf NULL-Werte überprüft, ist aber standardmäßig NULL.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType">
         <source>Nullable type '{0}' is null-checked and will throw if null.</source>
-        <target state="new">Nullable type '{0}' is null-checked and will throw if null.</target>
+        <target state="translated">Der Nullable-Typ „{0}“ wurde auf NULL-Werte überprüft und wird bei NULL ausgelöst.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType_Title">
         <source>Nullable type is null-checked and will throw if null.</source>
-        <target state="new">Nullable type is null-checked and will throw if null.</target>
+        <target state="translated">Der Nullable-Typ wurde auf NULL-Werte überprüft und wird bei NULL ausgelöst.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1574,7 +1574,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
+        <target state="translated">Der Parameter „{0}“ tritt nach „{1}“ in der Parameterliste auf, wird jedoch als Argument für die Handler-Konvertierungen einer interpolierten Zeichenfolge verwendet. Dies erfordert, dass der Aufrufer Parameter mit benannten Argumenten an der Aufrufsite neu anordnen kann. Erwägen Sie, den Handler-Parameter einer interpolierten Zeichenfolge hinter alle beteiligten Argumenten zu platzieren.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
index 92a367f32f5ae..b8e28c18aa352 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
@@ -224,7 +224,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotBeMadeNullable">
         <source>'{0}' cannot be made nullable.</source>
-        <target state="new">'{0}' cannot be made nullable.</target>
+        <target state="translated">'No se puede hacer que '{0}' acepte valores NULL.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotClone">
@@ -264,7 +264,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotUseRefInUnmanagedCallersOnly">
         <source>Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</source>
-        <target state="new">Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</target>
+        <target state="translated">No se puede usar "ref", "in" o "out" en la firma de un método atribuido con "UnmanagedCallersOnly".</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotUseSelfAsInterpolatedStringHandlerArgument">
@@ -464,7 +464,7 @@
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsPatternImplicitIndexer">
         <source>An expression tree may not contain a pattern System.Index or System.Range indexer access</source>
-        <target state="new">An expression tree may not contain a pattern System.Index or System.Range indexer access</target>
+        <target state="translated">Un árbol de expresión no puede contener un patrón System.Index o un acceso a indizador System.Range.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsRangeExpression">
@@ -629,7 +629,7 @@
       </trans-unit>
       <trans-unit id="ERR_IncorrectNullCheckSyntax">
         <source>Incorrect parameter null checking syntax. Should be '!!'.</source>
-        <target state="new">Incorrect parameter null checking syntax. Should be '!!'.</target>
+        <target state="translated">Sintaxis de comprobación null de parámetro incorrecto. Debe ser '!!'.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InheritingFromRecordWithSealedToString">
@@ -694,7 +694,7 @@
       </trans-unit>
       <trans-unit id="ERR_InterpolatedStringsReferencingInstanceCannotBeInObjectInitializers">
         <source>Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</source>
-        <target state="new">Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</target>
+        <target state="translated">Las conversiones de controlador de cadenas interpoladas que hacen referencia a la instancia que se está indizando no se puede usar en inicializadores de miembros de indizador.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InvalidFuncPointerReturnTypeModifier">
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaExplicitReturnTypeVar">
         <source>The contextual keyword 'var' cannot be used as an explicit lambda return type</source>
-        <target state="new">The contextual keyword 'var' cannot be used as an explicit lambda return type</target>
+        <target state="translated">La palabra clave contextual "var" no se puede utilizar como un tipo de retorno lambda explícito</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
@@ -794,7 +794,7 @@
       </trans-unit>
       <trans-unit id="ERR_MisplacedSlicePattern">
         <source>Slice patterns may only be used once and directly inside a list pattern.</source>
-        <target state="new">Slice patterns may only be used once and directly inside a list pattern.</target>
+        <target state="translated">Los patrones de segmento solo se pueden utilizar una vez directamente dentro de un patrón de lista.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MissingAddressOf">
@@ -854,7 +854,7 @@
       </trans-unit>
       <trans-unit id="ERR_MustNullCheckInImplementation">
         <source>Parameter '{0}' can only have exclamation-point null checking in implementation methods.</source>
-        <target state="new">Parameter '{0}' can only have exclamation-point null checking in implementation methods.</target>
+        <target state="translated">El parámetro '{0}' solo puede tener una comprobación nula de signo de exclamación en los métodos de implementación.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NewBoundWithUnmanaged">
@@ -864,7 +864,7 @@
       </trans-unit>
       <trans-unit id="ERR_NewlinesAreNotAllowedInsideANonVerbatimInterpolatedString">
         <source>Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</source>
-        <target state="new">Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</target>
+        <target state="translated">No se admiten líneas nuevas dentro de una cadena interpolada no textual en C# {0}. Utilice la versión de idioma {1} o superior.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NoConvToIAsyncDispWrongAsync">
@@ -899,7 +899,7 @@
       </trans-unit>
       <trans-unit id="ERR_NonNullableValueTypeIsNullChecked">
         <source>Parameter '{0}' is a non-nullable value type and cannot be null-checked.</source>
-        <target state="new">Parameter '{0}' is a non-nullable value type and cannot be null-checked.</target>
+        <target state="translated">El parámetro '{0}' es un tipo de valor que no acepta valores NULL y no se puede comprobar con valores NULL.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NonPrivateAPIInRecord">
@@ -934,7 +934,7 @@
       </trans-unit>
       <trans-unit id="ERR_NullCheckingOnByRefParameter">
         <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="new">By-reference parameter '{0}' cannot be null-checked.</target>
+        <target state="translated">El parámetro por referencia '{0}' no se puede comprobar con valores NULL.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
@@ -1069,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
         <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
+        <target state="translated">Un constructor declarado en un 'record struct' con lista de parámetros debe tener un inicializador 'this' que llame al constructor principal o a un constructor declarado explícitamente.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
@@ -1264,12 +1264,12 @@
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForListPattern">
         <source>List patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">List patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">No se pueden utilizar patrones de lista para un valor de tipo "{0}".</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForSlicePattern">
         <source>Slice patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">Slice patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">No se pueden utilizar patrones de segmento para el valor de tipo "{0}".</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_WrongArityAsyncReturn">
@@ -1349,7 +1349,7 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureLengthPattern">
         <source>length pattern</source>
-        <target state="new">length pattern</target>
+        <target state="translated">Patrón de longitud</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
@@ -1359,12 +1359,12 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureListPattern">
         <source>list pattern</source>
-        <target state="new">list pattern</target>
+        <target state="translated">patrón de lista</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureNewLinesInInterpolations">
         <source>newlines in interpolations</source>
-        <target state="new">newlines in interpolations</target>
+        <target state="translated">Nuevas líneas en interpolaciones</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureParameterlessStructConstructors">
@@ -1409,7 +1409,7 @@
       </trans-unit>
       <trans-unit id="IDS_ParameterNullChecking">
         <source>parameter null-checking</source>
-        <target state="new">parameter null-checking</target>
+        <target state="translated">comprobación null de parámetro</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_AnalyzerReferencesFramework">
@@ -1524,12 +1524,12 @@
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName">
         <source>The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">El nombre de tipo '{0}' solo contiene caracteres ASCII en minúsculas. Estos nombres pueden quedar reservados para el idioma.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName_Title">
         <source>The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">El nombre de tipo solo contiene caracteres ASCII en minúsculas. Estos nombres pueden reservarse para el idioma.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
@@ -1544,22 +1544,22 @@
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull">
         <source>Parameter '{0}' is null-checked but is null by default.</source>
-        <target state="new">Parameter '{0}' is null-checked but is null by default.</target>
+        <target state="translated">El parámetro '{0}' está marcado como null, pero es NULL de forma predeterminada.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull_Title">
         <source>Parameter is null-checked but is null by default.</source>
-        <target state="new">Parameter is null-checked but is null by default.</target>
+        <target state="translated">El parámetro está comprobado con valores NULL, pero es NULL de forma predeterminada.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType">
         <source>Nullable type '{0}' is null-checked and will throw if null.</source>
-        <target state="new">Nullable type '{0}' is null-checked and will throw if null.</target>
+        <target state="translated">El tipo que acepta valores NULL '{0}' está activado como NULL y se iniciará si es NULL.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType_Title">
         <source>Nullable type is null-checked and will throw if null.</source>
-        <target state="new">Nullable type is null-checked and will throw if null.</target>
+        <target state="translated">El tipo que acepta valores NULL está activado con valor NULL y se iniciará si es null.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1574,7 +1574,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
+        <target state="translated">El parámetro "{0}" se produce después de "{1}" en la lista de parámetros, pero se usa como argumento para conversiones de controlador de cadena interpolada. Esto requerirá que el autor de llamada reordene los parámetros con argumentos con nombre en el sitio de llamada. Considere la posibilidad de colocar el parámetro de controlador de cadena interpolada después de todos los argumentos implicados.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
index 7dd4843964bfa..e301593dd7f24 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
@@ -224,7 +224,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotBeMadeNullable">
         <source>'{0}' cannot be made nullable.</source>
-        <target state="new">'{0}' cannot be made nullable.</target>
+        <target state="translated">'{0}' ne peut pas être null.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotClone">
@@ -264,7 +264,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotUseRefInUnmanagedCallersOnly">
         <source>Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</source>
-        <target state="new">Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</target>
+        <target state="translated">Impossible d'utiliser 'ref', 'in' ou 'out' dans la signature d'une méthode attribuée avec 'UnmanagedCallersOnly'.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotUseSelfAsInterpolatedStringHandlerArgument">
@@ -464,7 +464,7 @@
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsPatternImplicitIndexer">
         <source>An expression tree may not contain a pattern System.Index or System.Range indexer access</source>
-        <target state="new">An expression tree may not contain a pattern System.Index or System.Range indexer access</target>
+        <target state="translated">Une arborescence de l'expression ne peut pas contenir de modèle d'accès à l'indexeur System.Index ou System.Range</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsRangeExpression">
@@ -629,7 +629,7 @@
       </trans-unit>
       <trans-unit id="ERR_IncorrectNullCheckSyntax">
         <source>Incorrect parameter null checking syntax. Should be '!!'.</source>
-        <target state="new">Incorrect parameter null checking syntax. Should be '!!'.</target>
+        <target state="translated">Syntaxe de vérification null du paramètre incorrect. Doit être « !! ».</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InheritingFromRecordWithSealedToString">
@@ -694,7 +694,7 @@
       </trans-unit>
       <trans-unit id="ERR_InterpolatedStringsReferencingInstanceCannotBeInObjectInitializers">
         <source>Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</source>
-        <target state="new">Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</target>
+        <target state="translated">Les conversions de gestionnaires de chaînes interpolées qui font référence à l'instance en cours d'indexation ne peuvent pas être utilisées dans les initialiseurs de membres d'indexeur.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InvalidFuncPointerReturnTypeModifier">
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaExplicitReturnTypeVar">
         <source>The contextual keyword 'var' cannot be used as an explicit lambda return type</source>
-        <target state="new">The contextual keyword 'var' cannot be used as an explicit lambda return type</target>
+        <target state="translated">Le mot clé contextuel 'var' ne peut pas être utilisé comme type de retour lambda explicite</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
@@ -794,7 +794,7 @@
       </trans-unit>
       <trans-unit id="ERR_MisplacedSlicePattern">
         <source>Slice patterns may only be used once and directly inside a list pattern.</source>
-        <target state="new">Slice patterns may only be used once and directly inside a list pattern.</target>
+        <target state="translated">Les modèles de tranche ne peuvent être utilisés qu'une seule fois et directement à l'intérieur d'un modèle de liste.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MissingAddressOf">
@@ -854,7 +854,7 @@
       </trans-unit>
       <trans-unit id="ERR_MustNullCheckInImplementation">
         <source>Parameter '{0}' can only have exclamation-point null checking in implementation methods.</source>
-        <target state="new">Parameter '{0}' can only have exclamation-point null checking in implementation methods.</target>
+        <target state="translated">Le paramètre '{0}' peut uniquement avoir une vérification null de point d’exclamation dans les méthodes d’implémentation.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NewBoundWithUnmanaged">
@@ -864,7 +864,7 @@
       </trans-unit>
       <trans-unit id="ERR_NewlinesAreNotAllowedInsideANonVerbatimInterpolatedString">
         <source>Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</source>
-        <target state="new">Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</target>
+        <target state="translated">Les nouvelles lignes à l'intérieur d'une chaîne interpolée non textuelle ne sont pas prises en charge en C# {0}. Veuillez utiliser la version linguistique {1} ou supérieure.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NoConvToIAsyncDispWrongAsync">
@@ -899,7 +899,7 @@
       </trans-unit>
       <trans-unit id="ERR_NonNullableValueTypeIsNullChecked">
         <source>Parameter '{0}' is a non-nullable value type and cannot be null-checked.</source>
-        <target state="new">Parameter '{0}' is a non-nullable value type and cannot be null-checked.</target>
+        <target state="translated">Le paramètre '{0}' est un type valeur non nullable et ne peut pas faire l’objet d’une vérification de valeur Null.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NonPrivateAPIInRecord">
@@ -934,7 +934,7 @@
       </trans-unit>
       <trans-unit id="ERR_NullCheckingOnByRefParameter">
         <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="new">By-reference parameter '{0}' cannot be null-checked.</target>
+        <target state="translated">Le paramètre par référence '{0}' ne peut pas faire l’objet d’une vérification de valeur Null.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
@@ -1069,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
         <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
+        <target state="translated">Un constructeur déclaré dans un 'record struct' avec une liste de paramètres doit avoir un initialiseur 'this' qui appelle le constructeur principal ou un constructeur explicitement déclaré.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
@@ -1264,12 +1264,12 @@
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForListPattern">
         <source>List patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">List patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">Les modèles de liste ne peuvent pas être utilisés pour une valeur de type '{0}'.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForSlicePattern">
         <source>Slice patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">Slice patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">Les modèles de tranche ne peuvent pas être utilisés pour une valeur de type '{0}'.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_WrongArityAsyncReturn">
@@ -1349,7 +1349,7 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureLengthPattern">
         <source>length pattern</source>
-        <target state="new">length pattern</target>
+        <target state="translated">modèle de longueur</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
@@ -1359,12 +1359,12 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureListPattern">
         <source>list pattern</source>
-        <target state="new">list pattern</target>
+        <target state="translated">modèle de liste</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureNewLinesInInterpolations">
         <source>newlines in interpolations</source>
-        <target state="new">newlines in interpolations</target>
+        <target state="translated">sauts de ligne dans les interpolations</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureParameterlessStructConstructors">
@@ -1409,7 +1409,7 @@
       </trans-unit>
       <trans-unit id="IDS_ParameterNullChecking">
         <source>parameter null-checking</source>
-        <target state="new">parameter null-checking</target>
+        <target state="translated">vérification de la valeur null du paramètre</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_AnalyzerReferencesFramework">
@@ -1524,12 +1524,12 @@
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName">
         <source>The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">Le nom de type '{0}' contient uniquement des caractères ascii en minuscules. De tels noms peuvent devenir réservés pour la langue.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName_Title">
         <source>The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">Le nom de type contient uniquement des caractères ascii en minuscules. De tels noms peuvent devenir réservés pour la langue.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
@@ -1544,22 +1544,22 @@
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull">
         <source>Parameter '{0}' is null-checked but is null by default.</source>
-        <target state="new">Parameter '{0}' is null-checked but is null by default.</target>
+        <target state="translated">Le paramètre '{0}' a la valeur Null, mais est null par défaut.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull_Title">
         <source>Parameter is null-checked but is null by default.</source>
-        <target state="new">Parameter is null-checked but is null by default.</target>
+        <target state="translated">Le paramètre est contrôlé comme nul mais est nul par défaut.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType">
         <source>Nullable type '{0}' is null-checked and will throw if null.</source>
-        <target state="new">Nullable type '{0}' is null-checked and will throw if null.</target>
+        <target state="translated">Le type nullable '{0}' a la valeur Null et lève la valeur null.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType_Title">
         <source>Nullable type is null-checked and will throw if null.</source>
-        <target state="new">Nullable type is null-checked and will throw if null.</target>
+        <target state="translated">Le type Nullable est activé pour null et lèvera si null.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1574,7 +1574,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
+        <target state="translated">Le paramètre '{0}' apparaît après '{1}' dans la liste des paramètres, mais est utilisé comme argument pour les conversions de gestionnaires de chaînes interpolées. Cela nécessitera que l'appelant réorganise les paramètres avec des arguments nommés sur le site d'appel. Envisagez de placer le paramètre de gestionnaire de chaîne interpolé après tous les arguments impliqués.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
index 7ad6cc95156a6..08c3886f52c80 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
@@ -224,7 +224,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotBeMadeNullable">
         <source>'{0}' cannot be made nullable.</source>
-        <target state="new">'{0}' cannot be made nullable.</target>
+        <target state="translated">'{0}' non può essere reso nullable.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotClone">
@@ -264,7 +264,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotUseRefInUnmanagedCallersOnly">
         <source>Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</source>
-        <target state="new">Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</target>
+        <target state="translated">Non è possibile usare 'ref', 'in' o 'out' nella firma di un metodo con attributo 'UnmanagedCallersOnly'.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotUseSelfAsInterpolatedStringHandlerArgument">
@@ -464,7 +464,7 @@
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsPatternImplicitIndexer">
         <source>An expression tree may not contain a pattern System.Index or System.Range indexer access</source>
-        <target state="new">An expression tree may not contain a pattern System.Index or System.Range indexer access</target>
+        <target state="translated">Un albero delle espressioni non può contenere un accesso a indicizzatore System.Index o System.Range di criterio</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsRangeExpression">
@@ -629,7 +629,7 @@
       </trans-unit>
       <trans-unit id="ERR_IncorrectNullCheckSyntax">
         <source>Incorrect parameter null checking syntax. Should be '!!'.</source>
-        <target state="new">Incorrect parameter null checking syntax. Should be '!!'.</target>
+        <target state="translated">Sintassi di controllo Null del parametro non corretta. Deve essere '!!'.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InheritingFromRecordWithSealedToString">
@@ -694,7 +694,7 @@
       </trans-unit>
       <trans-unit id="ERR_InterpolatedStringsReferencingInstanceCannotBeInObjectInitializers">
         <source>Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</source>
-        <target state="new">Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</target>
+        <target state="translated">Le conversioni di gestori di stringhe interpolate che fanno riferimento all'istanza indicizzata non possono essere utilizzate negli inizializzatori di membri dell'indicizzatore.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InvalidFuncPointerReturnTypeModifier">
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaExplicitReturnTypeVar">
         <source>The contextual keyword 'var' cannot be used as an explicit lambda return type</source>
-        <target state="new">The contextual keyword 'var' cannot be used as an explicit lambda return type</target>
+        <target state="translated">Non è possibile usare la parola chiave contestuale 'var' come tipo restituito dell’espressione lambda</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
@@ -794,7 +794,7 @@
       </trans-unit>
       <trans-unit id="ERR_MisplacedSlicePattern">
         <source>Slice patterns may only be used once and directly inside a list pattern.</source>
-        <target state="new">Slice patterns may only be used once and directly inside a list pattern.</target>
+        <target state="translated">I modelli di sezione possono essere usati solo una volta e direttamente all'interno di un modello di elenco.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MissingAddressOf">
@@ -854,7 +854,7 @@
       </trans-unit>
       <trans-unit id="ERR_MustNullCheckInImplementation">
         <source>Parameter '{0}' can only have exclamation-point null checking in implementation methods.</source>
-        <target state="new">Parameter '{0}' can only have exclamation-point null checking in implementation methods.</target>
+        <target state="translated">Il parametro '{0}' può avere solo un controllo Null punto esclamativo nei metodi di implementazione.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NewBoundWithUnmanaged">
@@ -864,7 +864,7 @@
       </trans-unit>
       <trans-unit id="ERR_NewlinesAreNotAllowedInsideANonVerbatimInterpolatedString">
         <source>Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</source>
-        <target state="new">Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</target>
+        <target state="translated">Nuove linee all'interno di una stringa interpolata non verbatim non sono supportate in C# {0}. Usare la versione del linguaggio {1} o le versioni successive.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NoConvToIAsyncDispWrongAsync">
@@ -899,7 +899,7 @@
       </trans-unit>
       <trans-unit id="ERR_NonNullableValueTypeIsNullChecked">
         <source>Parameter '{0}' is a non-nullable value type and cannot be null-checked.</source>
-        <target state="new">Parameter '{0}' is a non-nullable value type and cannot be null-checked.</target>
+        <target state="translated">Il parametro '{0}' è un tipo di valore che non ammette i valori Null e non può essere controllato Null.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NonPrivateAPIInRecord">
@@ -934,7 +934,7 @@
       </trans-unit>
       <trans-unit id="ERR_NullCheckingOnByRefParameter">
         <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="new">By-reference parameter '{0}' cannot be null-checked.</target>
+        <target state="translated">Il parametro '{0}' per riferimento non può essere controllato Null.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
@@ -1069,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
         <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
+        <target state="translated">Un costruttore dichiarato in uno “struct di record” con elenco di parametri deve avere un inizializzatore “this” che chiama il costruttore primario o un costruttore dichiarato in modo esplicito.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
@@ -1264,12 +1264,12 @@
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForListPattern">
         <source>List patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">List patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">Non è possibile usare i modelli di elenco per un valore di tipo '{0}'.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForSlicePattern">
         <source>Slice patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">Slice patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">Non è possibile usare Seziona modelli per un valore di tipo '{0}'.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_WrongArityAsyncReturn">
@@ -1349,7 +1349,7 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureLengthPattern">
         <source>length pattern</source>
-        <target state="new">length pattern</target>
+        <target state="translated">modello di lunghezza</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
@@ -1359,12 +1359,12 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureListPattern">
         <source>list pattern</source>
-        <target state="new">list pattern</target>
+        <target state="translated">modello di elenco</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureNewLinesInInterpolations">
         <source>newlines in interpolations</source>
-        <target state="new">newlines in interpolations</target>
+        <target state="translated">nuove linee nelle interpolazioni</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureParameterlessStructConstructors">
@@ -1409,7 +1409,7 @@
       </trans-unit>
       <trans-unit id="IDS_ParameterNullChecking">
         <source>parameter null-checking</source>
-        <target state="new">parameter null-checking</target>
+        <target state="translated">controllo Null parametro</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_AnalyzerReferencesFramework">
@@ -1524,12 +1524,12 @@
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName">
         <source>The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">Il nome del tipo '{0}' contiene solo caratteri ascii minuscoli. Tali nomi possono diventare riservati per la lingua.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName_Title">
         <source>The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">Il nome del tipo contiene solo caratteri ascii minuscoli. Tali nomi possono diventare riservati per la lingua.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
@@ -1544,22 +1544,22 @@
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull">
         <source>Parameter '{0}' is null-checked but is null by default.</source>
-        <target state="new">Parameter '{0}' is null-checked but is null by default.</target>
+        <target state="translated">Il parametro '{0}' è controllato Null ma è Null per impostazione predefinita.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull_Title">
         <source>Parameter is null-checked but is null by default.</source>
-        <target state="new">Parameter is null-checked but is null by default.</target>
+        <target state="translated">Il parametro è controllato Null ma è Null per impostazione predefinita.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType">
         <source>Nullable type '{0}' is null-checked and will throw if null.</source>
-        <target state="new">Nullable type '{0}' is null-checked and will throw if null.</target>
+        <target state="translated">Il tipo nullable '{0}' è controllato Null e genererà un'eccezione se Null.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType_Title">
         <source>Nullable type is null-checked and will throw if null.</source>
-        <target state="new">Nullable type is null-checked and will throw if null.</target>
+        <target state="translated">Il tipo nullable è controllato Null e verrà generato se Null.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1574,7 +1574,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
+        <target state="translated">Il parametro '{0}' è indicato dopo '{1}' nell'elenco di parametri, ma viene usato come argomento per le conversioni del gestore di stringhe interpolate. Al chiamante verrà richiesto di riordinare i parametri con argomenti denominati nel sito di chiamata. Provare a inserire il parametro del gestore di stringhe interpolate dopo tutti gli argomenti interessati.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
@@ -2324,7 +2324,7 @@
       </trans-unit>
       <trans-unit id="IDS_NULL">
         <source>&lt;null&gt;</source>
-        <target state="translated">&lt;Null&gt;</target>
+        <target state="translated">&lt;null&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_OverrideWithConstraints">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
index 3d1d8414c7213..5b39839ae939e 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
@@ -224,7 +224,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotBeMadeNullable">
         <source>'{0}' cannot be made nullable.</source>
-        <target state="new">'{0}' cannot be made nullable.</target>
+        <target state="translated">'{0}' は null 許容にすることはできません。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotClone">
@@ -264,7 +264,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotUseRefInUnmanagedCallersOnly">
         <source>Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</source>
-        <target state="new">Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</target>
+        <target state="translated">"UnmanagedCallersOnly" の属性が設定されたメソッドのシグネチャでは、"ref"、"in"、または "out" を使用できません。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotUseSelfAsInterpolatedStringHandlerArgument">
@@ -464,7 +464,7 @@
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsPatternImplicitIndexer">
         <source>An expression tree may not contain a pattern System.Index or System.Range indexer access</source>
-        <target state="new">An expression tree may not contain a pattern System.Index or System.Range indexer access</target>
+        <target state="translated">式ツリーに、System.Index または System.Range インデクサー アクセスのパターンを含めることはできません</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsRangeExpression">
@@ -629,7 +629,7 @@
       </trans-unit>
       <trans-unit id="ERR_IncorrectNullCheckSyntax">
         <source>Incorrect parameter null checking syntax. Should be '!!'.</source>
-        <target state="new">Incorrect parameter null checking syntax. Should be '!!'.</target>
+        <target state="translated">パラメーターの null チェック構文が正しくありません。"!!" にする必要があります。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InheritingFromRecordWithSealedToString">
@@ -694,7 +694,7 @@
       </trans-unit>
       <trans-unit id="ERR_InterpolatedStringsReferencingInstanceCannotBeInObjectInitializers">
         <source>Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</source>
-        <target state="new">Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</target>
+        <target state="translated">インデックス付けされているインスタンスを参照する補間された文字列ハンドラーの変換は、インデクサー メンバー初期化子では使用できません。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InvalidFuncPointerReturnTypeModifier">
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaExplicitReturnTypeVar">
         <source>The contextual keyword 'var' cannot be used as an explicit lambda return type</source>
-        <target state="new">The contextual keyword 'var' cannot be used as an explicit lambda return type</target>
+        <target state="translated">コンテキスト キーワード "var" を明示的なラムダ戻り値の型として使用することはできません</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
@@ -794,7 +794,7 @@
       </trans-unit>
       <trans-unit id="ERR_MisplacedSlicePattern">
         <source>Slice patterns may only be used once and directly inside a list pattern.</source>
-        <target state="new">Slice patterns may only be used once and directly inside a list pattern.</target>
+        <target state="translated">スライス パターンは、1 回限り、リスト パターン内で直接使用される可能性があります。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MissingAddressOf">
@@ -854,7 +854,7 @@
       </trans-unit>
       <trans-unit id="ERR_MustNullCheckInImplementation">
         <source>Parameter '{0}' can only have exclamation-point null checking in implementation methods.</source>
-        <target state="new">Parameter '{0}' can only have exclamation-point null checking in implementation methods.</target>
+        <target state="translated">パラメーター '{0}' には、実装メソッドで感嘆符 null チェックのみを指定できます。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NewBoundWithUnmanaged">
@@ -864,7 +864,7 @@
       </trans-unit>
       <trans-unit id="ERR_NewlinesAreNotAllowedInsideANonVerbatimInterpolatedString">
         <source>Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</source>
-        <target state="new">Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</target>
+        <target state="translated">非逐語的な補間された文字列内の改行は、C# {0} ではサポートされていません。{1} またはそれ以上の言語バージョンを使用してください。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NoConvToIAsyncDispWrongAsync">
@@ -899,7 +899,7 @@
       </trans-unit>
       <trans-unit id="ERR_NonNullableValueTypeIsNullChecked">
         <source>Parameter '{0}' is a non-nullable value type and cannot be null-checked.</source>
-        <target state="new">Parameter '{0}' is a non-nullable value type and cannot be null-checked.</target>
+        <target state="translated">パラメーター '{0}' は null 非許容の値の型であるため、null チェックできません。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NonPrivateAPIInRecord">
@@ -934,7 +934,7 @@
       </trans-unit>
       <trans-unit id="ERR_NullCheckingOnByRefParameter">
         <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="new">By-reference parameter '{0}' cannot be null-checked.</target>
+        <target state="translated">参照渡しパラメーター '{0}' を null チェックすることはできません。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
@@ -1069,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
         <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
+        <target state="translated">パラメーター リストを含む "record struct" で宣言されたコンストラクターには、プライマリ コンストラクターまたは明示的に宣言されたコンストラクターを呼び出す "this" 初期化子が必要です。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
@@ -1194,7 +1194,7 @@
       </trans-unit>
       <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
         <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
-        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <target state="translated">フィールド初期化子を持つ 'struct' には、明示的に宣言されたコンストラクターを含める必要があります。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
@@ -1264,12 +1264,12 @@
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForListPattern">
         <source>List patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">List patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">リスト パターンは、'{0}' 型の値に使用されない可能性があります。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForSlicePattern">
         <source>Slice patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">Slice patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">スライス パターンは、'{0}' 型の値に使用されない可能性があります。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_WrongArityAsyncReturn">
@@ -1349,7 +1349,7 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureLengthPattern">
         <source>length pattern</source>
-        <target state="new">length pattern</target>
+        <target state="translated">長さのパターン</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
@@ -1359,12 +1359,12 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureListPattern">
         <source>list pattern</source>
-        <target state="new">list pattern</target>
+        <target state="translated">リスト パターン</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureNewLinesInInterpolations">
         <source>newlines in interpolations</source>
-        <target state="new">newlines in interpolations</target>
+        <target state="translated">補間における改行</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureParameterlessStructConstructors">
@@ -1409,7 +1409,7 @@
       </trans-unit>
       <trans-unit id="IDS_ParameterNullChecking">
         <source>parameter null-checking</source>
-        <target state="new">parameter null-checking</target>
+        <target state="translated">パラメーターの null チェック</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_AnalyzerReferencesFramework">
@@ -1524,12 +1524,12 @@
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName">
         <source>The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">型名 '{0}' には、小文字の ASCII 文字のみが含まれています。このような名前は、プログラミング言語用に予約されている可能性があります。</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName_Title">
         <source>The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">型名には、小文字の ASCII 文字のみが含まれています。このような名前は、プログラミング言語用に予約されている可能性があります。</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
@@ -1544,22 +1544,22 @@
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull">
         <source>Parameter '{0}' is null-checked but is null by default.</source>
-        <target state="new">Parameter '{0}' is null-checked but is null by default.</target>
+        <target state="translated">パラメーター '{0}' は null チェックされていますが、既定では null です。</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull_Title">
         <source>Parameter is null-checked but is null by default.</source>
-        <target state="new">Parameter is null-checked but is null by default.</target>
+        <target state="translated">パラメーターは null チェックされていますが、既定では null です。</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType">
         <source>Nullable type '{0}' is null-checked and will throw if null.</source>
-        <target state="new">Nullable type '{0}' is null-checked and will throw if null.</target>
+        <target state="translated">Null 許容型 '{0}' は null チェックされており、null の場合はスローされます。</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType_Title">
         <source>Nullable type is null-checked and will throw if null.</source>
-        <target state="new">Nullable type is null-checked and will throw if null.</target>
+        <target state="translated">Null 許容型は null チェックされており、null の場合はスローされます。</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1574,7 +1574,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
+        <target state="translated">パラメーター リスト内の '{1}' の後にパラメーター '{0}' が発生しますが、補間された文字列ハンドラーの変換の引数として使用されます。呼び出し元が呼び出しサイトで名前付き引数を使用してパラメーターを並べ替える必要があります。関係するすべての引数の後に、補間された文字列ハンドラーのパラメーターを指定することを検討してください。</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
index 9130c787ea771..7ad7f17c7f674 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
@@ -224,7 +224,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotBeMadeNullable">
         <source>'{0}' cannot be made nullable.</source>
-        <target state="new">'{0}' cannot be made nullable.</target>
+        <target state="translated">'{0}'은(는) nullable이 될 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotClone">
@@ -264,7 +264,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotUseRefInUnmanagedCallersOnly">
         <source>Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</source>
-        <target state="new">Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</target>
+        <target state="translated">'UnmanagedCallersOnly'로 특성이 지정된 메서드의 시그니처에는 'ref', 'in' 또는 'out'을 사용할 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotUseSelfAsInterpolatedStringHandlerArgument">
@@ -464,7 +464,7 @@
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsPatternImplicitIndexer">
         <source>An expression tree may not contain a pattern System.Index or System.Range indexer access</source>
-        <target state="new">An expression tree may not contain a pattern System.Index or System.Range indexer access</target>
+        <target state="translated">식 트리에는 System.Index 또는 System.Range 패턴의 인덱서 액세스를 포함할 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsRangeExpression">
@@ -629,7 +629,7 @@
       </trans-unit>
       <trans-unit id="ERR_IncorrectNullCheckSyntax">
         <source>Incorrect parameter null checking syntax. Should be '!!'.</source>
-        <target state="new">Incorrect parameter null checking syntax. Should be '!!'.</target>
+        <target state="translated">잘못된 매개 변수 Null 검사 구문입니다. '!!'이어야 합니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InheritingFromRecordWithSealedToString">
@@ -694,7 +694,7 @@
       </trans-unit>
       <trans-unit id="ERR_InterpolatedStringsReferencingInstanceCannotBeInObjectInitializers">
         <source>Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</source>
-        <target state="new">Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</target>
+        <target state="translated">인덱싱되는 인스턴스를 참조하는 보간된 문자열 처리기 변환은 인덱서 멤버 이니셜라이저에서 사용할 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InvalidFuncPointerReturnTypeModifier">
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaExplicitReturnTypeVar">
         <source>The contextual keyword 'var' cannot be used as an explicit lambda return type</source>
-        <target state="new">The contextual keyword 'var' cannot be used as an explicit lambda return type</target>
+        <target state="translated">'var' 상황별 키워드는 명시적 람다 반환 형식으로 사용할 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
@@ -794,7 +794,7 @@
       </trans-unit>
       <trans-unit id="ERR_MisplacedSlicePattern">
         <source>Slice patterns may only be used once and directly inside a list pattern.</source>
-        <target state="new">Slice patterns may only be used once and directly inside a list pattern.</target>
+        <target state="translated">조각 패턴은 목록 패턴 내에서 바로 한 번만 사용할 수 있습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MissingAddressOf">
@@ -854,7 +854,7 @@
       </trans-unit>
       <trans-unit id="ERR_MustNullCheckInImplementation">
         <source>Parameter '{0}' can only have exclamation-point null checking in implementation methods.</source>
-        <target state="new">Parameter '{0}' can only have exclamation-point null checking in implementation methods.</target>
+        <target state="translated">매개 변수 '{0}'은(는) 구현 메서드에서 느낌표 Null 검사만 포함할 수 있습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NewBoundWithUnmanaged">
@@ -864,7 +864,7 @@
       </trans-unit>
       <trans-unit id="ERR_NewlinesAreNotAllowedInsideANonVerbatimInterpolatedString">
         <source>Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</source>
-        <target state="new">Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</target>
+        <target state="translated">축자가 아닌 보간된 문자열 내의 줄 바꿈은 C# {0}에서 지원되지 않습니다. {1} 이상의 언어 버전을 사용하세요.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NoConvToIAsyncDispWrongAsync">
@@ -899,7 +899,7 @@
       </trans-unit>
       <trans-unit id="ERR_NonNullableValueTypeIsNullChecked">
         <source>Parameter '{0}' is a non-nullable value type and cannot be null-checked.</source>
-        <target state="new">Parameter '{0}' is a non-nullable value type and cannot be null-checked.</target>
+        <target state="translated">매개 변수 '{0}'은(는) Null을 허용하지 않는 값 형식이므로 Null을 검사할 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NonPrivateAPIInRecord">
@@ -934,7 +934,7 @@
       </trans-unit>
       <trans-unit id="ERR_NullCheckingOnByRefParameter">
         <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="new">By-reference parameter '{0}' cannot be null-checked.</target>
+        <target state="translated">참조 기준 매개 변수 '{0}'을(를) Null로 확인할 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
@@ -1069,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
         <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
+        <target state="translated">매개 변수 목록을 사용하여 '레코드 구조체'에 선언된 생성자에는 기본 생성자 또는 명시적으로 선언된 생성자를 호출하는 'this' 이니셜라이저가 있어야 합니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
@@ -1264,12 +1264,12 @@
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForListPattern">
         <source>List patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">List patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">목록 패턴은 '{0}' 형식 값에 사용할 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForSlicePattern">
         <source>Slice patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">Slice patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">조각 패턴은 '{0}' 형식 값에 사용할 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_WrongArityAsyncReturn">
@@ -1349,7 +1349,7 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureLengthPattern">
         <source>length pattern</source>
-        <target state="new">length pattern</target>
+        <target state="translated">길이 패턴</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
@@ -1359,12 +1359,12 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureListPattern">
         <source>list pattern</source>
-        <target state="new">list pattern</target>
+        <target state="translated">목록 패턴</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureNewLinesInInterpolations">
         <source>newlines in interpolations</source>
-        <target state="new">newlines in interpolations</target>
+        <target state="translated">보간에서 줄 바꿈</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureParameterlessStructConstructors">
@@ -1409,7 +1409,7 @@
       </trans-unit>
       <trans-unit id="IDS_ParameterNullChecking">
         <source>parameter null-checking</source>
-        <target state="new">parameter null-checking</target>
+        <target state="translated">매개 변수 Null 확인</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_AnalyzerReferencesFramework">
@@ -1524,12 +1524,12 @@
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName">
         <source>The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">형식 이름 '{0}'에는 소문자 ASCII 문자만 포함됩니다. 이러한 이름은 언어에 대해 예약될 수 있습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName_Title">
         <source>The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">형식 이름에는 소문자 ASCII 문자만 포함됩니다. 이러한 이름은 언어에 대해 예약될 수 있습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
@@ -1544,22 +1544,22 @@
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull">
         <source>Parameter '{0}' is null-checked but is null by default.</source>
-        <target state="new">Parameter '{0}' is null-checked but is null by default.</target>
+        <target state="translated">매개 변수 '{0}'은(는) Null로 확인되었지만 기본적으로 Null입니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull_Title">
         <source>Parameter is null-checked but is null by default.</source>
-        <target state="new">Parameter is null-checked but is null by default.</target>
+        <target state="translated">매개 변수가 Null로 확인되었지만 기본적으로 Null입니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType">
         <source>Nullable type '{0}' is null-checked and will throw if null.</source>
-        <target state="new">Nullable type '{0}' is null-checked and will throw if null.</target>
+        <target state="translated">nullable 형식 '{0}'은(는) Null로 확인되었으며 Null이면 throw됩니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType_Title">
         <source>Nullable type is null-checked and will throw if null.</source>
-        <target state="new">Nullable type is null-checked and will throw if null.</target>
+        <target state="translated">nullable 형식은 Null로 확인되며 Null이면 throw됩니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1574,7 +1574,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
+        <target state="translated">‘{0}’ 매개 변수는 매개 변수 목록에서 ‘{1}’ 다음에 나타나지만 보간된 문자열 처리기 변환을 위한 인수로 사용됩니다. 이렇게 하려면 호출자가 호출 사이트에서 명명된 인수를 사용하여 매개 변수를 재정렬해야 합니다. 관련된 모든 인수 뒤에 보간된 문자열 처리기 매개 변수를 넣는 것을 고려하세요.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
index 071a746370502..91f88ca15314a 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
@@ -224,7 +224,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotBeMadeNullable">
         <source>'{0}' cannot be made nullable.</source>
-        <target state="new">'{0}' cannot be made nullable.</target>
+        <target state="translated">'Nie można ustawić elementu „{0}” jako dopuszczającego wartość null.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotClone">
@@ -264,7 +264,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotUseRefInUnmanagedCallersOnly">
         <source>Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</source>
-        <target state="new">Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</target>
+        <target state="translated">Nie można użyć elementów „ref”, „in” ani „out” w sygnaturze metody z atrybutem „UnmanagedCallersOnly”.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotUseSelfAsInterpolatedStringHandlerArgument">
@@ -464,7 +464,7 @@
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsPatternImplicitIndexer">
         <source>An expression tree may not contain a pattern System.Index or System.Range indexer access</source>
-        <target state="new">An expression tree may not contain a pattern System.Index or System.Range indexer access</target>
+        <target state="translated">Drzewo wyrażenia nie może zawierać dostępu do indeksatora z wzorcem System.Index lub System.Range</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsRangeExpression">
@@ -629,7 +629,7 @@
       </trans-unit>
       <trans-unit id="ERR_IncorrectNullCheckSyntax">
         <source>Incorrect parameter null checking syntax. Should be '!!'.</source>
-        <target state="new">Incorrect parameter null checking syntax. Should be '!!'.</target>
+        <target state="translated">Niepoprawna składnia sprawdzania wartości null parametru. Powinien mieć wartość „!!".</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InheritingFromRecordWithSealedToString">
@@ -694,7 +694,7 @@
       </trans-unit>
       <trans-unit id="ERR_InterpolatedStringsReferencingInstanceCannotBeInObjectInitializers">
         <source>Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</source>
-        <target state="new">Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</target>
+        <target state="translated">W inicjatorach składowych indeksatora nie można używać konwersji procedury obsługi ciągów interpolowanych odwołujących się do indeksowanego wystąpienia.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InvalidFuncPointerReturnTypeModifier">
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaExplicitReturnTypeVar">
         <source>The contextual keyword 'var' cannot be used as an explicit lambda return type</source>
-        <target state="new">The contextual keyword 'var' cannot be used as an explicit lambda return type</target>
+        <target state="translated">Kontekstowego słowa kluczowego „var” nie można użyć jako jawnego zwracanego typu lambda</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
@@ -794,7 +794,7 @@
       </trans-unit>
       <trans-unit id="ERR_MisplacedSlicePattern">
         <source>Slice patterns may only be used once and directly inside a list pattern.</source>
-        <target state="new">Slice patterns may only be used once and directly inside a list pattern.</target>
+        <target state="translated">Wzorce wycinków mogą być używane tylko raz i bezpośrednio wewnątrz wzorca listy.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MissingAddressOf">
@@ -854,7 +854,7 @@
       </trans-unit>
       <trans-unit id="ERR_MustNullCheckInImplementation">
         <source>Parameter '{0}' can only have exclamation-point null checking in implementation methods.</source>
-        <target state="new">Parameter '{0}' can only have exclamation-point null checking in implementation methods.</target>
+        <target state="translated">Parametr „{0}” może być sprawdzony tylko przy użyciu wartości null dla wykrzyknika w metodach implementacji.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NewBoundWithUnmanaged">
@@ -864,7 +864,7 @@
       </trans-unit>
       <trans-unit id="ERR_NewlinesAreNotAllowedInsideANonVerbatimInterpolatedString">
         <source>Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</source>
-        <target state="new">Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</target>
+        <target state="translated">Nowe wiersze wewnątrz ciągu interpolowanego nie będącego ciągiem dosłownym nie są obsługiwane w {0} języka C#. Użyj wersji językowej {1} lub nowszej.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NoConvToIAsyncDispWrongAsync">
@@ -899,7 +899,7 @@
       </trans-unit>
       <trans-unit id="ERR_NonNullableValueTypeIsNullChecked">
         <source>Parameter '{0}' is a non-nullable value type and cannot be null-checked.</source>
-        <target state="new">Parameter '{0}' is a non-nullable value type and cannot be null-checked.</target>
+        <target state="translated">Parametr „{0}” jest typem wartości, który nie dopuszcza wartości null i nie może być sprawdzony przy użyciu wartości null.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NonPrivateAPIInRecord">
@@ -934,7 +934,7 @@
       </trans-unit>
       <trans-unit id="ERR_NullCheckingOnByRefParameter">
         <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="new">By-reference parameter '{0}' cannot be null-checked.</target>
+        <target state="translated">Parametru referencyjny „{0}” nie może zostać sprawdzony przy użyciu wartości null.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
@@ -1069,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
         <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
+        <target state="translated">Konstruktor zadeklarowany w „strukturze rekordów” z listą parametrów musi mieć inicjator „this”, który wywołuje konstruktor podstawowy lub jawnie zadeklarowany konstruktor.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
@@ -1264,12 +1264,12 @@
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForListPattern">
         <source>List patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">List patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">Wzorców list nie można używać na potrzeby wartości typu „{0}”.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForSlicePattern">
         <source>Slice patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">Slice patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">Wzorców wycinków nie można używać na potrzeby wartości typu „{0}”.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_WrongArityAsyncReturn">
@@ -1349,7 +1349,7 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureLengthPattern">
         <source>length pattern</source>
-        <target state="new">length pattern</target>
+        <target state="translated">wzorzec długości</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
@@ -1359,12 +1359,12 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureListPattern">
         <source>list pattern</source>
-        <target state="new">list pattern</target>
+        <target state="translated">wzorzec listy</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureNewLinesInInterpolations">
         <source>newlines in interpolations</source>
-        <target state="new">newlines in interpolations</target>
+        <target state="translated">nowe wiersze w interpolacjach</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureParameterlessStructConstructors">
@@ -1409,7 +1409,7 @@
       </trans-unit>
       <trans-unit id="IDS_ParameterNullChecking">
         <source>parameter null-checking</source>
-        <target state="new">parameter null-checking</target>
+        <target state="translated">sprawdzanie wartości null parametru</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_AnalyzerReferencesFramework">
@@ -1524,12 +1524,12 @@
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName">
         <source>The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">Nazwa typu „{0}” zawiera tylko małe litery ascii. Takie nazwy mogą zostać zarezerwowane dla języka.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName_Title">
         <source>The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">Nazwa typu zawiera tylko małe litery ascii. Takie nazwy mogą zostać zarezerwowane dla języka.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
@@ -1544,22 +1544,22 @@
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull">
         <source>Parameter '{0}' is null-checked but is null by default.</source>
-        <target state="new">Parameter '{0}' is null-checked but is null by default.</target>
+        <target state="translated">Parametr „{0}” jest sprawdzony przy użyciu wartości null, ale domyślnie ma wartość null.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull_Title">
         <source>Parameter is null-checked but is null by default.</source>
-        <target state="new">Parameter is null-checked but is null by default.</target>
+        <target state="translated">Parametr jest sprawdzony przy użyciu wartości null, ale domyślnie ma wartość null.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType">
         <source>Nullable type '{0}' is null-checked and will throw if null.</source>
-        <target state="new">Nullable type '{0}' is null-checked and will throw if null.</target>
+        <target state="translated">Typ dopuszczający wartość null „{0}” jest sprawdzany przy użyciu wartości null i będzie widoczny w przypadku wartości null.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType_Title">
         <source>Nullable type is null-checked and will throw if null.</source>
-        <target state="new">Nullable type is null-checked and will throw if null.</target>
+        <target state="translated">Typ dopuszczający wartość null jest sprawdzony przy użyciu wartości null i będzie widoczny w przypadku wartości null.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1574,7 +1574,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
+        <target state="translated">Parametr „{0}” występuje po elemencie „{1}” na liście parametrów, ale jest on używany jako argument dla konwersji procedury obsługi ciągów interpolowanych. Będzie to wymagać od wywołującego zmiany kolejności parametrów za pomocą nazwanych argumentów w lokacji wywołania. Rozważ umieszczenie parametru procedury obsługi ciągu interpolowanego po wszystkich zastosowanych argumentach.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
index fdb39de3b4592..2b3171caf9dc3 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
@@ -224,7 +224,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotBeMadeNullable">
         <source>'{0}' cannot be made nullable.</source>
-        <target state="new">'{0}' cannot be made nullable.</target>
+        <target state="translated">'{0}' não pode ser tornado anulável.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotClone">
@@ -264,7 +264,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotUseRefInUnmanagedCallersOnly">
         <source>Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</source>
-        <target state="new">Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</target>
+        <target state="translated">Não é possível usar 'ref', 'in' ou 'out' na assinatura de um método atribuído com 'UnmanagedCallersOnly'.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotUseSelfAsInterpolatedStringHandlerArgument">
@@ -464,7 +464,7 @@
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsPatternImplicitIndexer">
         <source>An expression tree may not contain a pattern System.Index or System.Range indexer access</source>
-        <target state="new">An expression tree may not contain a pattern System.Index or System.Range indexer access</target>
+        <target state="translated">Uma árvore de expressão não pode conter um padrão System.Index ou acesso do indexador System.Range</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsRangeExpression">
@@ -629,7 +629,7 @@
       </trans-unit>
       <trans-unit id="ERR_IncorrectNullCheckSyntax">
         <source>Incorrect parameter null checking syntax. Should be '!!'.</source>
-        <target state="new">Incorrect parameter null checking syntax. Should be '!!'.</target>
+        <target state="translated">Sintaxe de verificação de nulo de parâmetro incorreta. Deveria estar '!!'.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InheritingFromRecordWithSealedToString">
@@ -694,7 +694,7 @@
       </trans-unit>
       <trans-unit id="ERR_InterpolatedStringsReferencingInstanceCannotBeInObjectInitializers">
         <source>Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</source>
-        <target state="new">Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</target>
+        <target state="translated">Conversões do manipulador de cadeia de caracteres interpoladas que fazem referência à instância que está sendo indexada não podem ser usadas em inicializadores de membros indexadores.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InvalidFuncPointerReturnTypeModifier">
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaExplicitReturnTypeVar">
         <source>The contextual keyword 'var' cannot be used as an explicit lambda return type</source>
-        <target state="new">The contextual keyword 'var' cannot be used as an explicit lambda return type</target>
+        <target state="translated">A palavra-chave contextual 'var' não pode ser usada como um tipo de retorno de lambda explícito</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
@@ -794,7 +794,7 @@
       </trans-unit>
       <trans-unit id="ERR_MisplacedSlicePattern">
         <source>Slice patterns may only be used once and directly inside a list pattern.</source>
-        <target state="new">Slice patterns may only be used once and directly inside a list pattern.</target>
+        <target state="translated">Os padrões de fatia somente podem ser usados uma vez e diretamente dentro de um padrão de lista.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MissingAddressOf">
@@ -854,7 +854,7 @@
       </trans-unit>
       <trans-unit id="ERR_MustNullCheckInImplementation">
         <source>Parameter '{0}' can only have exclamation-point null checking in implementation methods.</source>
-        <target state="new">Parameter '{0}' can only have exclamation-point null checking in implementation methods.</target>
+        <target state="translated">O parâmetro '{0}' só pode ter verificação nula de ponto de exclamação nos métodos de implementação.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NewBoundWithUnmanaged">
@@ -864,7 +864,7 @@
       </trans-unit>
       <trans-unit id="ERR_NewlinesAreNotAllowedInsideANonVerbatimInterpolatedString">
         <source>Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</source>
-        <target state="new">Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</target>
+        <target state="translated">Novas linhas dentro de uma cadeia de caracteres interpolada não textual não são suportadas no C# {0}. Use a versão {1} da linguagem ou superior.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NoConvToIAsyncDispWrongAsync">
@@ -899,7 +899,7 @@
       </trans-unit>
       <trans-unit id="ERR_NonNullableValueTypeIsNullChecked">
         <source>Parameter '{0}' is a non-nullable value type and cannot be null-checked.</source>
-        <target state="new">Parameter '{0}' is a non-nullable value type and cannot be null-checked.</target>
+        <target state="translated">O parâmetro '{0}' é um tipo de valor não anulável e não pode ser verificado como nulo.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NonPrivateAPIInRecord">
@@ -934,7 +934,7 @@
       </trans-unit>
       <trans-unit id="ERR_NullCheckingOnByRefParameter">
         <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="new">By-reference parameter '{0}' cannot be null-checked.</target>
+        <target state="translated">O parâmetro por referência '{0}' não pode ser verificado com o valor nulo.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
@@ -1069,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
         <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
+        <target state="translated">Um construtor declarado em uma 'estrutura de registro' com lista de parâmetros deve ter um inicializador 'este' que chama o construtor primário ou um construtor declarado explicitamente.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
@@ -1264,12 +1264,12 @@
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForListPattern">
         <source>List patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">List patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">Os padrões de lista não podem ser usados para um valor do tipo '{0}'.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForSlicePattern">
         <source>Slice patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">Slice patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">Os padrões de fatia não podem ser usados para um valor do tipo '{0}'.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_WrongArityAsyncReturn">
@@ -1349,7 +1349,7 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureLengthPattern">
         <source>length pattern</source>
-        <target state="new">length pattern</target>
+        <target state="translated">padrão de comprimento</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
@@ -1359,12 +1359,12 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureListPattern">
         <source>list pattern</source>
-        <target state="new">list pattern</target>
+        <target state="translated">padrão de lista</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureNewLinesInInterpolations">
         <source>newlines in interpolations</source>
-        <target state="new">newlines in interpolations</target>
+        <target state="translated">novas linhas em interpolações</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureParameterlessStructConstructors">
@@ -1409,7 +1409,7 @@
       </trans-unit>
       <trans-unit id="IDS_ParameterNullChecking">
         <source>parameter null-checking</source>
-        <target state="new">parameter null-checking</target>
+        <target state="translated">parâmetro de verificação nula</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_AnalyzerReferencesFramework">
@@ -1524,12 +1524,12 @@
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName">
         <source>The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">O nome do tipo '{0}' contém apenas caracteres ascii em caixa baixa. Esses nomes podem ficar reservados para o idioma.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName_Title">
         <source>The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">O nome do tipo contém apenas caracteres ascii em caixa baixa. Esses nomes podem ficar reservados para o idioma.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
@@ -1544,22 +1544,22 @@
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull">
         <source>Parameter '{0}' is null-checked but is null by default.</source>
-        <target state="new">Parameter '{0}' is null-checked but is null by default.</target>
+        <target state="translated">O parâmetro '{0}' é verificado como nulo, mas é nulo por padrão.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull_Title">
         <source>Parameter is null-checked but is null by default.</source>
-        <target state="new">Parameter is null-checked but is null by default.</target>
+        <target state="translated">O parâmetro é verificado como nulo, mas é nulo por padrão.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType">
         <source>Nullable type '{0}' is null-checked and will throw if null.</source>
-        <target state="new">Nullable type '{0}' is null-checked and will throw if null.</target>
+        <target state="translated">O tipo anulável '{0}' é verificado como nulo e será lançado se for nulo.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType_Title">
         <source>Nullable type is null-checked and will throw if null.</source>
-        <target state="new">Nullable type is null-checked and will throw if null.</target>
+        <target state="translated">O tipo anulável é verificado como nulo e será lançado se for nulo.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1574,7 +1574,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
+        <target state="translated">O parâmetro {0} ocorre após {1} na lista de parâmetros, mas é usado como um argumento para as conversões do manipulador de cadeia de caracteres interpolada. Isso exigirá que o chamador reordene os parâmetros com argumentos nomeados no local da chamada. Considere colocar o parâmetro do manipulador de cadeia de caracteres interpolada após todos os argumentos envolvidos.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
index 1786df85e6ee5..765ee1d7fa753 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
@@ -224,7 +224,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotBeMadeNullable">
         <source>'{0}' cannot be made nullable.</source>
-        <target state="new">'{0}' cannot be made nullable.</target>
+        <target state="translated">"{0}" не может быть стать параметром, допускающим NULL.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotClone">
@@ -264,7 +264,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotUseRefInUnmanagedCallersOnly">
         <source>Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</source>
-        <target state="new">Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</target>
+        <target state="translated">Нельзя использовать "ref", "in" или "out" в сигнатуре метода с атрибутом "UnmanagedCallersOnly".</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotUseSelfAsInterpolatedStringHandlerArgument">
@@ -464,7 +464,7 @@
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsPatternImplicitIndexer">
         <source>An expression tree may not contain a pattern System.Index or System.Range indexer access</source>
-        <target state="new">An expression tree may not contain a pattern System.Index or System.Range indexer access</target>
+        <target state="translated">Дерево выражения не может содержать доступ к индексатору System.Index или System.Range шаблона.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsRangeExpression">
@@ -629,7 +629,7 @@
       </trans-unit>
       <trans-unit id="ERR_IncorrectNullCheckSyntax">
         <source>Incorrect parameter null checking syntax. Should be '!!'.</source>
-        <target state="new">Incorrect parameter null checking syntax. Should be '!!'.</target>
+        <target state="translated">Неправильный синтаксис проверки значений NULL для параметра. Следует использовать "!!".</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InheritingFromRecordWithSealedToString">
@@ -694,7 +694,7 @@
       </trans-unit>
       <trans-unit id="ERR_InterpolatedStringsReferencingInstanceCannotBeInObjectInitializers">
         <source>Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</source>
-        <target state="new">Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</target>
+        <target state="translated">Преобразования обработчика интерполированной строки, ссылающиеся на индексируемый экземпляр, нельзя использовать в инициализаторах элементов индексатора.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InvalidFuncPointerReturnTypeModifier">
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaExplicitReturnTypeVar">
         <source>The contextual keyword 'var' cannot be used as an explicit lambda return type</source>
-        <target state="new">The contextual keyword 'var' cannot be used as an explicit lambda return type</target>
+        <target state="translated">Контекстное ключевое слово "var" нельзя использовать в качестве явного типа возвращаемого значения лямбда-выражения</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
@@ -794,7 +794,7 @@
       </trans-unit>
       <trans-unit id="ERR_MisplacedSlicePattern">
         <source>Slice patterns may only be used once and directly inside a list pattern.</source>
-        <target state="new">Slice patterns may only be used once and directly inside a list pattern.</target>
+        <target state="translated">Шаблоны среза можно использовать только один раз и непосредственно внутри шаблона списка.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MissingAddressOf">
@@ -854,7 +854,7 @@
       </trans-unit>
       <trans-unit id="ERR_MustNullCheckInImplementation">
         <source>Parameter '{0}' can only have exclamation-point null checking in implementation methods.</source>
-        <target state="new">Parameter '{0}' can only have exclamation-point null checking in implementation methods.</target>
+        <target state="translated">Для параметра "{0}" может использоваться только проверка значений NULL с восклицательным знаком в методах реализации.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NewBoundWithUnmanaged">
@@ -864,7 +864,7 @@
       </trans-unit>
       <trans-unit id="ERR_NewlinesAreNotAllowedInsideANonVerbatimInterpolatedString">
         <source>Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</source>
-        <target state="new">Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</target>
+        <target state="translated">Новые строки внутри небуквальной интерполированной строки не поддерживаются в C# {0}. Используйте версию языка {1} или более позднюю.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NoConvToIAsyncDispWrongAsync">
@@ -899,7 +899,7 @@
       </trans-unit>
       <trans-unit id="ERR_NonNullableValueTypeIsNullChecked">
         <source>Parameter '{0}' is a non-nullable value type and cannot be null-checked.</source>
-        <target state="new">Parameter '{0}' is a non-nullable value type and cannot be null-checked.</target>
+        <target state="translated">Параметр "{0}" является типом значения, не допускающим значения NULL, и для него невозможно выполнить проверку значения NULL.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NonPrivateAPIInRecord">
@@ -934,7 +934,7 @@
       </trans-unit>
       <trans-unit id="ERR_NullCheckingOnByRefParameter">
         <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="new">By-reference parameter '{0}' cannot be null-checked.</target>
+        <target state="translated">Для параметра по ссылке "{0}" невозможно проверить значение NULL.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
@@ -1069,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
         <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
+        <target state="translated">Конструктор, объявленный в "record struct" со списком параметров, должен содержать инициализатор "this", который вызывает первичный конструктор или явно объявленный конструктор.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
@@ -1194,7 +1194,7 @@
       </trans-unit>
       <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
         <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
-        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <target state="translated">Параметр struct с инициализаторами полей должен включать явно объявленный конструктор.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
@@ -1264,12 +1264,12 @@
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForListPattern">
         <source>List patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">List patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">Шаблоны списка не могут использоваться для значений типа "{0}".</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForSlicePattern">
         <source>Slice patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">Slice patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">Шаблоны среза не могут использоваться для значений типа "{0}".</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_WrongArityAsyncReturn">
@@ -1349,7 +1349,7 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureLengthPattern">
         <source>length pattern</source>
-        <target state="new">length pattern</target>
+        <target state="translated">шаблон длины</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
@@ -1359,12 +1359,12 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureListPattern">
         <source>list pattern</source>
-        <target state="new">list pattern</target>
+        <target state="translated">шаблон списка</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureNewLinesInInterpolations">
         <source>newlines in interpolations</source>
-        <target state="new">newlines in interpolations</target>
+        <target state="translated">новые линии в интерполяции</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureParameterlessStructConstructors">
@@ -1409,7 +1409,7 @@
       </trans-unit>
       <trans-unit id="IDS_ParameterNullChecking">
         <source>parameter null-checking</source>
-        <target state="new">parameter null-checking</target>
+        <target state="translated">проверка значений NULL для параметра</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_AnalyzerReferencesFramework">
@@ -1524,12 +1524,12 @@
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName">
         <source>The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">Имя типа "{0}" содержит только строчные символы ASCII. Такие имена могут резервироваться для языка.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName_Title">
         <source>The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">Имя типа содержит только строчные символы ASCII. Такие имена могут резервироваться для языка.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
@@ -1544,22 +1544,22 @@
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull">
         <source>Parameter '{0}' is null-checked but is null by default.</source>
-        <target state="new">Parameter '{0}' is null-checked but is null by default.</target>
+        <target state="translated">Для параметра "{0}" выполнена проверка значения NULL, но он по умолчанию имеет значение NULL.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull_Title">
         <source>Parameter is null-checked but is null by default.</source>
-        <target state="new">Parameter is null-checked but is null by default.</target>
+        <target state="translated">Для параметра выполнена проверка значения NULL, но он по умолчанию имеет значение NULL.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType">
         <source>Nullable type '{0}' is null-checked and will throw if null.</source>
-        <target state="new">Nullable type '{0}' is null-checked and will throw if null.</target>
+        <target state="translated">Для типа "{0}", допускающего значение NULL, выполнена проверка значения NULL. Он будет выдаваться, если ему присвоено значение NULL.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType_Title">
         <source>Nullable type is null-checked and will throw if null.</source>
-        <target state="new">Nullable type is null-checked and will throw if null.</target>
+        <target state="translated">Для типа, допускающего значение NULL, выполнена проверка значения NULL. Он будет выдаваться, если ему присвоено значение NULL.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1574,7 +1574,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
+        <target state="translated">Параметр {0} указан после {1} в списке параметров, но используется в качестве аргумента для преобразований обработчика интерполированных строк. В этом случае вызывающий должен изменить порядок параметров с именованными аргументами на сайте вызова. Рекомендуем разместить параметр обработчика интерполированных строк после всех используемых аргументов.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
index c420bb7b863cb..6f74471fd15a5 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
@@ -224,7 +224,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotBeMadeNullable">
         <source>'{0}' cannot be made nullable.</source>
-        <target state="new">'{0}' cannot be made nullable.</target>
+        <target state="translated">'{0}' öğesine null değer alma özelliği verilemiyor.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotClone">
@@ -264,7 +264,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotUseRefInUnmanagedCallersOnly">
         <source>Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</source>
-        <target state="new">Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</target>
+        <target state="translated">'UnmanagedCallersOnly' özniteliğine sahip bir metodun imzasında 'ref', 'in' veya 'out' kullanılamaz.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotUseSelfAsInterpolatedStringHandlerArgument">
@@ -464,7 +464,7 @@
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsPatternImplicitIndexer">
         <source>An expression tree may not contain a pattern System.Index or System.Range indexer access</source>
-        <target state="new">An expression tree may not contain a pattern System.Index or System.Range indexer access</target>
+        <target state="translated">İfade ağacı, desen System.Index veya System.Range dizin oluşturucu erişimi içeremez</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsRangeExpression">
@@ -629,7 +629,7 @@
       </trans-unit>
       <trans-unit id="ERR_IncorrectNullCheckSyntax">
         <source>Incorrect parameter null checking syntax. Should be '!!'.</source>
-        <target state="new">Incorrect parameter null checking syntax. Should be '!!'.</target>
+        <target state="translated">Yanlış parametre null denetimi söz dizimi. “!!” olmalıdır.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InheritingFromRecordWithSealedToString">
@@ -694,7 +694,7 @@
       </trans-unit>
       <trans-unit id="ERR_InterpolatedStringsReferencingInstanceCannotBeInObjectInitializers">
         <source>Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</source>
-        <target state="new">Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</target>
+        <target state="translated">Dizine alınan örneğe başvurulan düz metin arasına kod ekli dize işleyici dönüştürmeleri, dizin oluşturucu üye başlatıcılarında kullanılamaz.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InvalidFuncPointerReturnTypeModifier">
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaExplicitReturnTypeVar">
         <source>The contextual keyword 'var' cannot be used as an explicit lambda return type</source>
-        <target state="new">The contextual keyword 'var' cannot be used as an explicit lambda return type</target>
+        <target state="translated">Bağlamsal 'var' anahtar sözcüğü, açık lambda dönüş türü olarak kullanılamaz</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
@@ -794,7 +794,7 @@
       </trans-unit>
       <trans-unit id="ERR_MisplacedSlicePattern">
         <source>Slice patterns may only be used once and directly inside a list pattern.</source>
-        <target state="new">Slice patterns may only be used once and directly inside a list pattern.</target>
+        <target state="translated">Dilim desenleri yalnızca bir kez ve doğrudan bir liste deseninin içinde kullanılabilir.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MissingAddressOf">
@@ -854,7 +854,7 @@
       </trans-unit>
       <trans-unit id="ERR_MustNullCheckInImplementation">
         <source>Parameter '{0}' can only have exclamation-point null checking in implementation methods.</source>
-        <target state="new">Parameter '{0}' can only have exclamation-point null checking in implementation methods.</target>
+        <target state="translated">“{0}” parametresi, uygulama yöntemlerinde yalnızca ünlem işareti null denetimine sahip olabilir.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NewBoundWithUnmanaged">
@@ -864,7 +864,7 @@
       </trans-unit>
       <trans-unit id="ERR_NewlinesAreNotAllowedInsideANonVerbatimInterpolatedString">
         <source>Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</source>
-        <target state="new">Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</target>
+        <target state="translated">Tam olmayan düz metin arasına kod eklenmiş dize içindeki yeni satırlar, C# {0} içinde desteklenmiyor. Lütfen {1} dil sürümünü veya daha üstünü kullanın.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NoConvToIAsyncDispWrongAsync">
@@ -899,7 +899,7 @@
       </trans-unit>
       <trans-unit id="ERR_NonNullableValueTypeIsNullChecked">
         <source>Parameter '{0}' is a non-nullable value type and cannot be null-checked.</source>
-        <target state="new">Parameter '{0}' is a non-nullable value type and cannot be null-checked.</target>
+        <target state="translated">“{0}” parametresi, null atanamaz bir değer türüdür ve null denetimi yapılamaz.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NonPrivateAPIInRecord">
@@ -934,7 +934,7 @@
       </trans-unit>
       <trans-unit id="ERR_NullCheckingOnByRefParameter">
         <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="new">By-reference parameter '{0}' cannot be null-checked.</target>
+        <target state="translated">Başvuru parametresine göre “{0}” için null denetimi yapılamaz.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
@@ -1069,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
         <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
+        <target state="translated">Parametre listesiyle bir “kayıt yapısı”nda bildirilen bir oluşturucu, birincil oluşturucuyu veya açıkça bildirilen bir oluşturucuyu çağıran bir “this” başlatıcısına sahip olmalıdır.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
@@ -1264,12 +1264,12 @@
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForListPattern">
         <source>List patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">List patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">Liste desenleri, '{0}' türünde bir değer için kullanılamaz.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForSlicePattern">
         <source>Slice patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">Slice patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">Dilim desenleri, '{0}' türünde bir değer için kullanılamaz.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_WrongArityAsyncReturn">
@@ -1349,7 +1349,7 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureLengthPattern">
         <source>length pattern</source>
-        <target state="new">length pattern</target>
+        <target state="translated">uzunluk deseni</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
@@ -1359,12 +1359,12 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureListPattern">
         <source>list pattern</source>
-        <target state="new">list pattern</target>
+        <target state="translated">liste deseni</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureNewLinesInInterpolations">
         <source>newlines in interpolations</source>
-        <target state="new">newlines in interpolations</target>
+        <target state="translated">ilişkilendirmedeki yeni satırlar</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureParameterlessStructConstructors">
@@ -1409,7 +1409,7 @@
       </trans-unit>
       <trans-unit id="IDS_ParameterNullChecking">
         <source>parameter null-checking</source>
-        <target state="new">parameter null-checking</target>
+        <target state="translated">parametre null denetimi</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_AnalyzerReferencesFramework">
@@ -1524,12 +1524,12 @@
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName">
         <source>The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">“{0}” tür adı yalnızca küçük harfli ascii karakterleri içerir. Bu tür adlar dil için ayrılmış hale gelebilir.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName_Title">
         <source>The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">Tür adı yalnızca küçük harfli ascii karakterleri içerir. Bu tür adlar dil için ayrılmış hale gelebilir.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
@@ -1544,22 +1544,22 @@
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull">
         <source>Parameter '{0}' is null-checked but is null by default.</source>
-        <target state="new">Parameter '{0}' is null-checked but is null by default.</target>
+        <target state="translated">“{0}” parametresi null denetimlidir ancak varsayılan olarak null’dürr.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull_Title">
         <source>Parameter is null-checked but is null by default.</source>
-        <target state="new">Parameter is null-checked but is null by default.</target>
+        <target state="translated">Parametre null denetimlidir ancak varsayılan olarak null’dür.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType">
         <source>Nullable type '{0}' is null-checked and will throw if null.</source>
-        <target state="new">Nullable type '{0}' is null-checked and will throw if null.</target>
+        <target state="translated">“{0}” boş değer atanabilir tipi null denetimlidir ve null ise atılır.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType_Title">
         <source>Nullable type is null-checked and will throw if null.</source>
-        <target state="new">Nullable type is null-checked and will throw if null.</target>
+        <target state="translated">Boş değer atanabilir tip null denetimlidir ve null ise atılır.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1574,7 +1574,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
+        <target state="translated">Parametre listesinde parametre {0}, ardından parametre {1} gerçekleşir, ancak düz metin arasına kod eklenmiş dize işleyicisi dönüştürmeleri için bağımsız değişken olarak kullanılır. Bu, çağıranın, çağıran sitede adlandırılmış bağımsız değişkenlerle parametreleri yeniden düzenlemesini gerektirir. Tüm bağımsız değişkenlerin ardından düz metin arasına kod eklenmiş dize işleyicisi parametresini yerleştirmeyi göz önünde bulundurmanız gerekir.</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
@@ -7131,7 +7131,7 @@ RuntimeCompatibilityAttribute AssemblyInfo.cs dosyasında false olarak ayarlanm
       </trans-unit>
       <trans-unit id="ERR_BadOperatorSyntax">
         <source>Declaration is not valid; use '{0} operator &lt;dest-type&gt; (...' instead</source>
-        <target state="translated">Bildirim geçerli değil; bunun yerine '{0} işleç &lt; hedef-tür&gt; (...' kullanın</target>
+        <target state="translated">Bildirim geçerli değil; bunun yerine '{0} işleç &lt;hedef-tür&gt; (...' kullanın</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MainClassNotFound">
@@ -7726,7 +7726,7 @@ RuntimeCompatibilityAttribute AssemblyInfo.cs dosyasında false olarak ayarlanm
       </trans-unit>
       <trans-unit id="ERR_CantConvAsyncAnonFuncReturns">
         <source>Cannot convert async {0} to delegate type '{1}'. An async {0} may return void, Task or Task&lt;T&gt;, none of which are convertible to '{1}'.</source>
-        <target state="translated">Zaman uyumsuz {0}, '{1}' temsilci türüne dönüştürülemez. Zaman uyumsuz {0} void, Task veya Task&lt; T&gt; döndürebilir ve bunların hiçbiri '{1}' türüne dönüştürülemez.</target>
+        <target state="translated">Zaman uyumsuz {0}, '{1}' temsilci türüne dönüştürülemez. Zaman uyumsuz {0} void, Task veya Task&lt;T&gt; döndürebilir ve bunların hiçbiri '{1}' türüne dönüştürülemez.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_IllegalFixedType">
@@ -8929,7 +8929,7 @@ Derleyiciye yöntemleri ayrıştırma yolu verin. Örneğin, bunlara farklı adl
       </trans-unit>
       <trans-unit id="ERR_BadAwaitWithoutAsyncMethod">
         <source>The 'await' operator can only be used within an async method. Consider marking this method with the 'async' modifier and changing its return type to 'Task&lt;{0}&gt;'.</source>
-        <target state="translated">await' işleci yalnızca bir async metot içerisinde kullanılabilir. Bu metodu 'async' değiştiricisi ile işaretlemeyi ve dönüş tipini 'Task&lt;{0}&gt;' olarak değiştirmeyi düşünün.</target>
+        <target state="translated">'await' işleci yalnızca bir async metot içerisinde kullanılabilir. Bu metodu 'async' değiştiricisi ile işaretlemeyi ve dönüş tipini 'Task&lt;{0}&gt;' olarak değiştirmeyi düşünün.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_BadAwaitWithoutVoidAsyncMethod">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
index c320f05158406..461d32ca1734c 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
@@ -224,7 +224,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotBeMadeNullable">
         <source>'{0}' cannot be made nullable.</source>
-        <target state="new">'{0}' cannot be made nullable.</target>
+        <target state="translated">“{0}”不可以为 Null。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotClone">
@@ -264,7 +264,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotUseRefInUnmanagedCallersOnly">
         <source>Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</source>
-        <target state="new">Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</target>
+        <target state="translated">无法在具有 “UnmanagedCallersOnly” 特性的方法的签名中使用 “ref”、“in” 或 “out”。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotUseSelfAsInterpolatedStringHandlerArgument">
@@ -464,7 +464,7 @@
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsPatternImplicitIndexer">
         <source>An expression tree may not contain a pattern System.Index or System.Range indexer access</source>
-        <target state="new">An expression tree may not contain a pattern System.Index or System.Range indexer access</target>
+        <target state="translated">表达式树不能包含模式 System.Index 或 System.Range 索引器访问</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsRangeExpression">
@@ -629,7 +629,7 @@
       </trans-unit>
       <trans-unit id="ERR_IncorrectNullCheckSyntax">
         <source>Incorrect parameter null checking syntax. Should be '!!'.</source>
-        <target state="new">Incorrect parameter null checking syntax. Should be '!!'.</target>
+        <target state="translated">参数 null 检查语法不正确。应为 "!!"。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InheritingFromRecordWithSealedToString">
@@ -694,7 +694,7 @@
       </trans-unit>
       <trans-unit id="ERR_InterpolatedStringsReferencingInstanceCannotBeInObjectInitializers">
         <source>Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</source>
-        <target state="new">Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</target>
+        <target state="translated">引用要编制索引的实例的内插字符串处理程序转换不能用于索引器成员初始化表达式中。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InvalidFuncPointerReturnTypeModifier">
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaExplicitReturnTypeVar">
         <source>The contextual keyword 'var' cannot be used as an explicit lambda return type</source>
-        <target state="new">The contextual keyword 'var' cannot be used as an explicit lambda return type</target>
+        <target state="translated">上下文关键字 “var” 不能用作显式 lambda 返回类型</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
@@ -794,7 +794,7 @@
       </trans-unit>
       <trans-unit id="ERR_MisplacedSlicePattern">
         <source>Slice patterns may only be used once and directly inside a list pattern.</source>
-        <target state="new">Slice patterns may only be used once and directly inside a list pattern.</target>
+        <target state="translated">切片模式只能使用一次，并且直接在列表模式内使用。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MissingAddressOf">
@@ -854,7 +854,7 @@
       </trans-unit>
       <trans-unit id="ERR_MustNullCheckInImplementation">
         <source>Parameter '{0}' can only have exclamation-point null checking in implementation methods.</source>
-        <target state="new">Parameter '{0}' can only have exclamation-point null checking in implementation methods.</target>
+        <target state="translated">参数 "{0}" 只能在实现方法中包含感叹号 null 检查。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NewBoundWithUnmanaged">
@@ -864,7 +864,7 @@
       </trans-unit>
       <trans-unit id="ERR_NewlinesAreNotAllowedInsideANonVerbatimInterpolatedString">
         <source>Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</source>
-        <target state="new">Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</target>
+        <target state="translated">C# {0}不支持非逐字内插字符串内的换行符。请使用语言版本 {1} 或更高版本。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NoConvToIAsyncDispWrongAsync">
@@ -899,7 +899,7 @@
       </trans-unit>
       <trans-unit id="ERR_NonNullableValueTypeIsNullChecked">
         <source>Parameter '{0}' is a non-nullable value type and cannot be null-checked.</source>
-        <target state="new">Parameter '{0}' is a non-nullable value type and cannot be null-checked.</target>
+        <target state="translated">参数 "{0}" 是不可为 null 的值类型，不能进行 null 检查。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NonPrivateAPIInRecord">
@@ -934,7 +934,7 @@
       </trans-unit>
       <trans-unit id="ERR_NullCheckingOnByRefParameter">
         <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="new">By-reference parameter '{0}' cannot be null-checked.</target>
+        <target state="translated">不能对按地址引用参数 "{0}" 进行 null 检查。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
@@ -1069,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
         <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
+        <target state="translated">在带有参数列表的 "record struct" 中声明的构造函数必须具有调用主构造函数或显式声明的构造函数的 "this" 初始值设定项。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
@@ -1264,12 +1264,12 @@
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForListPattern">
         <source>List patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">List patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">列表模式不能用于类型为“{0}”的值。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForSlicePattern">
         <source>Slice patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">Slice patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">切片模式不能用于类型为“{0}”的值。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_WrongArityAsyncReturn">
@@ -1349,7 +1349,7 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureLengthPattern">
         <source>length pattern</source>
-        <target state="new">length pattern</target>
+        <target state="translated">长度模式</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
@@ -1359,12 +1359,12 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureListPattern">
         <source>list pattern</source>
-        <target state="new">list pattern</target>
+        <target state="translated">列表模式</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureNewLinesInInterpolations">
         <source>newlines in interpolations</source>
-        <target state="new">newlines in interpolations</target>
+        <target state="translated">内插中的换行符</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureParameterlessStructConstructors">
@@ -1409,7 +1409,7 @@
       </trans-unit>
       <trans-unit id="IDS_ParameterNullChecking">
         <source>parameter null-checking</source>
-        <target state="new">parameter null-checking</target>
+        <target state="translated">参数 null 检查</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_AnalyzerReferencesFramework">
@@ -1524,12 +1524,12 @@
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName">
         <source>The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">类型名称 "{0}" 仅包含小写 ascii 字符。此类名称可能会成为该语言的保留值。</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName_Title">
         <source>The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">该类型名称仅包含小写 ascii 字符。此类名称可能会成为该语言的保留值。</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
@@ -1544,22 +1544,22 @@
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull">
         <source>Parameter '{0}' is null-checked but is null by default.</source>
-        <target state="new">Parameter '{0}' is null-checked but is null by default.</target>
+        <target state="translated">对参数 "{0}" 进行了 null 检查，但默认情况下该参数为 null。</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull_Title">
         <source>Parameter is null-checked but is null by default.</source>
-        <target state="new">Parameter is null-checked but is null by default.</target>
+        <target state="translated">对参数进行了 null 检查，但默认情况下该参数为 null。</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType">
         <source>Nullable type '{0}' is null-checked and will throw if null.</source>
-        <target state="new">Nullable type '{0}' is null-checked and will throw if null.</target>
+        <target state="translated">对可以为 null 的类型“{0}”进行了 null 检查，如果为 null，将抛出异常。</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType_Title">
         <source>Nullable type is null-checked and will throw if null.</source>
-        <target state="new">Nullable type is null-checked and will throw if null.</target>
+        <target state="translated">对可以为 null 的类型进行了 null 检查，如果为 null，将抛出异常。</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1574,7 +1574,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
+        <target state="translated">参数“{0}”出现在参数列表中的“{1}”之后，但用作内插字符串处理程序转换的参数。这将要求调用方在调用站点使用已命名参数重新排列参数。请考虑将内插字符串处理程序参数放在涉及的所有参数的后面。</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
@@ -2284,7 +2284,7 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureSwitchExpression">
         <source>&lt;switch expression&gt;</source>
-        <target state="translated">&lt;switch expression&gt;</target>
+        <target state="translated">&lt;开关表达式&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureTargetTypedConditional">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
index 100fbb8acafa4..a6fb5751e8164 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
@@ -224,7 +224,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotBeMadeNullable">
         <source>'{0}' cannot be made nullable.</source>
-        <target state="new">'{0}' cannot be made nullable.</target>
+        <target state="translated">'{0}' 不可為 Null。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotClone">
@@ -264,7 +264,7 @@
       </trans-unit>
       <trans-unit id="ERR_CannotUseRefInUnmanagedCallersOnly">
         <source>Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</source>
-        <target state="new">Cannot use 'ref', 'in', or 'out' in the signature of a method attributed with 'UnmanagedCallersOnly'.</target>
+        <target state="translated">無法在具有 'UnmanagedCallersOnly' 的方法簽章中使用 'ref'、'in' 或 'out'。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_CannotUseSelfAsInterpolatedStringHandlerArgument">
@@ -464,7 +464,7 @@
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsPatternImplicitIndexer">
         <source>An expression tree may not contain a pattern System.Index or System.Range indexer access</source>
-        <target state="new">An expression tree may not contain a pattern System.Index or System.Range indexer access</target>
+        <target state="translated">運算式樹狀架構不可包含 System.Index 或 System.Range 索引子存取模式</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsRangeExpression">
@@ -629,7 +629,7 @@
       </trans-unit>
       <trans-unit id="ERR_IncorrectNullCheckSyntax">
         <source>Incorrect parameter null checking syntax. Should be '!!'.</source>
-        <target state="new">Incorrect parameter null checking syntax. Should be '!!'.</target>
+        <target state="translated">檢查參數是否為 Null 的語法不正確。應為 '!!'。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InheritingFromRecordWithSealedToString">
@@ -694,7 +694,7 @@
       </trans-unit>
       <trans-unit id="ERR_InterpolatedStringsReferencingInstanceCannotBeInObjectInitializers">
         <source>Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</source>
-        <target state="new">Interpolated string handler conversions that reference the instance being indexed cannot be used in indexer member initializers.</target>
+        <target state="translated">參考要編制索引的執行個體的差補字串處理常式轉換無法用於索引子成員初始化程式。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InvalidFuncPointerReturnTypeModifier">
@@ -769,7 +769,7 @@
       </trans-unit>
       <trans-unit id="ERR_LambdaExplicitReturnTypeVar">
         <source>The contextual keyword 'var' cannot be used as an explicit lambda return type</source>
-        <target state="new">The contextual keyword 'var' cannot be used as an explicit lambda return type</target>
+        <target state="translated">內容關鍵字 'var' 不得做為明確的 Lambda 傳回型別</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_LambdaWithAttributesToExpressionTree">
@@ -794,7 +794,7 @@
       </trans-unit>
       <trans-unit id="ERR_MisplacedSlicePattern">
         <source>Slice patterns may only be used once and directly inside a list pattern.</source>
-        <target state="new">Slice patterns may only be used once and directly inside a list pattern.</target>
+        <target state="translated">切片模式只能在清單模式中使用一次且直接使用。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_MissingAddressOf">
@@ -854,7 +854,7 @@
       </trans-unit>
       <trans-unit id="ERR_MustNullCheckInImplementation">
         <source>Parameter '{0}' can only have exclamation-point null checking in implementation methods.</source>
-        <target state="new">Parameter '{0}' can only have exclamation-point null checking in implementation methods.</target>
+        <target state="translated">在實作方法中，參數 '{0}' 只能使用驚嘆號檢查是否為 Null。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NewBoundWithUnmanaged">
@@ -864,7 +864,7 @@
       </trans-unit>
       <trans-unit id="ERR_NewlinesAreNotAllowedInsideANonVerbatimInterpolatedString">
         <source>Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</source>
-        <target state="new">Newlines inside a non-verbatim interpolated string are not supported in C# {0}. Please use language version {1} or greater.</target>
+        <target state="translated">C# {0} 不支援非逐字差補字串內的新行。請使用語言版本 {1} 或更高版本。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NoConvToIAsyncDispWrongAsync">
@@ -899,7 +899,7 @@
       </trans-unit>
       <trans-unit id="ERR_NonNullableValueTypeIsNullChecked">
         <source>Parameter '{0}' is a non-nullable value type and cannot be null-checked.</source>
-        <target state="new">Parameter '{0}' is a non-nullable value type and cannot be null-checked.</target>
+        <target state="translated">參數 '{0}' 是不可為 Null 的實值型別，而且不能檢查是否為 Null。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NonPrivateAPIInRecord">
@@ -934,7 +934,7 @@
       </trans-unit>
       <trans-unit id="ERR_NullCheckingOnByRefParameter">
         <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="new">By-reference parameter '{0}' cannot be null-checked.</target>
+        <target state="translated">參考類參數 '{0}' 不能檢查是否為 Null。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
@@ -1069,7 +1069,7 @@
       </trans-unit>
       <trans-unit id="ERR_RecordStructConstructorCallsDefaultConstructor">
         <source>A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</source>
-        <target state="new">A constructor declared in a 'record struct' with parameter list must have a 'this' initializer that calls the primary constructor or an explicitly declared constructor.</target>
+        <target state="translated">使用參數清單在 'record struct' 中宣告的建構函式，必須有呼叫主要建構函式或已明確宣告建構函式的 'this' 初始設定式。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_RefAssignNarrower">
@@ -1264,12 +1264,12 @@
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForListPattern">
         <source>List patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">List patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">類型 '{0}' 的值不可使用清單模式。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_UnsupportedTypeForSlicePattern">
         <source>Slice patterns may not be used for a value of type '{0}'.</source>
-        <target state="new">Slice patterns may not be used for a value of type '{0}'.</target>
+        <target state="translated">類型 '{0}' 的值不可使用切片模式。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_WrongArityAsyncReturn">
@@ -1349,7 +1349,7 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureLengthPattern">
         <source>length pattern</source>
-        <target state="new">length pattern</target>
+        <target state="translated">長度模式</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
@@ -1359,12 +1359,12 @@
       </trans-unit>
       <trans-unit id="IDS_FeatureListPattern">
         <source>list pattern</source>
-        <target state="new">list pattern</target>
+        <target state="translated">清單模式</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureNewLinesInInterpolations">
         <source>newlines in interpolations</source>
-        <target state="new">newlines in interpolations</target>
+        <target state="translated">插補中的新行</target>
         <note />
       </trans-unit>
       <trans-unit id="IDS_FeatureParameterlessStructConstructors">
@@ -1409,7 +1409,7 @@
       </trans-unit>
       <trans-unit id="IDS_ParameterNullChecking">
         <source>parameter null-checking</source>
-        <target state="new">parameter null-checking</target>
+        <target state="translated">檢查參數是否為 Null</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_AnalyzerReferencesFramework">
@@ -1524,12 +1524,12 @@
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName">
         <source>The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name '{0}' only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">類型名稱 '{0}' 只包含小寫的 ASCII 字元。此類名稱可能保留供此語言使用。</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_LowerCaseTypeName_Title">
         <source>The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</source>
-        <target state="new">The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</target>
+        <target state="translated">類型名稱只包含小寫的 ASCII 字元。此類名稱可能保留供此語言使用。</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_MethGrpToNonDel">
@@ -1544,22 +1544,22 @@
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull">
         <source>Parameter '{0}' is null-checked but is null by default.</source>
-        <target state="new">Parameter '{0}' is null-checked but is null by default.</target>
+        <target state="translated">已檢查參數 '{0}' 是否為 Null，但其本就預設為 Null。</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckedHasDefaultNull_Title">
         <source>Parameter is null-checked but is null by default.</source>
-        <target state="new">Parameter is null-checked but is null by default.</target>
+        <target state="translated">已檢查參數是否為 Null，但其本就預設為 Null。</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType">
         <source>Nullable type '{0}' is null-checked and will throw if null.</source>
-        <target state="new">Nullable type '{0}' is null-checked and will throw if null.</target>
+        <target state="translated">可為 Null 類型的 '{0}' 會檢查是否為 Null，若為 Null，則會擲回。</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_NullCheckingOnNullableType_Title">
         <source>Nullable type is null-checked and will throw if null.</source>
-        <target state="new">Nullable type is null-checked and will throw if null.</target>
+        <target state="translated">可為 Null 的類型會檢查是否為 Null，若為 Null，則會擲回。</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterNotNullIfNotNull">
@@ -1574,7 +1574,7 @@
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter">
         <source>Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</source>
-        <target state="new">Parameter '{0}' occurs after '{1}' in the parameter list, but is used as an argument for interpolated string handler conversions. This will require the caller to reorder parameters with named arguments at the call site. Consider putting the interpolated string handler parameter after all arguments involved.</target>
+        <target state="translated">參數 {0} 發生在參數清單中 {1} 之後，但卻用為差補字串處理常式轉換的引數。這會要求呼叫者在呼叫網站使用具名引數重新排列參數。請考慮將差補字串處理常式參數置於所有相關的引數後面。</target>
         <note />
       </trans-unit>
       <trans-unit id="WRN_ParameterOccursAfterInterpolatedStringHandlerParameter_Title">
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.tr.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.tr.xlf
index 6d6398cd05899..0fb46e1e726b6 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.tr.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.tr.xlf
@@ -256,12 +256,12 @@
       </trans-unit>
       <trans-unit id="InMemoryAssembly">
         <source>&lt;in-memory assembly&gt;</source>
-        <target state="translated">&lt; bellek içi derleme &gt;</target>
+        <target state="translated">&lt;bellek içi derleme&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="InMemoryModule">
         <source>&lt;in-memory module&gt;</source>
-        <target state="translated">&lt; bellek modülü &gt;</target>
+        <target state="translated">&lt;bellek modülü&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="SizeHasToBePositive">
diff --git a/src/Compilers/VisualBasic/Portable/xlf/VBResources.cs.xlf b/src/Compilers/VisualBasic/Portable/xlf/VBResources.cs.xlf
index 629d5c1977535..74dbe4cd9e5b2 100644
--- a/src/Compilers/VisualBasic/Portable/xlf/VBResources.cs.xlf
+++ b/src/Compilers/VisualBasic/Portable/xlf/VBResources.cs.xlf
@@ -3992,7 +3992,7 @@
       </trans-unit>
       <trans-unit id="ERR_ExpectedXmlEndCData">
         <source>Expected closing ']]&gt;' for XML CDATA section.</source>
-        <target state="translated">Očekávalo se ukončení oddílu CDATA kódu XML znaky ]]&gt;.</target>
+        <target state="translated">Očekávalo se ukončení oddílu CDATA kódu XML znaky ']]&gt;'.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ExpectedSQuote">
@@ -4007,7 +4007,7 @@
       </trans-unit>
       <trans-unit id="ERR_ExpectedLT">
         <source>Expected beginning '&lt;' for an XML tag.</source>
-        <target state="translated">Očekával se úvodní znak &lt; značky XML.</target>
+        <target state="translated">Očekával se úvodní znak '&lt;' značky XML.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_StartAttributeValue">
@@ -7395,7 +7395,7 @@
       </trans-unit>
       <trans-unit id="ERR_XmlEndCDataNotAllowedInContent">
         <source>The literal string ']]&gt;' is not allowed in element content.</source>
-        <target state="translated">V obsahu elementu není povolený řetězec literálu ]]&gt;.</target>
+        <target state="translated">V obsahu elementu není povolený řetězec literálu ']]&gt;'.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_OverloadsModifierInModule">

From b72b227b82fd15deefa8165aa6dbb3c24c890042 Mon Sep 17 00:00:00 2001
From: dotnet bot <dotnet-bot@dotnetfoundation.org>
Date: Fri, 7 Jan 2022 12:03:22 -0800
Subject: [PATCH 277/444] Localized file check-in by OneLocBuild Task: Build
 definition ID 327: Build ID 1541625

---
 .../Portable/xlf/VBResources.fr.xlf           |  4 +-
 .../Portable/xlf/VBResources.pt-BR.xlf        |  2 +-
 .../Portable/xlf/VBResources.tr.xlf           |  4 +-
 .../Core/xlf/EditorFeaturesResources.cs.xlf   | 12 +--
 .../Core/xlf/EditorFeaturesResources.de.xlf   | 12 +--
 .../Core/xlf/EditorFeaturesResources.es.xlf   | 12 +--
 .../Core/xlf/EditorFeaturesResources.fr.xlf   | 12 +--
 .../Core/xlf/EditorFeaturesResources.it.xlf   | 12 +--
 .../Core/xlf/EditorFeaturesResources.ja.xlf   | 12 +--
 .../Core/xlf/EditorFeaturesResources.ko.xlf   | 12 +--
 .../Core/xlf/EditorFeaturesResources.pl.xlf   | 12 +--
 .../xlf/EditorFeaturesResources.pt-BR.xlf     | 12 +--
 .../Core/xlf/EditorFeaturesResources.ru.xlf   | 12 +--
 .../Core/xlf/EditorFeaturesResources.tr.xlf   | 12 +--
 .../xlf/EditorFeaturesResources.zh-Hans.xlf   | 12 +--
 .../xlf/EditorFeaturesResources.zh-Hant.xlf   | 12 +--
 .../Portable/xlf/FeaturesResources.cs.xlf     | 86 +++++++++---------
 .../Portable/xlf/FeaturesResources.de.xlf     | 86 +++++++++---------
 .../Portable/xlf/FeaturesResources.es.xlf     | 88 +++++++++----------
 .../Portable/xlf/FeaturesResources.fr.xlf     | 86 +++++++++---------
 .../Portable/xlf/FeaturesResources.it.xlf     | 86 +++++++++---------
 .../Portable/xlf/FeaturesResources.ja.xlf     | 86 +++++++++---------
 .../Portable/xlf/FeaturesResources.ko.xlf     | 86 +++++++++---------
 .../Portable/xlf/FeaturesResources.pl.xlf     | 86 +++++++++---------
 .../Portable/xlf/FeaturesResources.pt-BR.xlf  | 86 +++++++++---------
 .../Portable/xlf/FeaturesResources.ru.xlf     | 86 +++++++++---------
 26 files changed, 514 insertions(+), 514 deletions(-)

diff --git a/src/Compilers/VisualBasic/Portable/xlf/VBResources.fr.xlf b/src/Compilers/VisualBasic/Portable/xlf/VBResources.fr.xlf
index 6d7ee262248fe..aa9b5800ad529 100644
--- a/src/Compilers/VisualBasic/Portable/xlf/VBResources.fr.xlf
+++ b/src/Compilers/VisualBasic/Portable/xlf/VBResources.fr.xlf
@@ -3992,7 +3992,7 @@
       </trans-unit>
       <trans-unit id="ERR_ExpectedXmlEndCData">
         <source>Expected closing ']]&gt;' for XML CDATA section.</source>
-        <target state="translated">]]&gt;' fermant attendu pour une section CDATA XML.</target>
+        <target state="translated">']]&gt;' fermant attendu pour une section CDATA XML.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ExpectedSQuote">
@@ -4007,7 +4007,7 @@
       </trans-unit>
       <trans-unit id="ERR_ExpectedLT">
         <source>Expected beginning '&lt;' for an XML tag.</source>
-        <target state="translated">&lt;' ouvrant attendu pour une balise XML.</target>
+        <target state="translated">'&lt;' ouvrant attendu pour une balise XML.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_StartAttributeValue">
diff --git a/src/Compilers/VisualBasic/Portable/xlf/VBResources.pt-BR.xlf b/src/Compilers/VisualBasic/Portable/xlf/VBResources.pt-BR.xlf
index f566a2211eb7f..206d8737e4cb4 100644
--- a/src/Compilers/VisualBasic/Portable/xlf/VBResources.pt-BR.xlf
+++ b/src/Compilers/VisualBasic/Portable/xlf/VBResources.pt-BR.xlf
@@ -3992,7 +3992,7 @@
       </trans-unit>
       <trans-unit id="ERR_ExpectedXmlEndCData">
         <source>Expected closing ']]&gt;' for XML CDATA section.</source>
-        <target state="translated">]]&gt;' de fechamento esperado para seção XML CDATA.</target>
+        <target state="translated">']]&gt;' de fechamento esperado para seção XML CDATA.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_ExpectedSQuote">
diff --git a/src/Compilers/VisualBasic/Portable/xlf/VBResources.tr.xlf b/src/Compilers/VisualBasic/Portable/xlf/VBResources.tr.xlf
index 5c401a33f945e..e6bbcbc2efa53 100644
--- a/src/Compilers/VisualBasic/Portable/xlf/VBResources.tr.xlf
+++ b/src/Compilers/VisualBasic/Portable/xlf/VBResources.tr.xlf
@@ -5119,7 +5119,7 @@
       </trans-unit>
       <trans-unit id="ERR_UnknownOperator">
         <source>Operator declaration must be one of:  +, -, *, \, /, ^, &amp;, Like, Mod, And, Or, Xor, Not, &lt;&lt;, &gt;&gt;, =, &lt;&gt;, &lt;, &lt;=, &gt;, &gt;=, CType, IsTrue, IsFalse.</source>
-        <target state="translated">İşleç bildirimi şunlardan biri olmalıdır: +, -, *, \, /, ^, &amp;, Like, Mod, And, Or, Xor, Not, &lt;&lt;, &gt;&gt;, =, &lt;&gt;, &lt;, &lt;=, &gt;, &gt;=, CType, IsTrue, IsFalse.</target>
+        <target state="translated">İşleç bildirimi şunlardan biri olmalıdır: +, -, *, \, /, ^, &amp;, Like, Mod, And, Or, Xor, Not, &lt;&lt;,&gt;&gt;, =, &lt;&gt;, &lt;, &lt;=,&gt;,&gt;=, CType, IsTrue, IsFalse.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_DuplicateConversionCategoryUsed">
@@ -5129,7 +5129,7 @@
       </trans-unit>
       <trans-unit id="ERR_OperatorNotOverloadable">
         <source>Operator is not overloadable. Operator declaration must be one of:  +, -, *, \, /, ^, &amp;, Like, Mod, And, Or, Xor, Not, &lt;&lt;, &gt;&gt;, =, &lt;&gt;, &lt;, &lt;=, &gt;, &gt;=, CType, IsTrue, IsFalse.</source>
-        <target state="translated">İşleç aşırı yüklenebilir değil. İşleç bildirimi şunlardan biri olmalıdır: +, -, *, \, /, ^, &amp;, Like, Mod, And, Or, Xor, Not, &lt;&lt;, &gt;&gt;, =, &lt;&gt;, &lt;, &lt;=, &gt;, &gt;=, CType, IsTrue, IsFalse.</target>
+        <target state="translated">İşleç aşırı yüklenebilir değil. İşleç bildirimi şunlardan biri olmalıdır: +, -, *, \, /, ^, &amp;, Like, Mod, And, Or, Xor, Not, &lt;&lt;,&gt;&gt;, =, &lt;&gt;, &lt;, &lt;=,&gt;,&gt;=, CType, IsTrue, IsFalse.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_InvalidHandles">
diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.cs.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.cs.xlf
index b55de38bbb9d5..79f8eb44fde8c 100644
--- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.cs.xlf
+++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.cs.xlf
@@ -44,7 +44,7 @@
       </trans-unit>
       <trans-unit id="Execute_Suggested_Action">
         <source>Execute Suggested Action</source>
-        <target state="new">Execute Suggested Action</target>
+        <target state="translated">Provést navrhovanou akci</target>
         <note />
       </trans-unit>
       <trans-unit id="Expander_display_text">
@@ -119,17 +119,17 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Error">
         <source>Inline Diagnostics - Error</source>
-        <target state="new">Inline Diagnostics - Error</target>
+        <target state="translated">Vložená diagnostika – Chyba</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Rude_Edit">
         <source>Inline Diagnostics - Rude Edit</source>
-        <target state="new">Inline Diagnostics - Rude Edit</target>
+        <target state="translated">Vložená diagnostika – Hrubá úprava</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Warning">
         <source>Inline Diagnostics - Warning</source>
-        <target state="new">Inline Diagnostics - Warning</target>
+        <target state="translated">Vložená diagnostika – Upozornění</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -159,7 +159,7 @@
       </trans-unit>
       <trans-unit id="Language_client_initialization_failed">
         <source>{0} failed to initialize. Status = {1}. Exception = {2}</source>
-        <target state="new">{0} failed to initialize. Status = {1}. Exception = {2}</target>
+        <target state="translated">Inicializace {0} se nepodařila. Stav = {1}. Výjimka = {2}</target>
         <note>{0} is the language server name.  Status is the status of the initialization.  Exception is the exception encountered during initialization.</note>
       </trans-unit>
       <trans-unit id="Locating_bases">
@@ -269,7 +269,7 @@
       </trans-unit>
       <trans-unit id="The_results_may_be_incomplete_due_to_the_solution_still_loading_projects">
         <source>The results may be incomplete due to the solution still loading projects.</source>
-        <target state="new">The results may be incomplete due to the solution still loading projects.</target>
+        <target state="translated">Výsledky mohou být neúplné, protože řešení stále načítá projekty.</target>
         <note />
       </trans-unit>
       <trans-unit id="The_symbol_has_no_base">
diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.de.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.de.xlf
index e926155e837aa..348967208ed37 100644
--- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.de.xlf
+++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.de.xlf
@@ -44,7 +44,7 @@
       </trans-unit>
       <trans-unit id="Execute_Suggested_Action">
         <source>Execute Suggested Action</source>
-        <target state="new">Execute Suggested Action</target>
+        <target state="translated">Vorgeschlagene Aktion ausführen</target>
         <note />
       </trans-unit>
       <trans-unit id="Expander_display_text">
@@ -119,17 +119,17 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Error">
         <source>Inline Diagnostics - Error</source>
-        <target state="new">Inline Diagnostics - Error</target>
+        <target state="translated">Inline-Diagnose – Fehler</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Rude_Edit">
         <source>Inline Diagnostics - Rude Edit</source>
-        <target state="new">Inline Diagnostics - Rude Edit</target>
+        <target state="translated">Inlinediagnose – NIcht unterstützte Bearbeitung</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Warning">
         <source>Inline Diagnostics - Warning</source>
-        <target state="new">Inline Diagnostics - Warning</target>
+        <target state="translated">Inline-Diagnose – Warnung</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -159,7 +159,7 @@
       </trans-unit>
       <trans-unit id="Language_client_initialization_failed">
         <source>{0} failed to initialize. Status = {1}. Exception = {2}</source>
-        <target state="new">{0} failed to initialize. Status = {1}. Exception = {2}</target>
+        <target state="translated">{0} konnte nicht initialisiert werden. Status = {1}. Ausnahme = {2}</target>
         <note>{0} is the language server name.  Status is the status of the initialization.  Exception is the exception encountered during initialization.</note>
       </trans-unit>
       <trans-unit id="Locating_bases">
@@ -269,7 +269,7 @@
       </trans-unit>
       <trans-unit id="The_results_may_be_incomplete_due_to_the_solution_still_loading_projects">
         <source>The results may be incomplete due to the solution still loading projects.</source>
-        <target state="new">The results may be incomplete due to the solution still loading projects.</target>
+        <target state="translated">Die Ergebnisse sind möglicherweise unvollständig, da die Projektmappe noch Projekte lädt.</target>
         <note />
       </trans-unit>
       <trans-unit id="The_symbol_has_no_base">
diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.es.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.es.xlf
index 859fbe8d25002..3b22bba522e45 100644
--- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.es.xlf
+++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.es.xlf
@@ -44,7 +44,7 @@
       </trans-unit>
       <trans-unit id="Execute_Suggested_Action">
         <source>Execute Suggested Action</source>
-        <target state="new">Execute Suggested Action</target>
+        <target state="translated">Ejecutar acción recomendada</target>
         <note />
       </trans-unit>
       <trans-unit id="Expander_display_text">
@@ -119,17 +119,17 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Error">
         <source>Inline Diagnostics - Error</source>
-        <target state="new">Inline Diagnostics - Error</target>
+        <target state="translated">Diagnósticos integrados: error</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Rude_Edit">
         <source>Inline Diagnostics - Rude Edit</source>
-        <target state="new">Inline Diagnostics - Rude Edit</target>
+        <target state="translated">Diagnósticos integrados: edición superficial</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Warning">
         <source>Inline Diagnostics - Warning</source>
-        <target state="new">Inline Diagnostics - Warning</target>
+        <target state="translated">Diagnóstico integrado: advertencia</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -159,7 +159,7 @@
       </trans-unit>
       <trans-unit id="Language_client_initialization_failed">
         <source>{0} failed to initialize. Status = {1}. Exception = {2}</source>
-        <target state="new">{0} failed to initialize. Status = {1}. Exception = {2}</target>
+        <target state="translated">No se pudo inicializar {0}. Estado = {1}. Excepción = {2}</target>
         <note>{0} is the language server name.  Status is the status of the initialization.  Exception is the exception encountered during initialization.</note>
       </trans-unit>
       <trans-unit id="Locating_bases">
@@ -269,7 +269,7 @@
       </trans-unit>
       <trans-unit id="The_results_may_be_incomplete_due_to_the_solution_still_loading_projects">
         <source>The results may be incomplete due to the solution still loading projects.</source>
-        <target state="new">The results may be incomplete due to the solution still loading projects.</target>
+        <target state="translated">Los resultados pueden estar incompletos porque la solución aún está cargando proyectos.</target>
         <note />
       </trans-unit>
       <trans-unit id="The_symbol_has_no_base">
diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.fr.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.fr.xlf
index d043127c5d95d..777f9725bfb00 100644
--- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.fr.xlf
+++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.fr.xlf
@@ -44,7 +44,7 @@
       </trans-unit>
       <trans-unit id="Execute_Suggested_Action">
         <source>Execute Suggested Action</source>
-        <target state="new">Execute Suggested Action</target>
+        <target state="translated">Exécuter l'action suggérée</target>
         <note />
       </trans-unit>
       <trans-unit id="Expander_display_text">
@@ -119,17 +119,17 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Error">
         <source>Inline Diagnostics - Error</source>
-        <target state="new">Inline Diagnostics - Error</target>
+        <target state="translated">Diagnostics en ligne – Erreur</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Rude_Edit">
         <source>Inline Diagnostics - Rude Edit</source>
-        <target state="new">Inline Diagnostics - Rude Edit</target>
+        <target state="translated">Diagnostics en ligne – Modification grossière</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Warning">
         <source>Inline Diagnostics - Warning</source>
-        <target state="new">Inline Diagnostics - Warning</target>
+        <target state="translated">Diagnostics en ligne – Avertissement</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -159,7 +159,7 @@
       </trans-unit>
       <trans-unit id="Language_client_initialization_failed">
         <source>{0} failed to initialize. Status = {1}. Exception = {2}</source>
-        <target state="new">{0} failed to initialize. Status = {1}. Exception = {2}</target>
+        <target state="translated">{0} n’a pas pu s’initialiser. État = {1}. Exception = {2}</target>
         <note>{0} is the language server name.  Status is the status of the initialization.  Exception is the exception encountered during initialization.</note>
       </trans-unit>
       <trans-unit id="Locating_bases">
@@ -269,7 +269,7 @@
       </trans-unit>
       <trans-unit id="The_results_may_be_incomplete_due_to_the_solution_still_loading_projects">
         <source>The results may be incomplete due to the solution still loading projects.</source>
-        <target state="new">The results may be incomplete due to the solution still loading projects.</target>
+        <target state="translated">Les résultats sont peut-être incomplets, car la solution est toujours en train de charger des projets.</target>
         <note />
       </trans-unit>
       <trans-unit id="The_symbol_has_no_base">
diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.it.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.it.xlf
index 1e6ea2c35ebc7..ac1778cf4da9f 100644
--- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.it.xlf
+++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.it.xlf
@@ -44,7 +44,7 @@
       </trans-unit>
       <trans-unit id="Execute_Suggested_Action">
         <source>Execute Suggested Action</source>
-        <target state="new">Execute Suggested Action</target>
+        <target state="translated">Esegui azione suggerita</target>
         <note />
       </trans-unit>
       <trans-unit id="Expander_display_text">
@@ -119,17 +119,17 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Error">
         <source>Inline Diagnostics - Error</source>
-        <target state="new">Inline Diagnostics - Error</target>
+        <target state="translated">Diagnostica inline - Errore</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Rude_Edit">
         <source>Inline Diagnostics - Rude Edit</source>
-        <target state="new">Inline Diagnostics - Rude Edit</target>
+        <target state="translated">Diagnostica inline - Modifica non applicabile</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Warning">
         <source>Inline Diagnostics - Warning</source>
-        <target state="new">Inline Diagnostics - Warning</target>
+        <target state="translated">Diagnostica inline - Avviso</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -159,7 +159,7 @@
       </trans-unit>
       <trans-unit id="Language_client_initialization_failed">
         <source>{0} failed to initialize. Status = {1}. Exception = {2}</source>
-        <target state="new">{0} failed to initialize. Status = {1}. Exception = {2}</target>
+        <target state="translated">Non è stato possibile inizializzare {0}. Stato = {1}. Eccezione = {2}</target>
         <note>{0} is the language server name.  Status is the status of the initialization.  Exception is the exception encountered during initialization.</note>
       </trans-unit>
       <trans-unit id="Locating_bases">
@@ -269,7 +269,7 @@
       </trans-unit>
       <trans-unit id="The_results_may_be_incomplete_due_to_the_solution_still_loading_projects">
         <source>The results may be incomplete due to the solution still loading projects.</source>
-        <target state="new">The results may be incomplete due to the solution still loading projects.</target>
+        <target state="translated">I risultati potrebbero essere incompleti perché la soluzione ancora carica i progetti.</target>
         <note />
       </trans-unit>
       <trans-unit id="The_symbol_has_no_base">
diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ja.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ja.xlf
index 4de85135e04b2..be6922c51846d 100644
--- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ja.xlf
+++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ja.xlf
@@ -44,7 +44,7 @@
       </trans-unit>
       <trans-unit id="Execute_Suggested_Action">
         <source>Execute Suggested Action</source>
-        <target state="new">Execute Suggested Action</target>
+        <target state="translated">おすすめのアクションを実行する</target>
         <note />
       </trans-unit>
       <trans-unit id="Expander_display_text">
@@ -119,17 +119,17 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Error">
         <source>Inline Diagnostics - Error</source>
-        <target state="new">Inline Diagnostics - Error</target>
+        <target state="translated">インライン診断 - エラー</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Rude_Edit">
         <source>Inline Diagnostics - Rude Edit</source>
-        <target state="new">Inline Diagnostics - Rude Edit</target>
+        <target state="translated">インライン診断 - Rude Edit</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Warning">
         <source>Inline Diagnostics - Warning</source>
-        <target state="new">Inline Diagnostics - Warning</target>
+        <target state="translated">インライン診断 - 警告</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -159,7 +159,7 @@
       </trans-unit>
       <trans-unit id="Language_client_initialization_failed">
         <source>{0} failed to initialize. Status = {1}. Exception = {2}</source>
-        <target state="new">{0} failed to initialize. Status = {1}. Exception = {2}</target>
+        <target state="translated">{0} を初期化できませんでした。状態 = {1}。例外 = {2}</target>
         <note>{0} is the language server name.  Status is the status of the initialization.  Exception is the exception encountered during initialization.</note>
       </trans-unit>
       <trans-unit id="Locating_bases">
@@ -269,7 +269,7 @@
       </trans-unit>
       <trans-unit id="The_results_may_be_incomplete_due_to_the_solution_still_loading_projects">
         <source>The results may be incomplete due to the solution still loading projects.</source>
-        <target state="new">The results may be incomplete due to the solution still loading projects.</target>
+        <target state="translated">ソリューションでプロジェクトを読み込み中であるため、結果は不完全になる可能性があります。</target>
         <note />
       </trans-unit>
       <trans-unit id="The_symbol_has_no_base">
diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ko.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ko.xlf
index 8d3ef95735b22..6dab354d27f5b 100644
--- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ko.xlf
+++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ko.xlf
@@ -44,7 +44,7 @@
       </trans-unit>
       <trans-unit id="Execute_Suggested_Action">
         <source>Execute Suggested Action</source>
-        <target state="new">Execute Suggested Action</target>
+        <target state="translated">제안된 작업 실행</target>
         <note />
       </trans-unit>
       <trans-unit id="Expander_display_text">
@@ -119,17 +119,17 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Error">
         <source>Inline Diagnostics - Error</source>
-        <target state="new">Inline Diagnostics - Error</target>
+        <target state="translated">인라인 진단 - 오류</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Rude_Edit">
         <source>Inline Diagnostics - Rude Edit</source>
-        <target state="new">Inline Diagnostics - Rude Edit</target>
+        <target state="translated">인라인 진단 - Rude 편집</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Warning">
         <source>Inline Diagnostics - Warning</source>
-        <target state="new">Inline Diagnostics - Warning</target>
+        <target state="translated">인라인 진단 - 경고</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -159,7 +159,7 @@
       </trans-unit>
       <trans-unit id="Language_client_initialization_failed">
         <source>{0} failed to initialize. Status = {1}. Exception = {2}</source>
-        <target state="new">{0} failed to initialize. Status = {1}. Exception = {2}</target>
+        <target state="translated">{0}을(를) 초기화하지 못했습니다. 상태 = {1}. 예외 = {2}</target>
         <note>{0} is the language server name.  Status is the status of the initialization.  Exception is the exception encountered during initialization.</note>
       </trans-unit>
       <trans-unit id="Locating_bases">
@@ -269,7 +269,7 @@
       </trans-unit>
       <trans-unit id="The_results_may_be_incomplete_due_to_the_solution_still_loading_projects">
         <source>The results may be incomplete due to the solution still loading projects.</source>
-        <target state="new">The results may be incomplete due to the solution still loading projects.</target>
+        <target state="translated">솔루션이 아직 프로젝트를 로드하는 중이므로 결과가 불완전할 수 있습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="The_symbol_has_no_base">
diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.pl.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.pl.xlf
index c0b02d84f796e..31063335e563e 100644
--- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.pl.xlf
+++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.pl.xlf
@@ -44,7 +44,7 @@
       </trans-unit>
       <trans-unit id="Execute_Suggested_Action">
         <source>Execute Suggested Action</source>
-        <target state="new">Execute Suggested Action</target>
+        <target state="translated">Wykonaj sugerowaną akcję</target>
         <note />
       </trans-unit>
       <trans-unit id="Expander_display_text">
@@ -119,17 +119,17 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Error">
         <source>Inline Diagnostics - Error</source>
-        <target state="new">Inline Diagnostics - Error</target>
+        <target state="translated">Diagnostyka w tekście — błąd</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Rude_Edit">
         <source>Inline Diagnostics - Rude Edit</source>
-        <target state="new">Inline Diagnostics - Rude Edit</target>
+        <target state="translated">Diagnostyka w tekście — edycja nagła</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Warning">
         <source>Inline Diagnostics - Warning</source>
-        <target state="new">Inline Diagnostics - Warning</target>
+        <target state="translated">Diagnostyka w tekście — ostrzeżenie</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -159,7 +159,7 @@
       </trans-unit>
       <trans-unit id="Language_client_initialization_failed">
         <source>{0} failed to initialize. Status = {1}. Exception = {2}</source>
-        <target state="new">{0} failed to initialize. Status = {1}. Exception = {2}</target>
+        <target state="translated">Zainicjowanie języka {0} zakończyło się niepowodzeniem. Stan = {1}. Wyjątek = {2}</target>
         <note>{0} is the language server name.  Status is the status of the initialization.  Exception is the exception encountered during initialization.</note>
       </trans-unit>
       <trans-unit id="Locating_bases">
@@ -269,7 +269,7 @@
       </trans-unit>
       <trans-unit id="The_results_may_be_incomplete_due_to_the_solution_still_loading_projects">
         <source>The results may be incomplete due to the solution still loading projects.</source>
-        <target state="new">The results may be incomplete due to the solution still loading projects.</target>
+        <target state="translated">Wyniki mogą być niekompletne, ponieważ rozwiązanie nadal ładuje projekty.</target>
         <note />
       </trans-unit>
       <trans-unit id="The_symbol_has_no_base">
diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.pt-BR.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.pt-BR.xlf
index ca25dc5627759..731d833582e99 100644
--- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.pt-BR.xlf
+++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.pt-BR.xlf
@@ -44,7 +44,7 @@
       </trans-unit>
       <trans-unit id="Execute_Suggested_Action">
         <source>Execute Suggested Action</source>
-        <target state="new">Execute Suggested Action</target>
+        <target state="translated">Executar a Ação Sugerida</target>
         <note />
       </trans-unit>
       <trans-unit id="Expander_display_text">
@@ -119,17 +119,17 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Error">
         <source>Inline Diagnostics - Error</source>
-        <target state="new">Inline Diagnostics - Error</target>
+        <target state="translated">Diagnóstico em linha - Erro</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Rude_Edit">
         <source>Inline Diagnostics - Rude Edit</source>
-        <target state="new">Inline Diagnostics - Rude Edit</target>
+        <target state="translated">Diagnóstico em linha - Edição Rudimentar</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Warning">
         <source>Inline Diagnostics - Warning</source>
-        <target state="new">Inline Diagnostics - Warning</target>
+        <target state="translated">Diagnóstico em linha - Aviso</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -159,7 +159,7 @@
       </trans-unit>
       <trans-unit id="Language_client_initialization_failed">
         <source>{0} failed to initialize. Status = {1}. Exception = {2}</source>
-        <target state="new">{0} failed to initialize. Status = {1}. Exception = {2}</target>
+        <target state="translated">{0} falhou ao inicializar. Status = {1}. Exceção = {2}</target>
         <note>{0} is the language server name.  Status is the status of the initialization.  Exception is the exception encountered during initialization.</note>
       </trans-unit>
       <trans-unit id="Locating_bases">
@@ -269,7 +269,7 @@
       </trans-unit>
       <trans-unit id="The_results_may_be_incomplete_due_to_the_solution_still_loading_projects">
         <source>The results may be incomplete due to the solution still loading projects.</source>
-        <target state="new">The results may be incomplete due to the solution still loading projects.</target>
+        <target state="translated">Os resultados podem estar incompletos porque a solução ainda está carregando projetos.</target>
         <note />
       </trans-unit>
       <trans-unit id="The_symbol_has_no_base">
diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ru.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ru.xlf
index 8c401b366167b..babcf45cc47fa 100644
--- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ru.xlf
+++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.ru.xlf
@@ -44,7 +44,7 @@
       </trans-unit>
       <trans-unit id="Execute_Suggested_Action">
         <source>Execute Suggested Action</source>
-        <target state="new">Execute Suggested Action</target>
+        <target state="translated">Выполнить предложенное действие</target>
         <note />
       </trans-unit>
       <trans-unit id="Expander_display_text">
@@ -119,17 +119,17 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Error">
         <source>Inline Diagnostics - Error</source>
-        <target state="new">Inline Diagnostics - Error</target>
+        <target state="translated">Встроенная диагностика — ошибка</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Rude_Edit">
         <source>Inline Diagnostics - Rude Edit</source>
-        <target state="new">Inline Diagnostics - Rude Edit</target>
+        <target state="translated">Встроенная диагностика — грубое редактирование</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Warning">
         <source>Inline Diagnostics - Warning</source>
-        <target state="new">Inline Diagnostics - Warning</target>
+        <target state="translated">Встроенная диагностика — предупреждение</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -159,7 +159,7 @@
       </trans-unit>
       <trans-unit id="Language_client_initialization_failed">
         <source>{0} failed to initialize. Status = {1}. Exception = {2}</source>
-        <target state="new">{0} failed to initialize. Status = {1}. Exception = {2}</target>
+        <target state="translated">Не удалось инициализировать {0}. Состояние = {1}. Исключение = {2}</target>
         <note>{0} is the language server name.  Status is the status of the initialization.  Exception is the exception encountered during initialization.</note>
       </trans-unit>
       <trans-unit id="Locating_bases">
@@ -269,7 +269,7 @@
       </trans-unit>
       <trans-unit id="The_results_may_be_incomplete_due_to_the_solution_still_loading_projects">
         <source>The results may be incomplete due to the solution still loading projects.</source>
-        <target state="new">The results may be incomplete due to the solution still loading projects.</target>
+        <target state="translated">Результаты могут быть неполными, поскольку решение еще загружает проекты.</target>
         <note />
       </trans-unit>
       <trans-unit id="The_symbol_has_no_base">
diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.tr.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.tr.xlf
index e898ae599474d..8fdce2e6b39f8 100644
--- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.tr.xlf
+++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.tr.xlf
@@ -44,7 +44,7 @@
       </trans-unit>
       <trans-unit id="Execute_Suggested_Action">
         <source>Execute Suggested Action</source>
-        <target state="new">Execute Suggested Action</target>
+        <target state="translated">Önerilen Eylemi Yürüt</target>
         <note />
       </trans-unit>
       <trans-unit id="Expander_display_text">
@@ -119,17 +119,17 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Error">
         <source>Inline Diagnostics - Error</source>
-        <target state="new">Inline Diagnostics - Error</target>
+        <target state="translated">Satır İçi Tanılama - Hata</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Rude_Edit">
         <source>Inline Diagnostics - Rude Edit</source>
-        <target state="new">Inline Diagnostics - Rude Edit</target>
+        <target state="translated">Satır İçi Tanılama - İşlenmemiş Düzenleme</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Warning">
         <source>Inline Diagnostics - Warning</source>
-        <target state="new">Inline Diagnostics - Warning</target>
+        <target state="translated">Satır İçi Tanılama - Uyarı</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -159,7 +159,7 @@
       </trans-unit>
       <trans-unit id="Language_client_initialization_failed">
         <source>{0} failed to initialize. Status = {1}. Exception = {2}</source>
-        <target state="new">{0} failed to initialize. Status = {1}. Exception = {2}</target>
+        <target state="translated">{0} başlatılamadı. Durum = {1}. Özel durum = {2}</target>
         <note>{0} is the language server name.  Status is the status of the initialization.  Exception is the exception encountered during initialization.</note>
       </trans-unit>
       <trans-unit id="Locating_bases">
@@ -269,7 +269,7 @@
       </trans-unit>
       <trans-unit id="The_results_may_be_incomplete_due_to_the_solution_still_loading_projects">
         <source>The results may be incomplete due to the solution still loading projects.</source>
-        <target state="new">The results may be incomplete due to the solution still loading projects.</target>
+        <target state="translated">Çözüm projeleri hala yüklemediğinden sonuçlar tamamlanmamış olabilir.</target>
         <note />
       </trans-unit>
       <trans-unit id="The_symbol_has_no_base">
diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.zh-Hans.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.zh-Hans.xlf
index 3733a9f97d464..36d9b80f798f2 100644
--- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.zh-Hans.xlf
+++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.zh-Hans.xlf
@@ -44,7 +44,7 @@
       </trans-unit>
       <trans-unit id="Execute_Suggested_Action">
         <source>Execute Suggested Action</source>
-        <target state="new">Execute Suggested Action</target>
+        <target state="translated">执行建议的操作</target>
         <note />
       </trans-unit>
       <trans-unit id="Expander_display_text">
@@ -119,17 +119,17 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Error">
         <source>Inline Diagnostics - Error</source>
-        <target state="new">Inline Diagnostics - Error</target>
+        <target state="translated">内联诊断 - 错误</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Rude_Edit">
         <source>Inline Diagnostics - Rude Edit</source>
-        <target state="new">Inline Diagnostics - Rude Edit</target>
+        <target state="translated">内联诊断 - 原始编辑</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Warning">
         <source>Inline Diagnostics - Warning</source>
-        <target state="new">Inline Diagnostics - Warning</target>
+        <target state="translated">内联诊断 - 警告</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -159,7 +159,7 @@
       </trans-unit>
       <trans-unit id="Language_client_initialization_failed">
         <source>{0} failed to initialize. Status = {1}. Exception = {2}</source>
-        <target state="new">{0} failed to initialize. Status = {1}. Exception = {2}</target>
+        <target state="translated">无法初始化 {0}。状态 = {1}。异常 = {2}</target>
         <note>{0} is the language server name.  Status is the status of the initialization.  Exception is the exception encountered during initialization.</note>
       </trans-unit>
       <trans-unit id="Locating_bases">
@@ -269,7 +269,7 @@
       </trans-unit>
       <trans-unit id="The_results_may_be_incomplete_due_to_the_solution_still_loading_projects">
         <source>The results may be incomplete due to the solution still loading projects.</source>
-        <target state="new">The results may be incomplete due to the solution still loading projects.</target>
+        <target state="translated">由于解决方案仍在加载项目，结果可能不完整。</target>
         <note />
       </trans-unit>
       <trans-unit id="The_symbol_has_no_base">
diff --git a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.zh-Hant.xlf b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.zh-Hant.xlf
index 74974444712cc..63c30658352eb 100644
--- a/src/EditorFeatures/Core/xlf/EditorFeaturesResources.zh-Hant.xlf
+++ b/src/EditorFeatures/Core/xlf/EditorFeaturesResources.zh-Hant.xlf
@@ -44,7 +44,7 @@
       </trans-unit>
       <trans-unit id="Execute_Suggested_Action">
         <source>Execute Suggested Action</source>
-        <target state="new">Execute Suggested Action</target>
+        <target state="translated">執行建議動作</target>
         <note />
       </trans-unit>
       <trans-unit id="Expander_display_text">
@@ -119,17 +119,17 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Error">
         <source>Inline Diagnostics - Error</source>
-        <target state="new">Inline Diagnostics - Error</target>
+        <target state="translated">內嵌診斷 - 錯誤</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Rude_Edit">
         <source>Inline Diagnostics - Rude Edit</source>
-        <target state="new">Inline Diagnostics - Rude Edit</target>
+        <target state="translated">內嵌診斷 - 粗略編輯</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_Warning">
         <source>Inline Diagnostics - Warning</source>
-        <target state="new">Inline Diagnostics - Warning</target>
+        <target state="translated">內嵌診斷 - 警告</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -159,7 +159,7 @@
       </trans-unit>
       <trans-unit id="Language_client_initialization_failed">
         <source>{0} failed to initialize. Status = {1}. Exception = {2}</source>
-        <target state="new">{0} failed to initialize. Status = {1}. Exception = {2}</target>
+        <target state="translated">{0} 無法初始化。狀態 = {1}。例外狀況 = {2}</target>
         <note>{0} is the language server name.  Status is the status of the initialization.  Exception is the exception encountered during initialization.</note>
       </trans-unit>
       <trans-unit id="Locating_bases">
@@ -269,7 +269,7 @@
       </trans-unit>
       <trans-unit id="The_results_may_be_incomplete_due_to_the_solution_still_loading_projects">
         <source>The results may be incomplete due to the solution still loading projects.</source>
-        <target state="new">The results may be incomplete due to the solution still loading projects.</target>
+        <target state="translated">結果可能不完整，因為方案仍在載入專案。</target>
         <note />
       </trans-unit>
       <trans-unit id="The_symbol_has_no_base">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf
index 078982182e196..7c1b1f08579e3 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf
@@ -242,12 +242,12 @@ Ujistěte se, že specifikátor tt použijete pro jazyky, pro které je nezbytn
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression">
         <source>Await the preceding expression</source>
-        <target state="new">Await the preceding expression</target>
+        <target state="translated">Počkat na předchozí výraz</target>
         <note />
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression_and_add_ConfigureAwait_0">
         <source>Await the preceding expression and add ConfigureAwait({0}).</source>
-        <target state="new">Await the preceding expression and add ConfigureAwait({0}).</target>
+        <target state="translated">Počkejte na předchozí výraz a přidejte ConfigureAwait({0}).</target>
         <note>{Locked="ConfigureAwait"} "ConfigureAwait" is an api name and should not be localized. {0} is a placeholder for the language specific keyword 'false'.</note>
       </trans-unit>
       <trans-unit id="Awaited_task_returns_0">
@@ -472,12 +472,12 @@ Ujistěte se, že specifikátor tt použijete pro jazyky, pro které je nezbytn
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
         <source>Could not find portable PDB on disk or embedded.</source>
-        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <target state="translated">Na disku nebo vloženém disku se nepovedlo najít přenosný soubor PDB.</target>
         <note />
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
         <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
-        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <target state="translated">Soubor PDB nelze najít na disku, vloženém nebo na serveru symbolů.</target>
         <note />
       </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
@@ -562,7 +562,7 @@ Ujistěte se, že specifikátor tt použijete pro jazyky, pro které je nezbytn
       </trans-unit>
       <trans-unit id="Error_reading_PDB_0">
         <source>Error reading PDB: '{0}'</source>
-        <target state="new">Error reading PDB: '{0}'</target>
+        <target state="translated">Chyba při čtení PDB: {0}</target>
         <note />
       </trans-unit>
       <trans-unit id="Example">
@@ -582,7 +582,7 @@ Ujistěte se, že specifikátor tt použijete pro jazyky, pro které je nezbytn
       </trans-unit>
       <trans-unit id="Explicitly_inherit_documentation">
         <source>Explicitly inherit documentation</source>
-        <target state="new">Explicitly inherit documentation</target>
+        <target state="translated">Explicitně dědit dokumentaci</target>
         <note />
       </trans-unit>
       <trans-unit id="Extract_base_class">
@@ -632,32 +632,32 @@ Ujistěte se, že specifikátor tt použijete pro jazyky, pro které je nezbytn
       </trans-unit>
       <trans-unit id="Found_PDB_file_at_0">
         <source>Found PDB file at '{0}'</source>
-        <target state="new">Found PDB file at '{0}'</target>
+        <target state="translated">V {0} se našel soubor PDB.</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server">
         <source>Found PDB on symbol server.</source>
-        <target state="new">Found PDB on symbol server.</target>
+        <target state="translated">Soubor PDB byl nalezen na serveru symbolů.</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
         <source>Found PDB on symbol server but could not read file.</source>
-        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <target state="translated">Soubor PDB se našel na serveru symbolů, ale nepovedlo se přečíst soubor.</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_embedded_PDB_file">
         <source>Found embedded PDB file.</source>
-        <target state="new">Found embedded PDB file.</target>
+        <target state="translated">Byl nalezen vložený soubor PDB.</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
-        <target state="new">Generate abstract method '{0}'</target>
+        <target state="translated">Generovat abstraktní metodu {0}</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_property_0">
         <source>Generate abstract property '{0}'</source>
-        <target state="new">Generate abstract property '{0}'</target>
+        <target state="translated">Generovat abstraktní vlastnost {0}</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_comparison_operators">
@@ -667,7 +667,7 @@ Ujistěte se, že specifikátor tt použijete pro jazyky, pro které je nezbytn
       </trans-unit>
       <trans-unit id="Generate_constant_0">
         <source>Generate constant '{0}'</source>
-        <target state="new">Generate constant '{0}'</target>
+        <target state="translated">Generovat konstantu {0}</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_constructor_in_0_with_fields">
@@ -682,12 +682,12 @@ Ujistěte se, že specifikátor tt použijete pro jazyky, pro které je nezbytn
       </trans-unit>
       <trans-unit id="Generate_enum_member_0">
         <source>Generate enum member '{0}'</source>
-        <target state="new">Generate enum member '{0}'</target>
+        <target state="translated">Generovat člena výčtu {0}</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_field_0">
         <source>Generate field '{0}'</source>
-        <target state="new">Generate field '{0}'</target>
+        <target state="translated">Generovat pole {0}</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_for_0">
@@ -697,7 +697,7 @@ Ujistěte se, že specifikátor tt použijete pro jazyky, pro které je nezbytn
       </trans-unit>
       <trans-unit id="Generate_method_0">
         <source>Generate method '{0}'</source>
-        <target state="new">Generate method '{0}'</target>
+        <target state="translated">Generovat metodu {0}</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_parameter_0">
@@ -712,17 +712,17 @@ Ujistěte se, že specifikátor tt použijete pro jazyky, pro které je nezbytn
       </trans-unit>
       <trans-unit id="Generate_property_0">
         <source>Generate property '{0}'</source>
-        <target state="new">Generate property '{0}'</target>
+        <target state="translated">Generovat vlastnost {0}</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_field_0">
         <source>Generate read-only field '{0}'</source>
-        <target state="new">Generate read-only field '{0}'</target>
+        <target state="translated">Generovat pole {0} jen pro čtení</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_property_0">
         <source>Generate read-only property '{0}'</source>
-        <target state="new">Generate read-only property '{0}'</target>
+        <target state="translated">Generovat vlastnost {0} jen pro čtení</target>
         <note />
       </trans-unit>
       <trans-unit id="Illegal_backslash_at_end_of_pattern">
@@ -947,7 +947,7 @@ Ujistěte se, že specifikátor tt použijete pro jazyky, pro které je nezbytn
       </trans-unit>
       <trans-unit id="Miscellaneous_Files">
         <source>Miscellaneous Files</source>
-        <target state="new">Miscellaneous Files</target>
+        <target state="translated">Různé soubory</target>
         <note />
       </trans-unit>
       <trans-unit id="Missing_control_character">
@@ -1057,7 +1057,7 @@ Ujistěte se, že specifikátor tt použijete pro jazyky, pro které je nezbytn
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type">
         <source>Move static members to another type...</source>
-        <target state="new">Move static members to another type...</target>
+        <target state="translated">Přesunout statické členy do jiného typu…</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -1072,7 +1072,7 @@ Ujistěte se, že specifikátor tt použijete pro jazyky, pro které je nezbytn
       </trans-unit>
       <trans-unit id="Navigating_to_symbol_0_from_1">
         <source>Navigating to symbol '{0}' from '{1}'.</source>
-        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <target state="translated">Přechází se na symbol {0} z {1}.</target>
         <note />
       </trans-unit>
       <trans-unit id="Nested_quantifier_0">
@@ -1087,7 +1087,7 @@ Ujistěte se, že specifikátor tt použijete pro jazyky, pro které je nezbytn
       </trans-unit>
       <trans-unit id="No_source_document_info_found_in_PDB">
         <source>No source document info found in PDB.</source>
-        <target state="new">No source document info found in PDB.</target>
+        <target state="translated">V souboru PDB se nenašly žádné informace o zdrojovém dokumentu.</target>
         <note />
       </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
@@ -1275,11 +1275,11 @@ Tato možnost se doporučuje, pokud víte, že zpětné vyhledávání nepovede
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
+        <target state="translated">Definice vyrovnávací skupiny odstraní definici dříve definované skupiny a uloží interval mezi dříve definovanou skupinou a aktuální skupinou do aktuální skupiny.
 
-'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+Skupina name1 je aktuální skupina (volitelná), skupina name2 je dříve definovaná skupina a subexpression je libovolný platný vzor regulárního výrazu. Definice vyrovnávací skupiny odstraní definici skupiny name2 a uloží interval mezi skupinami name2 a name1 do skupiny name1. Pokud není definována žádná skupina name2, porovnávání se vrátí zpět. Vzhledem k tomu, že odstraněním poslední definice skupiny name2 se odkryje předchozí definice skupiny name2, umožňuje tento konstruktor použít zásobník zachycení pro skupinu name2 jako čítač pro uchování přehledu o vnořených konstruktorech, jako jsou kulaté nebo hranaté otevírací a uzavírací závorky.
 
-The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
+Definice vyrovnávací skupiny používá jako zásobník skupinu name2. Počáteční znak každého vnořeného konstruktoru se umístí do této skupiny a do její kolekce Group.Captures. Po nalezení uzavíracího znaku se odpovídající otevírací znak odebere ze skupiny a kolekce Captures se zmenší o jednu položku. Po nalezení otevíracích a uzavíracích znaků všech vnořených konstruktorů bude skupina name1 prázdná.</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
@@ -2352,7 +2352,7 @@ Pozitivní kontrolní výrazy zpětného vyhledávání s nulovou délkou se obv
       </trans-unit>
       <trans-unit id="Silent">
         <source>Silent</source>
-        <target state="new">Silent</target>
+        <target state="translated">Silent</target>
         <note />
       </trans-unit>
       <trans-unit id="Sort_accessibility_modifiers">
@@ -2362,12 +2362,12 @@ Pozitivní kontrolní výrazy zpětného vyhledávání s nulovou délkou se obv
       </trans-unit>
       <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
         <source>Source code language information was not found in PDB.</source>
-        <target state="new">Source code language information was not found in PDB.</target>
+        <target state="translated">Informace o jazyku zdrojového kódu nebyly v souboru PDB nalezeny.</target>
         <note />
       </trans-unit>
       <trans-unit id="Source_is_a_reference_assembly">
         <source>Source is a reference assembly, not enough information to find PDB.</source>
-        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <target state="translated">Zdroj je referenční sestavení, nedostatek informací pro vyhledání souboru PDB.</target>
         <note />
       </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
@@ -2397,7 +2397,7 @@ Pozitivní kontrolní výrazy zpětného vyhledávání s nulovou délkou se obv
       </trans-unit>
       <trans-unit id="Symbol_found_in_assembly_path_0">
         <source>Symbol found in assembly path '{0}'</source>
-        <target state="new">Symbol found in assembly path '{0}'</target>
+        <target state="translated">V cestě sestavení {0} byl nalezen symbol.</target>
         <note />
       </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
@@ -2427,12 +2427,12 @@ Pozitivní kontrolní výrazy zpětného vyhledávání s nulovou délkou se obv
       </trans-unit>
       <trans-unit id="Timeout_SourceLink">
         <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <target state="translated">Při pokusu o stažení zdrojového kódu ze zdrojového odkazu vypršel časový limit. Následné žádosti můžou být úspěšné.</target>
         <note />
       </trans-unit>
       <trans-unit id="Timeout_symbol_server">
         <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <target state="translated">Při pokusu o stažení souboru PDB ze serveru symbolů vypršel časový limit. Následné žádosti můžou být úspěšné.</target>
         <note />
       </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
@@ -2447,7 +2447,7 @@ Pozitivní kontrolní výrazy zpětného vyhledávání s nulovou délkou se obv
       </trans-unit>
       <trans-unit id="Types_colon">
         <source>Types:</source>
-        <target state="new">Types:</target>
+        <target state="translated">Typy:</target>
         <note />
       </trans-unit>
       <trans-unit id="UnableToReadSourceFileOrPdb">
@@ -2737,42 +2737,42 @@ Pozitivní kontrolní výrazy zpětného vyhledávání s nulovou délkou se obv
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB">
         <source>'{0}' found in embedded PDB.</source>
-        <target state="new">'{0}' found in embedded PDB.</target>
+        <target state="translated">Ve vloženém souboru PDB se našel {0}.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
         <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">Ve vloženém souboru PDB byl nalezen {0}, ale kontrolní součet byl chybný nebo nešlo přečíst dočasný soubor.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
         <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
-        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <target state="translated">Ve vloženém souboru PDB se našel {0}, ale nebylo možné zapisovat do dočasného souboru: {1}</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
         <source>'{0}' found in embedded PDB and found cached source file.</source>
-        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <target state="translated">Ve vloženém souboru PDB se našel {0} a zdrojový soubor uložený v mezipaměti.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location">
         <source>'{0}' found in original location.</source>
-        <target state="new">'{0}' found in original location.</target>
+        <target state="translated">{0} se našel v původním umístění.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location_but_checksum_failed">
         <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">V původním umístění byl nalezen {0}, ale kontrolní součet byl chybný nebo nešlo přečíst dočasný soubor.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink">
         <source>'{0}' found via SourceLink.</source>
-        <target state="new">'{0}' found via SourceLink.</target>
+        <target state="translated">{0} se našel přes SourceLink.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
         <source>'{0}' found via SourceLink but couldn't read temp file.</source>
-        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <target state="translated">{0} se našel přes SourceLink, ale nepovedlo se přečíst dočasný soubor.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_is_not_null_here">
@@ -3105,12 +3105,12 @@ Pokud se specifikátor formátu d použije bez dalších specifikátorů vlastn
       </trans-unit>
       <trans-unit id="embedded">
         <source>embedded</source>
-        <target state="new">embedded</target>
+        <target state="translated">zapuštěná</target>
         <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
       </trans-unit>
       <trans-unit id="external">
         <source>external</source>
-        <target state="new">external</target>
+        <target state="translated">external</target>
         <note>External means "external source", meaning source files that are not part of the current solution</note>
       </trans-unit>
       <trans-unit id="from_metadata">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf
index 42e2d37adb679..f37fa60af4881 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf
@@ -242,12 +242,12 @@ Stellen Sie sicher, dass Sie den Bezeichner "tt" für Sprachen verwenden, für d
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression">
         <source>Await the preceding expression</source>
-        <target state="new">Await the preceding expression</target>
+        <target state="translated">Auf den vorhergehenden Ausdruck warten</target>
         <note />
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression_and_add_ConfigureAwait_0">
         <source>Await the preceding expression and add ConfigureAwait({0}).</source>
-        <target state="new">Await the preceding expression and add ConfigureAwait({0}).</target>
+        <target state="translated">Warten Sie auf den vorhergehenden Ausdruck, und fügen Sie „ConfigureAwait ({0})“ hinzu.</target>
         <note>{Locked="ConfigureAwait"} "ConfigureAwait" is an api name and should not be localized. {0} is a placeholder for the language specific keyword 'false'.</note>
       </trans-unit>
       <trans-unit id="Awaited_task_returns_0">
@@ -472,12 +472,12 @@ Stellen Sie sicher, dass Sie den Bezeichner "tt" für Sprachen verwenden, für d
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
         <source>Could not find portable PDB on disk or embedded.</source>
-        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <target state="translated">Die portierbare PDB-Datei wurde nicht auf dem Datenträger oder eingebettet gefunden.</target>
         <note />
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
         <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
-        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <target state="translated">Die PDB-Datei wurde nicht auf dem Datenträger, eingebettet oder auf einem Symbolserver gefunden.</target>
         <note />
       </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
@@ -562,7 +562,7 @@ Stellen Sie sicher, dass Sie den Bezeichner "tt" für Sprachen verwenden, für d
       </trans-unit>
       <trans-unit id="Error_reading_PDB_0">
         <source>Error reading PDB: '{0}'</source>
-        <target state="new">Error reading PDB: '{0}'</target>
+        <target state="translated">Fehler beim Lesen von PDB-Dateien: „{0}“</target>
         <note />
       </trans-unit>
       <trans-unit id="Example">
@@ -582,7 +582,7 @@ Stellen Sie sicher, dass Sie den Bezeichner "tt" für Sprachen verwenden, für d
       </trans-unit>
       <trans-unit id="Explicitly_inherit_documentation">
         <source>Explicitly inherit documentation</source>
-        <target state="new">Explicitly inherit documentation</target>
+        <target state="translated">Dokumentation explizit erben</target>
         <note />
       </trans-unit>
       <trans-unit id="Extract_base_class">
@@ -632,32 +632,32 @@ Stellen Sie sicher, dass Sie den Bezeichner "tt" für Sprachen verwenden, für d
       </trans-unit>
       <trans-unit id="Found_PDB_file_at_0">
         <source>Found PDB file at '{0}'</source>
-        <target state="new">Found PDB file at '{0}'</target>
+        <target state="translated">Die PDB-Datei wurde unter „{0}“ gefunden</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server">
         <source>Found PDB on symbol server.</source>
-        <target state="new">Found PDB on symbol server.</target>
+        <target state="translated">Die PDB-Datei wurde auf dem Symbolserver gefunden.</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
         <source>Found PDB on symbol server but could not read file.</source>
-        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <target state="translated">Die PDB-Datei wurde auf dem Symbolserver gefunden, aber die Datei konnte jedoch nicht gelesen werden.</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_embedded_PDB_file">
         <source>Found embedded PDB file.</source>
-        <target state="new">Found embedded PDB file.</target>
+        <target state="translated">Die eingebettete PDB-Datei wurde gefunden.</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
-        <target state="new">Generate abstract method '{0}'</target>
+        <target state="translated">Abstrakte Methode „{0}“ generieren</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_property_0">
         <source>Generate abstract property '{0}'</source>
-        <target state="new">Generate abstract property '{0}'</target>
+        <target state="translated">Abstrakte Eigenschaft „{0}X generieren</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_comparison_operators">
@@ -667,7 +667,7 @@ Stellen Sie sicher, dass Sie den Bezeichner "tt" für Sprachen verwenden, für d
       </trans-unit>
       <trans-unit id="Generate_constant_0">
         <source>Generate constant '{0}'</source>
-        <target state="new">Generate constant '{0}'</target>
+        <target state="translated">Konstante „{0}“ generieren</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_constructor_in_0_with_fields">
@@ -682,12 +682,12 @@ Stellen Sie sicher, dass Sie den Bezeichner "tt" für Sprachen verwenden, für d
       </trans-unit>
       <trans-unit id="Generate_enum_member_0">
         <source>Generate enum member '{0}'</source>
-        <target state="new">Generate enum member '{0}'</target>
+        <target state="translated">Aufzählungselement „{0}“ generieren</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_field_0">
         <source>Generate field '{0}'</source>
-        <target state="new">Generate field '{0}'</target>
+        <target state="translated">Feld „{0}“ generieren</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_for_0">
@@ -697,7 +697,7 @@ Stellen Sie sicher, dass Sie den Bezeichner "tt" für Sprachen verwenden, für d
       </trans-unit>
       <trans-unit id="Generate_method_0">
         <source>Generate method '{0}'</source>
-        <target state="new">Generate method '{0}'</target>
+        <target state="translated">Methode „{0}“ generieren</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_parameter_0">
@@ -712,17 +712,17 @@ Stellen Sie sicher, dass Sie den Bezeichner "tt" für Sprachen verwenden, für d
       </trans-unit>
       <trans-unit id="Generate_property_0">
         <source>Generate property '{0}'</source>
-        <target state="new">Generate property '{0}'</target>
+        <target state="translated">Eigenschaft „{0}“ generieren</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_field_0">
         <source>Generate read-only field '{0}'</source>
-        <target state="new">Generate read-only field '{0}'</target>
+        <target state="translated">Schreibgeschütztes Feld „{0}“ generieren</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_property_0">
         <source>Generate read-only property '{0}'</source>
-        <target state="new">Generate read-only property '{0}'</target>
+        <target state="translated">Schreibgeschützte Eigenschaft „{0}“ generieren</target>
         <note />
       </trans-unit>
       <trans-unit id="Illegal_backslash_at_end_of_pattern">
@@ -947,7 +947,7 @@ Stellen Sie sicher, dass Sie den Bezeichner "tt" für Sprachen verwenden, für d
       </trans-unit>
       <trans-unit id="Miscellaneous_Files">
         <source>Miscellaneous Files</source>
-        <target state="new">Miscellaneous Files</target>
+        <target state="translated">Sonstige Dateien</target>
         <note />
       </trans-unit>
       <trans-unit id="Missing_control_character">
@@ -1057,7 +1057,7 @@ Stellen Sie sicher, dass Sie den Bezeichner "tt" für Sprachen verwenden, für d
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type">
         <source>Move static members to another type...</source>
-        <target state="new">Move static members to another type...</target>
+        <target state="translated">Statische Mitglieder werden in einen anderen Typ verschoben...</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -1072,7 +1072,7 @@ Stellen Sie sicher, dass Sie den Bezeichner "tt" für Sprachen verwenden, für d
       </trans-unit>
       <trans-unit id="Navigating_to_symbol_0_from_1">
         <source>Navigating to symbol '{0}' from '{1}'.</source>
-        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <target state="translated">Die Navigation von „{1}“ zum Symbol „{0}“ wird durchgeführt.</target>
         <note />
       </trans-unit>
       <trans-unit id="Nested_quantifier_0">
@@ -1087,7 +1087,7 @@ Stellen Sie sicher, dass Sie den Bezeichner "tt" für Sprachen verwenden, für d
       </trans-unit>
       <trans-unit id="No_source_document_info_found_in_PDB">
         <source>No source document info found in PDB.</source>
-        <target state="new">No source document info found in PDB.</target>
+        <target state="translated">In der PDB-Datei wurden keine Quelldokumentinformationen gefunden.</target>
         <note />
       </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
@@ -1275,11 +1275,11 @@ Diese Option empfiehlt sich, wenn Sie wissen, dass die Rückverfolgung nicht zum
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
+        <target state="translated">Eine Ausgleichsgruppendefinition löscht die Definition einer zuvor definierten Gruppe und speichert in der aktuellen Gruppe das Intervall zwischen der zuvor definierten Gruppe und der aktuellen Gruppe.
 
-'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+„name1“ ist die aktuelle Gruppe (optional), „name2“ ist eine zuvor definierte Gruppe, und „Teilausdruck“ ist ein beliebiges gültiges Muster für reguläre Ausdrücke. Die Ausgleichsgruppendefinition löscht die Definition von „name2“ und speichert das Intervall zwischen „name2“ und „name1“ in „name1“. Wenn keine Gruppe namens „name2“ definiert ist, wird für die Übereinstimmung eine Rückverfolgung durchgeführt. Weil durch das Löschen der letzten Definition von „name2“ die vorherige Definition von „name2“ angezeigt wird, können Sie mithilfe dieses Konstrukts den Stapel von Erfassungen für die Gruppe „name2“ als Zähler für die Nachverfolgung geschachtelter Konstrukte wie z. B. öffnende und schließende Klammern verwenden.
 
-The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
+Die Ausgleichsgruppendefinition verwendet „name2“ als Stapel. Das Anfangszeichen der einzelnen geschachtelten Konstrukte wird in der Gruppe und in der zugehörigen Sammlung „Group.Captures“ platziert. Wenn das schließende Zeichen gefunden wurde, wird das entsprechende öffnende Zeichen aus der Gruppe entfernt, und die „Captures“-Sammlung wird um eins verringert. Nachdem die öffnenden und schließenden Zeichen aller geschachtelten Konstrukte abgeglichen wurden, ist „name1“ leer.</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
@@ -2352,7 +2352,7 @@ Positive Lookbehindassertionen mit Nullbreite werden normalerweise am Anfang reg
       </trans-unit>
       <trans-unit id="Silent">
         <source>Silent</source>
-        <target state="new">Silent</target>
+        <target state="translated">Still</target>
         <note />
       </trans-unit>
       <trans-unit id="Sort_accessibility_modifiers">
@@ -2362,12 +2362,12 @@ Positive Lookbehindassertionen mit Nullbreite werden normalerweise am Anfang reg
       </trans-unit>
       <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
         <source>Source code language information was not found in PDB.</source>
-        <target state="new">Source code language information was not found in PDB.</target>
+        <target state="translated">Die Informationen zur Quellcodesprache wurden in der PDB-Datei nicht gefunden.</target>
         <note />
       </trans-unit>
       <trans-unit id="Source_is_a_reference_assembly">
         <source>Source is a reference assembly, not enough information to find PDB.</source>
-        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <target state="translated">Die Quelle ist eine Referenzassembly. Es sind nicht genügend Informationen vorhanden, um die PDB-Datei zu finden.</target>
         <note />
       </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
@@ -2397,7 +2397,7 @@ Positive Lookbehindassertionen mit Nullbreite werden normalerweise am Anfang reg
       </trans-unit>
       <trans-unit id="Symbol_found_in_assembly_path_0">
         <source>Symbol found in assembly path '{0}'</source>
-        <target state="new">Symbol found in assembly path '{0}'</target>
+        <target state="translated">Das Symbol wurde unter dem Assemblypfad „{0}“ gefunden</target>
         <note />
       </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
@@ -2427,12 +2427,12 @@ Positive Lookbehindassertionen mit Nullbreite werden normalerweise am Anfang reg
       </trans-unit>
       <trans-unit id="Timeout_SourceLink">
         <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <target state="translated">Timeout beim Herunterladen von Quellcode aus SourceLink. Nachfolgende Anforderungen sind möglicherweise erfolgreich.</target>
         <note />
       </trans-unit>
       <trans-unit id="Timeout_symbol_server">
         <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <target state="translated">Timeout beim Herunterladen der PDB-Datei vom Symbolserver. Nachfolgende Anforderungen sind möglicherweise erfolgreich.</target>
         <note />
       </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
@@ -2447,7 +2447,7 @@ Positive Lookbehindassertionen mit Nullbreite werden normalerweise am Anfang reg
       </trans-unit>
       <trans-unit id="Types_colon">
         <source>Types:</source>
-        <target state="new">Types:</target>
+        <target state="translated">Typen:</target>
         <note />
       </trans-unit>
       <trans-unit id="UnableToReadSourceFileOrPdb">
@@ -2737,42 +2737,42 @@ Positive Lookbehindassertionen mit Nullbreite werden normalerweise am Anfang reg
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB">
         <source>'{0}' found in embedded PDB.</source>
-        <target state="new">'{0}' found in embedded PDB.</target>
+        <target state="translated">„{0}“ wurde in einer eingebetteten PDB-Datei gefunden.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
         <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">„{0}“ wurde in einer eingebetteten PDB-Datei gefunden, aber die Prüfsumme war falsch oder die temporäre Datei konnte nicht gelesen werden.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
         <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
-        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <target state="translated">„{0}“ wurde in einer eingebetteten PDB-Datei gefunden, konnte aber nicht in die temporäre Datei schreiben: „{1}“</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
         <source>'{0}' found in embedded PDB and found cached source file.</source>
-        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <target state="translated">„{0}“ wurde in der eingebetteten PDB-Datei und in der zwischengespeicherten Quelldatei gefunden.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location">
         <source>'{0}' found in original location.</source>
-        <target state="new">'{0}' found in original location.</target>
+        <target state="translated">„{0}“ wurde am ursprünglichen Speicherort gefunden.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location_but_checksum_failed">
         <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">„{0}“ wurde am ursprünglichen Speicherort gefunden, aber die Prüfsumme war falsch oder die temporäre Datei konnte nicht gelesen werden.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink">
         <source>'{0}' found via SourceLink.</source>
-        <target state="new">'{0}' found via SourceLink.</target>
+        <target state="translated">„{0}“ wurde über SourceLink gefunden.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
         <source>'{0}' found via SourceLink but couldn't read temp file.</source>
-        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <target state="translated">„{0}“ wurde über SourceLink gefunden, aber die temporäre Datei konnte nicht gelesen werden.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_is_not_null_here">
@@ -3105,12 +3105,12 @@ Bei Verwendung des Formatbezeichners "d" ohne weitere benutzerdefinierte Formatb
       </trans-unit>
       <trans-unit id="embedded">
         <source>embedded</source>
-        <target state="new">embedded</target>
+        <target state="translated">Eingebettet</target>
         <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
       </trans-unit>
       <trans-unit id="external">
         <source>external</source>
-        <target state="new">external</target>
+        <target state="translated">Extern</target>
         <note>External means "external source", meaning source files that are not part of the current solution</note>
       </trans-unit>
       <trans-unit id="from_metadata">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf
index 276f61e8b8af0..1b3a2701ef342 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf
@@ -242,12 +242,12 @@ Asegúrese de usar el especificador "tt" para los idiomas para los que es necesa
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression">
         <source>Await the preceding expression</source>
-        <target state="new">Await the preceding expression</target>
+        <target state="translated">Espere la expresión anterior</target>
         <note />
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression_and_add_ConfigureAwait_0">
         <source>Await the preceding expression and add ConfigureAwait({0}).</source>
-        <target state="new">Await the preceding expression and add ConfigureAwait({0}).</target>
+        <target state="translated">Espere la expresión anterior y agregue ConfigureAwait({0}).</target>
         <note>{Locked="ConfigureAwait"} "ConfigureAwait" is an api name and should not be localized. {0} is a placeholder for the language specific keyword 'false'.</note>
       </trans-unit>
       <trans-unit id="Awaited_task_returns_0">
@@ -472,12 +472,12 @@ Asegúrese de usar el especificador "tt" para los idiomas para los que es necesa
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
         <source>Could not find portable PDB on disk or embedded.</source>
-        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <target state="translated">No se pudo encontrar el archivo PDB portátil en el disco o incrustado.</target>
         <note />
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
         <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
-        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <target state="translated">No se encontró el archivo PDB en el disco, incrustado o en un servidor de símbolos.</target>
         <note />
       </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
@@ -562,7 +562,7 @@ Asegúrese de usar el especificador "tt" para los idiomas para los que es necesa
       </trans-unit>
       <trans-unit id="Error_reading_PDB_0">
         <source>Error reading PDB: '{0}'</source>
-        <target state="new">Error reading PDB: '{0}'</target>
+        <target state="translated">Error al leer PDB: '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Example">
@@ -582,7 +582,7 @@ Asegúrese de usar el especificador "tt" para los idiomas para los que es necesa
       </trans-unit>
       <trans-unit id="Explicitly_inherit_documentation">
         <source>Explicitly inherit documentation</source>
-        <target state="new">Explicitly inherit documentation</target>
+        <target state="translated">Heredar explícitamente la documentación</target>
         <note />
       </trans-unit>
       <trans-unit id="Extract_base_class">
@@ -632,32 +632,32 @@ Asegúrese de usar el especificador "tt" para los idiomas para los que es necesa
       </trans-unit>
       <trans-unit id="Found_PDB_file_at_0">
         <source>Found PDB file at '{0}'</source>
-        <target state="new">Found PDB file at '{0}'</target>
+        <target state="translated">Se encontró el archivo PDB en '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server">
         <source>Found PDB on symbol server.</source>
-        <target state="new">Found PDB on symbol server.</target>
+        <target state="translated">Se encontró PDB en el servidor de símbolos.</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
         <source>Found PDB on symbol server but could not read file.</source>
-        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <target state="translated">Se encontró PDB en el servidor de símbolos, pero no se pudo leer el archivo.</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_embedded_PDB_file">
         <source>Found embedded PDB file.</source>
-        <target state="new">Found embedded PDB file.</target>
+        <target state="translated">Se encontró un archivo PDB incrustado.</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
-        <target state="new">Generate abstract method '{0}'</target>
+        <target state="translated">Generar método abstracto "{0}"</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_property_0">
         <source>Generate abstract property '{0}'</source>
-        <target state="new">Generate abstract property '{0}'</target>
+        <target state="translated">Generar propiedad abstracta "{0}"</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_comparison_operators">
@@ -667,7 +667,7 @@ Asegúrese de usar el especificador "tt" para los idiomas para los que es necesa
       </trans-unit>
       <trans-unit id="Generate_constant_0">
         <source>Generate constant '{0}'</source>
-        <target state="new">Generate constant '{0}'</target>
+        <target state="translated">Generar constante "{0}"</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_constructor_in_0_with_fields">
@@ -682,12 +682,12 @@ Asegúrese de usar el especificador "tt" para los idiomas para los que es necesa
       </trans-unit>
       <trans-unit id="Generate_enum_member_0">
         <source>Generate enum member '{0}'</source>
-        <target state="new">Generate enum member '{0}'</target>
+        <target state="translated">Generar miembro de enumeración "{0}"</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_field_0">
         <source>Generate field '{0}'</source>
-        <target state="new">Generate field '{0}'</target>
+        <target state="translated">Generar campo "{0}"</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_for_0">
@@ -697,7 +697,7 @@ Asegúrese de usar el especificador "tt" para los idiomas para los que es necesa
       </trans-unit>
       <trans-unit id="Generate_method_0">
         <source>Generate method '{0}'</source>
-        <target state="new">Generate method '{0}'</target>
+        <target state="translated">Generar método "{0}"</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_parameter_0">
@@ -712,17 +712,17 @@ Asegúrese de usar el especificador "tt" para los idiomas para los que es necesa
       </trans-unit>
       <trans-unit id="Generate_property_0">
         <source>Generate property '{0}'</source>
-        <target state="new">Generate property '{0}'</target>
+        <target state="translated">Generar propiedad "{0}"</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_field_0">
         <source>Generate read-only field '{0}'</source>
-        <target state="new">Generate read-only field '{0}'</target>
+        <target state="translated">Generar un campo de sólo lectura "{0}"</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_property_0">
         <source>Generate read-only property '{0}'</source>
-        <target state="new">Generate read-only property '{0}'</target>
+        <target state="translated">Generar propiedad de solo lectura "{0}"</target>
         <note />
       </trans-unit>
       <trans-unit id="Illegal_backslash_at_end_of_pattern">
@@ -947,7 +947,7 @@ Asegúrese de usar el especificador "tt" para los idiomas para los que es necesa
       </trans-unit>
       <trans-unit id="Miscellaneous_Files">
         <source>Miscellaneous Files</source>
-        <target state="new">Miscellaneous Files</target>
+        <target state="translated">Archivos varios</target>
         <note />
       </trans-unit>
       <trans-unit id="Missing_control_character">
@@ -1057,7 +1057,7 @@ Asegúrese de usar el especificador "tt" para los idiomas para los que es necesa
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type">
         <source>Move static members to another type...</source>
-        <target state="new">Move static members to another type...</target>
+        <target state="translated">Mover miembros estáticos a otro tipo...</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -1072,7 +1072,7 @@ Asegúrese de usar el especificador "tt" para los idiomas para los que es necesa
       </trans-unit>
       <trans-unit id="Navigating_to_symbol_0_from_1">
         <source>Navigating to symbol '{0}' from '{1}'.</source>
-        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <target state="translated">Navegando al símbolo '{0}' desde '{1}'.</target>
         <note />
       </trans-unit>
       <trans-unit id="Nested_quantifier_0">
@@ -1087,7 +1087,7 @@ Asegúrese de usar el especificador "tt" para los idiomas para los que es necesa
       </trans-unit>
       <trans-unit id="No_source_document_info_found_in_PDB">
         <source>No source document info found in PDB.</source>
-        <target state="new">No source document info found in PDB.</target>
+        <target state="translated">No se encontró información del documento de origen en PDB.</target>
         <note />
       </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
@@ -1275,11 +1275,11 @@ Se recomienda esta opción si sabe que la vuelta atrás no será correcta. Evita
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
+        <target state="translated">Una definición de grupo de equilibrio elimina la definición de un grupo definido anteriormente y almacena, en el grupo actual, el intervalo entre el grupo definido anteriormente y el grupo actual.
 
-'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+"name1" es el grupo actual (opcional), "name2" es un grupo definido anteriormente y "subexpression" es cualquier patrón de expresión regular válido. La definición del grupo de equilibrio elimina la definición de name2 y almacena el intervalo entre name2 y name1 en name1. Si no se define un grupo de name2, la coincidencia se busca con retroceso. Como la eliminación de la última definición de name2 revela la definición anterior de name2, esta construcción permite usar la pila de capturas para el grupo name2 como contador para realizar el seguimiento de las construcciones anidadas, como los paréntesis o los corchetes de apertura y cierre.
 
-The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
+La definición del grupo de equilibrio usa "name2" como una pila. El carácter inicial de cada construcción anidada se coloca en el grupo y en su colección Group.Captures. Cuando coincide el carácter de cierre, se quita el carácter de apertura correspondiente del grupo y se quita uno de la colección Captures. Una vez que se han encontrado coincidencias de los caracteres de apertura y cierre de todas las construcciones anidadas, "name1" se queda vacío.</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
@@ -2352,7 +2352,7 @@ Las aserciones de búsqueda retrasada (lookbehind) positivas de ancho cero se us
       </trans-unit>
       <trans-unit id="Silent">
         <source>Silent</source>
-        <target state="new">Silent</target>
+        <target state="translated">Silencioso</target>
         <note />
       </trans-unit>
       <trans-unit id="Sort_accessibility_modifiers">
@@ -2362,12 +2362,12 @@ Las aserciones de búsqueda retrasada (lookbehind) positivas de ancho cero se us
       </trans-unit>
       <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
         <source>Source code language information was not found in PDB.</source>
-        <target state="new">Source code language information was not found in PDB.</target>
+        <target state="translated">No se encontró la información del lenguaje de código fuente en PDB.</target>
         <note />
       </trans-unit>
       <trans-unit id="Source_is_a_reference_assembly">
         <source>Source is a reference assembly, not enough information to find PDB.</source>
-        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <target state="translated">El origen es un ensamblado de referencia, no hay suficiente información para encontrar el archivo PDB.</target>
         <note />
       </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
@@ -2397,7 +2397,7 @@ Las aserciones de búsqueda retrasada (lookbehind) positivas de ancho cero se us
       </trans-unit>
       <trans-unit id="Symbol_found_in_assembly_path_0">
         <source>Symbol found in assembly path '{0}'</source>
-        <target state="new">Symbol found in assembly path '{0}'</target>
+        <target state="translated">Símbolo encontrado en la ruta de acceso del ensamblado '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
@@ -2427,12 +2427,12 @@ Las aserciones de búsqueda retrasada (lookbehind) positivas de ancho cero se us
       </trans-unit>
       <trans-unit id="Timeout_SourceLink">
         <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <target state="translated">Se agotó el tiempo de espera al intentar descargar el código fuente de SourceLink. Es posible que las solicitudes siguientes se realicen correctamente.</target>
         <note />
       </trans-unit>
       <trans-unit id="Timeout_symbol_server">
         <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <target state="translated">Se agotó el tiempo de espera al intentar descargar el archivo PDB del servidor de símbolos. Es posible que las solicitudes siguientes se realicen correctamente.</target>
         <note />
       </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
@@ -2447,7 +2447,7 @@ Las aserciones de búsqueda retrasada (lookbehind) positivas de ancho cero se us
       </trans-unit>
       <trans-unit id="Types_colon">
         <source>Types:</source>
-        <target state="new">Types:</target>
+        <target state="translated">Tipos:</target>
         <note />
       </trans-unit>
       <trans-unit id="UnableToReadSourceFileOrPdb">
@@ -2737,42 +2737,42 @@ Las aserciones de búsqueda retrasada (lookbehind) positivas de ancho cero se us
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB">
         <source>'{0}' found in embedded PDB.</source>
-        <target state="new">'{0}' found in embedded PDB.</target>
+        <target state="translated">'{0}' encontrados en PDB incrustado.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
         <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">'{0}' encontró en el archivo PDB incrustado, pero la suma de comprobación era incorrecta o no pudo leer el archivo temporal.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
         <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
-        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <target state="translated">'{0}' encontró en el archivo PDB incrustado pero no pudo escribir en el archivo temporal: '{1}'</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
         <source>'{0}' found in embedded PDB and found cached source file.</source>
-        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <target state="translated">'{0}' se encontró en el archivo PDB incrustado y se encontró el archivo de origen almacenado en caché.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location">
         <source>'{0}' found in original location.</source>
-        <target state="new">'{0}' found in original location.</target>
+        <target state="translated">'{0}' encontrados en la ubicación original.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location_but_checksum_failed">
         <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">'{0}' encontró en la ubicación original, pero la suma de comprobación era incorrecta o no pudo leer el archivo temporal.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink">
         <source>'{0}' found via SourceLink.</source>
-        <target state="new">'{0}' found via SourceLink.</target>
+        <target state="translated">'{0}' encontró a través de SourceLink.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
         <source>'{0}' found via SourceLink but couldn't read temp file.</source>
-        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <target state="translated">'{0}' encontró a través de SourceLink pero no pudo leer el archivo temporal.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_is_not_null_here">
@@ -3105,12 +3105,12 @@ Si el especificador de formato "d" se usa sin otros especificadores de formato p
       </trans-unit>
       <trans-unit id="embedded">
         <source>embedded</source>
-        <target state="new">embedded</target>
+        <target state="translated">Incrustado</target>
         <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
       </trans-unit>
       <trans-unit id="external">
         <source>external</source>
-        <target state="new">external</target>
+        <target state="translated">externo</target>
         <note>External means "external source", meaning source files that are not part of the current solution</note>
       </trans-unit>
       <trans-unit id="from_metadata">
@@ -3747,7 +3747,7 @@ Do you want to continue?</source>
       </trans-unit>
       <trans-unit id="in_Suppression_File">
         <source>in Suppression File</source>
-        <target state="translated">En&amp; archivo de supresión</target>
+        <target state="translated">En archivo de supresión</target>
         <note />
       </trans-unit>
       <trans-unit id="Remove_Suppression_0">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf
index 751ae795026bc..b805709d77a5d 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf
@@ -242,12 +242,12 @@ Veillez à utiliser le spécificateur "tt" pour les langues où il est nécessai
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression">
         <source>Await the preceding expression</source>
-        <target state="new">Await the preceding expression</target>
+        <target state="translated">Attendre l'expression précédente</target>
         <note />
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression_and_add_ConfigureAwait_0">
         <source>Await the preceding expression and add ConfigureAwait({0}).</source>
-        <target state="new">Await the preceding expression and add ConfigureAwait({0}).</target>
+        <target state="translated">Attendez l'expression précédente et ajoutez ConfigureAwait({0}).</target>
         <note>{Locked="ConfigureAwait"} "ConfigureAwait" is an api name and should not be localized. {0} is a placeholder for the language specific keyword 'false'.</note>
       </trans-unit>
       <trans-unit id="Awaited_task_returns_0">
@@ -472,12 +472,12 @@ Veillez à utiliser le spécificateur "tt" pour les langues où il est nécessai
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
         <source>Could not find portable PDB on disk or embedded.</source>
-        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <target state="translated">PDB portable introuvable sur le disque ou incorporé.</target>
         <note />
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
         <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
-        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <target state="translated">PDB introuvable sur le disque, ou incorporé, ou sur un serveur de symboles.</target>
         <note />
       </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
@@ -562,7 +562,7 @@ Veillez à utiliser le spécificateur "tt" pour les langues où il est nécessai
       </trans-unit>
       <trans-unit id="Error_reading_PDB_0">
         <source>Error reading PDB: '{0}'</source>
-        <target state="new">Error reading PDB: '{0}'</target>
+        <target state="translated">Erreur de lecture de la base de données PDB : '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Example">
@@ -582,7 +582,7 @@ Veillez à utiliser le spécificateur "tt" pour les langues où il est nécessai
       </trans-unit>
       <trans-unit id="Explicitly_inherit_documentation">
         <source>Explicitly inherit documentation</source>
-        <target state="new">Explicitly inherit documentation</target>
+        <target state="translated">Hériter explicitement de la documentation</target>
         <note />
       </trans-unit>
       <trans-unit id="Extract_base_class">
@@ -632,32 +632,32 @@ Veillez à utiliser le spécificateur "tt" pour les langues où il est nécessai
       </trans-unit>
       <trans-unit id="Found_PDB_file_at_0">
         <source>Found PDB file at '{0}'</source>
-        <target state="new">Found PDB file at '{0}'</target>
+        <target state="translated">Fichier PDB trouvé sur '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server">
         <source>Found PDB on symbol server.</source>
-        <target state="new">Found PDB on symbol server.</target>
+        <target state="translated">Fichier PDB trouvé sur le serveur de symboles</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
         <source>Found PDB on symbol server but could not read file.</source>
-        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <target state="translated">PDB trouvé sur le serveur de symboles, mais le fichier n’a pas pu être lu.</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_embedded_PDB_file">
         <source>Found embedded PDB file.</source>
-        <target state="new">Found embedded PDB file.</target>
+        <target state="translated">Fichier PDB incorporé trouvé.</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
-        <target state="new">Generate abstract method '{0}'</target>
+        <target state="translated">Générer la méthode abstraite '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_property_0">
         <source>Generate abstract property '{0}'</source>
-        <target state="new">Generate abstract property '{0}'</target>
+        <target state="translated">Générer la propriété abstraite '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_comparison_operators">
@@ -667,7 +667,7 @@ Veillez à utiliser le spécificateur "tt" pour les langues où il est nécessai
       </trans-unit>
       <trans-unit id="Generate_constant_0">
         <source>Generate constant '{0}'</source>
-        <target state="new">Generate constant '{0}'</target>
+        <target state="translated">Générer une constante '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_constructor_in_0_with_fields">
@@ -682,12 +682,12 @@ Veillez à utiliser le spécificateur "tt" pour les langues où il est nécessai
       </trans-unit>
       <trans-unit id="Generate_enum_member_0">
         <source>Generate enum member '{0}'</source>
-        <target state="new">Generate enum member '{0}'</target>
+        <target state="translated">Générer le membre enum '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_field_0">
         <source>Generate field '{0}'</source>
-        <target state="new">Generate field '{0}'</target>
+        <target state="translated">Générer le champ '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_for_0">
@@ -697,7 +697,7 @@ Veillez à utiliser le spécificateur "tt" pour les langues où il est nécessai
       </trans-unit>
       <trans-unit id="Generate_method_0">
         <source>Generate method '{0}'</source>
-        <target state="new">Generate method '{0}'</target>
+        <target state="translated">Générer la méthode '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_parameter_0">
@@ -712,17 +712,17 @@ Veillez à utiliser le spécificateur "tt" pour les langues où il est nécessai
       </trans-unit>
       <trans-unit id="Generate_property_0">
         <source>Generate property '{0}'</source>
-        <target state="new">Generate property '{0}'</target>
+        <target state="translated">Générer la propriété '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_field_0">
         <source>Generate read-only field '{0}'</source>
-        <target state="new">Generate read-only field '{0}'</target>
+        <target state="translated">Générer le champ en lecture seule '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_property_0">
         <source>Generate read-only property '{0}'</source>
-        <target state="new">Generate read-only property '{0}'</target>
+        <target state="translated">Générer la propriété en lecture seule '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Illegal_backslash_at_end_of_pattern">
@@ -947,7 +947,7 @@ Veillez à utiliser le spécificateur "tt" pour les langues où il est nécessai
       </trans-unit>
       <trans-unit id="Miscellaneous_Files">
         <source>Miscellaneous Files</source>
-        <target state="new">Miscellaneous Files</target>
+        <target state="translated">Fichiers divers</target>
         <note />
       </trans-unit>
       <trans-unit id="Missing_control_character">
@@ -1057,7 +1057,7 @@ Veillez à utiliser le spécificateur "tt" pour les langues où il est nécessai
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type">
         <source>Move static members to another type...</source>
-        <target state="new">Move static members to another type...</target>
+        <target state="translated">Déplacer les membres statiques vers un autre type...</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -1072,7 +1072,7 @@ Veillez à utiliser le spécificateur "tt" pour les langues où il est nécessai
       </trans-unit>
       <trans-unit id="Navigating_to_symbol_0_from_1">
         <source>Navigating to symbol '{0}' from '{1}'.</source>
-        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <target state="translated">Navigation vers le symbole '{0}' à partir de '{1}'.</target>
         <note />
       </trans-unit>
       <trans-unit id="Nested_quantifier_0">
@@ -1087,7 +1087,7 @@ Veillez à utiliser le spécificateur "tt" pour les langues où il est nécessai
       </trans-unit>
       <trans-unit id="No_source_document_info_found_in_PDB">
         <source>No source document info found in PDB.</source>
-        <target state="new">No source document info found in PDB.</target>
+        <target state="translated">Aucune information de document source n’a été trouvée dans le fichier PDB.</target>
         <note />
       </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
@@ -1275,11 +1275,11 @@ Cette option est recommandée si vous savez que le retour sur trace va être un
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
+        <target state="translated">Une définition de groupe d'équilibrage supprime la définition d'un groupe précédemment défini et stocke, dans le groupe courant, l'intervalle entre le groupe précédemment défini et le groupe courant.
 
-'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+« nom1 » est le groupe actuel (facultatif), « nom2 » est un groupe défini précédemment et « sous-expression » est un modèle d’expression régulière valide. La définition du groupe d'équilibrage supprime la définition de nom2 et stocke l'intervalle entre nom2 et nom1 dans nom1. Si aucun groupe name2 n'est défini, la correspondance revient en arrière. Étant donné que la suppression de la dernière définition de name2 révèle la définition précédente de name2, cette construction vous permet d'utiliser la pile de captures pour le groupe name2 comme compteur pour suivre les constructions imbriquées telles que les parenthèses ou les crochets ouvrants et fermants.
 
-The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
+La définition du groupe d'équilibrage utilise 'name2' comme pile. Le caractère de début de chaque construction imbriquée est placé dans le groupe et dans sa collection Group.Captures. Lorsque le caractère de fermeture est mis en correspondance, son caractère d'ouverture correspondant est supprimé du groupe et la collection Captures est diminuée de un. Une fois que les caractères d'ouverture et de fermeture de toutes les constructions imbriquées ont été mis en correspondance, 'name1' est vide.</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
@@ -2352,7 +2352,7 @@ Les assertions arrière positives de largeur nulle sont généralement utilisée
       </trans-unit>
       <trans-unit id="Silent">
         <source>Silent</source>
-        <target state="new">Silent</target>
+        <target state="translated">Silent</target>
         <note />
       </trans-unit>
       <trans-unit id="Sort_accessibility_modifiers">
@@ -2362,12 +2362,12 @@ Les assertions arrière positives de largeur nulle sont généralement utilisée
       </trans-unit>
       <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
         <source>Source code language information was not found in PDB.</source>
-        <target state="new">Source code language information was not found in PDB.</target>
+        <target state="translated">Les informations sur la langue du code source sont introuvables dans le fichier PDB.</target>
         <note />
       </trans-unit>
       <trans-unit id="Source_is_a_reference_assembly">
         <source>Source is a reference assembly, not enough information to find PDB.</source>
-        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <target state="translated">La source est un assembly de référence, il n’y a pas assez d’informations pour trouver le fichier PDB.</target>
         <note />
       </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
@@ -2397,7 +2397,7 @@ Les assertions arrière positives de largeur nulle sont généralement utilisée
       </trans-unit>
       <trans-unit id="Symbol_found_in_assembly_path_0">
         <source>Symbol found in assembly path '{0}'</source>
-        <target state="new">Symbol found in assembly path '{0}'</target>
+        <target state="translated">Symbole trouvé dans le chemin d’accès de l’assembly '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
@@ -2427,12 +2427,12 @@ Les assertions arrière positives de largeur nulle sont généralement utilisée
       </trans-unit>
       <trans-unit id="Timeout_SourceLink">
         <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <target state="translated">Expiration du délai d’attente lors de la tentative de téléchargement du code source à partir de SourceLink. Les demandes suivantes peuvent réussir.</target>
         <note />
       </trans-unit>
       <trans-unit id="Timeout_symbol_server">
         <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <target state="translated">Expiration du délai d’attente lors de la tentative de téléchargement du fichier PDB à partir du serveur de symboles. Les demandes suivantes peuvent réussir.</target>
         <note />
       </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
@@ -2447,7 +2447,7 @@ Les assertions arrière positives de largeur nulle sont généralement utilisée
       </trans-unit>
       <trans-unit id="Types_colon">
         <source>Types:</source>
-        <target state="new">Types:</target>
+        <target state="translated">Types :</target>
         <note />
       </trans-unit>
       <trans-unit id="UnableToReadSourceFileOrPdb">
@@ -2737,42 +2737,42 @@ Les assertions arrière positives de largeur nulle sont généralement utilisée
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB">
         <source>'{0}' found in embedded PDB.</source>
-        <target state="new">'{0}' found in embedded PDB.</target>
+        <target state="translated">'{0}' trouvé dans le fichier PDB incorporé.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
         <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">'{0}' a été trouvé dans la PDB intégrée mais la somme de contrôle était incorrecte, ou le fichier temporaire n'a pas pu être lu.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
         <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
-        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <target state="translated">'{0}' trouvé dans le fichier PDB incorporé, mais n’a pas pu écrire dans le fichier temporaire : '{1}'.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
         <source>'{0}' found in embedded PDB and found cached source file.</source>
-        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <target state="translated">'{0}' dans le fichier PDB incorporé et le fichier source mis en cache.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location">
         <source>'{0}' found in original location.</source>
-        <target state="new">'{0}' found in original location.</target>
+        <target state="translated">'{0}' trouvé à l’emplacement d’origine.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location_but_checksum_failed">
         <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">'{0}' trouvé à l’emplacement d’origine, mais la somme de contrôle était incorrecte ou n’a pas pu lire le fichier temporaire.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink">
         <source>'{0}' found via SourceLink.</source>
-        <target state="new">'{0}' found via SourceLink.</target>
+        <target state="translated">'{0}' trouvées via SourceLink.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
         <source>'{0}' found via SourceLink but couldn't read temp file.</source>
-        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <target state="translated">'{0}' trouvé via SourceLink mais n’a pas pu lire le fichier temporaire.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_is_not_null_here">
@@ -3105,12 +3105,12 @@ Si le spécificateur de format "d" est utilisé sans autres spécificateurs de f
       </trans-unit>
       <trans-unit id="embedded">
         <source>embedded</source>
-        <target state="new">embedded</target>
+        <target state="translated">Rapport</target>
         <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
       </trans-unit>
       <trans-unit id="external">
         <source>external</source>
-        <target state="new">external</target>
+        <target state="translated">externe</target>
         <note>External means "external source", meaning source files that are not part of the current solution</note>
       </trans-unit>
       <trans-unit id="from_metadata">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf
index ad7c9b888a68c..eb892febb49ba 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf
@@ -242,12 +242,12 @@ Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessa
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression">
         <source>Await the preceding expression</source>
-        <target state="new">Await the preceding expression</target>
+        <target state="translated">Attendi l'espressione precedente</target>
         <note />
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression_and_add_ConfigureAwait_0">
         <source>Await the preceding expression and add ConfigureAwait({0}).</source>
-        <target state="new">Await the preceding expression and add ConfigureAwait({0}).</target>
+        <target state="translated">Attendi l'espressione precedente e aggiungi ConfigureAwait({0}).</target>
         <note>{Locked="ConfigureAwait"} "ConfigureAwait" is an api name and should not be localized. {0} is a placeholder for the language specific keyword 'false'.</note>
       </trans-unit>
       <trans-unit id="Awaited_task_returns_0">
@@ -472,12 +472,12 @@ Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessa
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
         <source>Could not find portable PDB on disk or embedded.</source>
-        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <target state="translated">Impossibile trovare PDB portabile su disco o incorporato.</target>
         <note />
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
         <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
-        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <target state="translated">Impossibile trovare PDB su disco, incorporato o su un server di simboli.</target>
         <note />
       </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
@@ -562,7 +562,7 @@ Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessa
       </trans-unit>
       <trans-unit id="Error_reading_PDB_0">
         <source>Error reading PDB: '{0}'</source>
-        <target state="new">Error reading PDB: '{0}'</target>
+        <target state="translated">Errore durante la lettura del PDB: '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Example">
@@ -582,7 +582,7 @@ Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessa
       </trans-unit>
       <trans-unit id="Explicitly_inherit_documentation">
         <source>Explicitly inherit documentation</source>
-        <target state="new">Explicitly inherit documentation</target>
+        <target state="translated">Eredita esplicitamente la documentazione</target>
         <note />
       </trans-unit>
       <trans-unit id="Extract_base_class">
@@ -632,32 +632,32 @@ Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessa
       </trans-unit>
       <trans-unit id="Found_PDB_file_at_0">
         <source>Found PDB file at '{0}'</source>
-        <target state="new">Found PDB file at '{0}'</target>
+        <target state="translated">Trovato file PDB in '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server">
         <source>Found PDB on symbol server.</source>
-        <target state="new">Found PDB on symbol server.</target>
+        <target state="translated">È stato trovato il PDB nel server dei simboli.</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
         <source>Found PDB on symbol server but could not read file.</source>
-        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <target state="translated">Il file PDB è stato trovato nel server dei simboli ma non è stato possibile leggere il file.</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_embedded_PDB_file">
         <source>Found embedded PDB file.</source>
-        <target state="new">Found embedded PDB file.</target>
+        <target state="translated">Trovato file PDB incorporato.</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
-        <target state="new">Generate abstract method '{0}'</target>
+        <target state="translated">Genera il metodo astratto '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_property_0">
         <source>Generate abstract property '{0}'</source>
-        <target state="new">Generate abstract property '{0}'</target>
+        <target state="translated">Genera la proprietà astratta '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_comparison_operators">
@@ -667,7 +667,7 @@ Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessa
       </trans-unit>
       <trans-unit id="Generate_constant_0">
         <source>Generate constant '{0}'</source>
-        <target state="new">Generate constant '{0}'</target>
+        <target state="translated">Genera la costante '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_constructor_in_0_with_fields">
@@ -682,12 +682,12 @@ Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessa
       </trans-unit>
       <trans-unit id="Generate_enum_member_0">
         <source>Generate enum member '{0}'</source>
-        <target state="new">Generate enum member '{0}'</target>
+        <target state="translated">Genera il membro di enumerazione '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_field_0">
         <source>Generate field '{0}'</source>
-        <target state="new">Generate field '{0}'</target>
+        <target state="translated">Genera il campo '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_for_0">
@@ -697,7 +697,7 @@ Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessa
       </trans-unit>
       <trans-unit id="Generate_method_0">
         <source>Generate method '{0}'</source>
-        <target state="new">Generate method '{0}'</target>
+        <target state="translated">Genera il metodo '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_parameter_0">
@@ -712,17 +712,17 @@ Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessa
       </trans-unit>
       <trans-unit id="Generate_property_0">
         <source>Generate property '{0}'</source>
-        <target state="new">Generate property '{0}'</target>
+        <target state="translated">Genera la proprietà '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_field_0">
         <source>Generate read-only field '{0}'</source>
-        <target state="new">Generate read-only field '{0}'</target>
+        <target state="translated">Genera il campo di sola lettura '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_property_0">
         <source>Generate read-only property '{0}'</source>
-        <target state="new">Generate read-only property '{0}'</target>
+        <target state="translated">Genera la proprietà di sola lettura '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Illegal_backslash_at_end_of_pattern">
@@ -947,7 +947,7 @@ Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessa
       </trans-unit>
       <trans-unit id="Miscellaneous_Files">
         <source>Miscellaneous Files</source>
-        <target state="new">Miscellaneous Files</target>
+        <target state="translated">File esterni</target>
         <note />
       </trans-unit>
       <trans-unit id="Missing_control_character">
@@ -1057,7 +1057,7 @@ Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessa
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type">
         <source>Move static members to another type...</source>
-        <target state="new">Move static members to another type...</target>
+        <target state="translated">Sposta membri statici in un altro tipo...</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -1072,7 +1072,7 @@ Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessa
       </trans-unit>
       <trans-unit id="Navigating_to_symbol_0_from_1">
         <source>Navigating to symbol '{0}' from '{1}'.</source>
-        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <target state="translated">Passaggio al simbolo '{0}' da '{1}'.</target>
         <note />
       </trans-unit>
       <trans-unit id="Nested_quantifier_0">
@@ -1087,7 +1087,7 @@ Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessa
       </trans-unit>
       <trans-unit id="No_source_document_info_found_in_PDB">
         <source>No source document info found in PDB.</source>
-        <target state="new">No source document info found in PDB.</target>
+        <target state="translated">Nessuna informazione sul documento di origine trovata nel PDB.</target>
         <note />
       </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
@@ -1275,11 +1275,11 @@ Questa opzione è consigliata solo se si è certi che il backtracking avrà esit
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
+        <target state="translated">La definizione di gruppo di bilanciamento elimina la definizione di un gruppo definito in precedenza e archivia, nel gruppo corrente, l'intervallo tra il gruppo definito in precedenza e il gruppo corrente.
 
-'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+'name1' è il gruppo corrente (facoltativo), 'name2' è un gruppo definito in precedenza e 'subexpression' è qualsiasi criterio di espressione regolare valido. La definizione del gruppo di bilanciamento elimina la definizione di name2 e archivia l'intervallo tra name2 e name1 in name1. Se non viene definito alcun gruppo name2, viene eseguito il backtracking della corrispondenza. Dal momento che l'eliminazione dell'ultima definizione di name2 rivela la definizione precedente di name2, questo costrutto consente di usare lo stack di acquisizioni per il gruppo name2 come contatore per tenere traccia dei costrutti annidati, come ad esempio le parentesi o le parentesi quadre di apertura e chiusura.
 
-The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
+La definizione del gruppo di bilanciamento utilizza 'name2' come stack. Il carattere iniziale di ogni costrutto annidato viene inserito nel gruppo e nella relativa raccolta Group.Captures. Quando viene trovata una corrispondenza con il carattere di chiusura, il carattere di apertura corrispondente viene rimosso dal gruppo e la raccolta Captures viene ridotta di uno. Dopo che la corrispondenza dei caratteri di apertura e chiusura di tutti i costrutti annidati è stata trovata, 'name1' risulta vuoto.</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
@@ -2352,7 +2352,7 @@ Le asserzioni lookbehind positive di larghezza zero vengono usate in genere all'
       </trans-unit>
       <trans-unit id="Silent">
         <source>Silent</source>
-        <target state="new">Silent</target>
+        <target state="translated">Silent</target>
         <note />
       </trans-unit>
       <trans-unit id="Sort_accessibility_modifiers">
@@ -2362,12 +2362,12 @@ Le asserzioni lookbehind positive di larghezza zero vengono usate in genere all'
       </trans-unit>
       <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
         <source>Source code language information was not found in PDB.</source>
-        <target state="new">Source code language information was not found in PDB.</target>
+        <target state="translated">Le informazioni sul linguaggio del codice sorgente non sono state trovate nel PDB.</target>
         <note />
       </trans-unit>
       <trans-unit id="Source_is_a_reference_assembly">
         <source>Source is a reference assembly, not enough information to find PDB.</source>
-        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <target state="translated">L'origine è un assembly di riferimento, informazioni insufficienti per trovare il PDB.</target>
         <note />
       </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
@@ -2397,7 +2397,7 @@ Le asserzioni lookbehind positive di larghezza zero vengono usate in genere all'
       </trans-unit>
       <trans-unit id="Symbol_found_in_assembly_path_0">
         <source>Symbol found in assembly path '{0}'</source>
-        <target state="new">Symbol found in assembly path '{0}'</target>
+        <target state="translated">Simbolo trovato nel percorso assembly '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
@@ -2427,12 +2427,12 @@ Le asserzioni lookbehind positive di larghezza zero vengono usate in genere all'
       </trans-unit>
       <trans-unit id="Timeout_SourceLink">
         <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <target state="translated">Timeout durante il tentativo di scaricare il codice sorgente da SourceLink. Le richieste successive potrebbero avere esito positivo.</target>
         <note />
       </trans-unit>
       <trans-unit id="Timeout_symbol_server">
         <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <target state="translated">Timeout durante il tentativo di scaricare PDB dal server dei simboli. Le richieste successive potrebbero avere esito positivo.</target>
         <note />
       </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
@@ -2447,7 +2447,7 @@ Le asserzioni lookbehind positive di larghezza zero vengono usate in genere all'
       </trans-unit>
       <trans-unit id="Types_colon">
         <source>Types:</source>
-        <target state="new">Types:</target>
+        <target state="translated">Tipi:</target>
         <note />
       </trans-unit>
       <trans-unit id="UnableToReadSourceFileOrPdb">
@@ -2737,42 +2737,42 @@ Le asserzioni lookbehind positive di larghezza zero vengono usate in genere all'
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB">
         <source>'{0}' found in embedded PDB.</source>
-        <target state="new">'{0}' found in embedded PDB.</target>
+        <target state="translated">'{0}' trovati nel PDB incorporato.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
         <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">'{0}' è stato trovato nel PDB incorporato, ma il checksum non è corretto o non è stato possibile leggere il file temporaneo.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
         <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
-        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <target state="translated">'{0}' trovato nel PDB incorporato ma non è stato possibile scrivere nel file temporaneo: '{1}'</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
         <source>'{0}' found in embedded PDB and found cached source file.</source>
-        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <target state="translated">'{0}' trovato nel PDB incorporato e trovato file di origine memorizzato nella cache.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location">
         <source>'{0}' found in original location.</source>
-        <target state="new">'{0}' found in original location.</target>
+        <target state="translated">'{0}' trovato nella posizione originale.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location_but_checksum_failed">
         <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">'{0}' trovato nel percorso originale, ma il checksum non è corretto o non è stato possibile leggere il file temporaneo.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink">
         <source>'{0}' found via SourceLink.</source>
-        <target state="new">'{0}' found via SourceLink.</target>
+        <target state="translated">'{0}' trovato tramite SourceLink.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
         <source>'{0}' found via SourceLink but couldn't read temp file.</source>
-        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <target state="translated">'{0}' trovato tramite SourceLink ma non è stato possibile leggere il file temporaneo.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_is_not_null_here">
@@ -3105,12 +3105,12 @@ Se l'identificatore di formato "d" viene usato senza altri identificatori di for
       </trans-unit>
       <trans-unit id="embedded">
         <source>embedded</source>
-        <target state="new">embedded</target>
+        <target state="translated">Incorporata</target>
         <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
       </trans-unit>
       <trans-unit id="external">
         <source>external</source>
-        <target state="new">external</target>
+        <target state="translated">external</target>
         <note>External means "external source", meaning source files that are not part of the current solution</note>
       </trans-unit>
       <trans-unit id="from_metadata">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf
index 44a887be830c0..ca2c7e0fc26b5 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf
@@ -242,12 +242,12 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression">
         <source>Await the preceding expression</source>
-        <target state="new">Await the preceding expression</target>
+        <target state="translated">前の式を待機する</target>
         <note />
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression_and_add_ConfigureAwait_0">
         <source>Await the preceding expression and add ConfigureAwait({0}).</source>
-        <target state="new">Await the preceding expression and add ConfigureAwait({0}).</target>
+        <target state="translated">前の式を待機し、ConfigureAwait ({0}) を追加します。</target>
         <note>{Locked="ConfigureAwait"} "ConfigureAwait" is an api name and should not be localized. {0} is a placeholder for the language specific keyword 'false'.</note>
       </trans-unit>
       <trans-unit id="Awaited_task_returns_0">
@@ -472,12 +472,12 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
         <source>Could not find portable PDB on disk or embedded.</source>
-        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <target state="translated">ポータブル PDB がディスクまたは埋め込みで見つかりませんでした。</target>
         <note />
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
         <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
-        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <target state="translated">ディスク、埋め込み、またはシンボル サーバーで PDB が見つかりませんでした。</target>
         <note />
       </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
@@ -562,7 +562,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Error_reading_PDB_0">
         <source>Error reading PDB: '{0}'</source>
-        <target state="new">Error reading PDB: '{0}'</target>
+        <target state="translated">PDB: '{0}' の読み込み中にエラーが発生した</target>
         <note />
       </trans-unit>
       <trans-unit id="Example">
@@ -582,7 +582,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Explicitly_inherit_documentation">
         <source>Explicitly inherit documentation</source>
-        <target state="new">Explicitly inherit documentation</target>
+        <target state="translated">ドキュメントを明示的に継承する</target>
         <note />
       </trans-unit>
       <trans-unit id="Extract_base_class">
@@ -632,32 +632,32 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Found_PDB_file_at_0">
         <source>Found PDB file at '{0}'</source>
-        <target state="new">Found PDB file at '{0}'</target>
+        <target state="translated">'{0}' で PDB ファイルが見つかりました</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server">
         <source>Found PDB on symbol server.</source>
-        <target state="new">Found PDB on symbol server.</target>
+        <target state="translated">シンボル サーバーで PDB が見つかりました。</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
         <source>Found PDB on symbol server but could not read file.</source>
-        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <target state="translated">シンボル サーバーで PDB が見つかりましたが、ファイルを読み取ることができませんでした。</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_embedded_PDB_file">
         <source>Found embedded PDB file.</source>
-        <target state="new">Found embedded PDB file.</target>
+        <target state="translated">埋め込み PDB ファイルが見つかりました。</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
-        <target state="new">Generate abstract method '{0}'</target>
+        <target state="translated">抽象メソッド '{0}' を生成する</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_property_0">
         <source>Generate abstract property '{0}'</source>
-        <target state="new">Generate abstract property '{0}'</target>
+        <target state="translated">抽象プロパティ '{0}' を生成する</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_comparison_operators">
@@ -667,7 +667,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Generate_constant_0">
         <source>Generate constant '{0}'</source>
-        <target state="new">Generate constant '{0}'</target>
+        <target state="translated">定数 '{0}' を生成する</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_constructor_in_0_with_fields">
@@ -682,12 +682,12 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Generate_enum_member_0">
         <source>Generate enum member '{0}'</source>
-        <target state="new">Generate enum member '{0}'</target>
+        <target state="translated">列挙型メンバー '{0}' を生成する</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_field_0">
         <source>Generate field '{0}'</source>
-        <target state="new">Generate field '{0}'</target>
+        <target state="translated">フィールド '{0}' を生成する</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_for_0">
@@ -697,7 +697,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Generate_method_0">
         <source>Generate method '{0}'</source>
-        <target state="new">Generate method '{0}'</target>
+        <target state="translated">メソッド '{0}' を生成する</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_parameter_0">
@@ -712,17 +712,17 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Generate_property_0">
         <source>Generate property '{0}'</source>
-        <target state="new">Generate property '{0}'</target>
+        <target state="translated">プロパティ '{0}' を生成する</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_field_0">
         <source>Generate read-only field '{0}'</source>
-        <target state="new">Generate read-only field '{0}'</target>
+        <target state="translated">読み取り専用フィールド '{0}' を生成する</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_property_0">
         <source>Generate read-only property '{0}'</source>
-        <target state="new">Generate read-only property '{0}'</target>
+        <target state="translated">読み取り専用プロパティ '{0}' を生成する</target>
         <note />
       </trans-unit>
       <trans-unit id="Illegal_backslash_at_end_of_pattern">
@@ -947,7 +947,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Miscellaneous_Files">
         <source>Miscellaneous Files</source>
-        <target state="new">Miscellaneous Files</target>
+        <target state="translated">その他のファイル</target>
         <note />
       </trans-unit>
       <trans-unit id="Missing_control_character">
@@ -1057,7 +1057,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type">
         <source>Move static members to another type...</source>
-        <target state="new">Move static members to another type...</target>
+        <target state="translated">静的メンバーを別の型に移行する...</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -1072,7 +1072,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Navigating_to_symbol_0_from_1">
         <source>Navigating to symbol '{0}' from '{1}'.</source>
-        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <target state="translated">"{1}" からシンボル '{0}' に移動しています。</target>
         <note />
       </trans-unit>
       <trans-unit id="Nested_quantifier_0">
@@ -1087,7 +1087,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="No_source_document_info_found_in_PDB">
         <source>No source document info found in PDB.</source>
-        <target state="new">No source document info found in PDB.</target>
+        <target state="translated">PDB にソース ドキュメント情報が見つかりません。</target>
         <note />
       </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
@@ -1275,11 +1275,11 @@ This option is recommended if you know that backtracking will not succeed. Preve
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
+        <target state="translated">グループ定義の均等化では、既に定義されていたグループの定義を削除し、現在のグループにおいて、既に定義されていたグループと現在のグループの間の差分を保存します。
 
-'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+ "name1" は現在のグループ (オプション) で、"name2" は既に定義されていたグループで、"subexpression" は有効な正規表現パターンです。グループ定義の均等化では、name2 の定義を削除し、name2 と name1 の間の差分を name1 に格納します。name2 グループが定義されていない場合、一致は差し戻します。name2 の最新の定義を削除すると、name2 の以前の定義が明らかになるため、このコンストラクトによって、かっこや左右の角かっこなど入れ子になったコンストラクトを追跡するカウンターとして name2 グループのキャプチャのスタックを使用できます。
 
-The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
+グループ定義の均等化では、"name2" をスタックとして使用します。入れ子になった各コンストラクトの開始文字が、グループとその Group.Captures コレクションに配置されます。終了文字が一致すると、対応する開始文字がグループから削除され、Captures コレクションが 1 つ減らされます。入れ子になったすべてのコンストラクトの開始文字と終了文字が一致したら、"name1" は空になります。</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
@@ -2352,7 +2352,7 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Silent">
         <source>Silent</source>
-        <target state="new">Silent</target>
+        <target state="translated">サイレント</target>
         <note />
       </trans-unit>
       <trans-unit id="Sort_accessibility_modifiers">
@@ -2362,12 +2362,12 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
         <source>Source code language information was not found in PDB.</source>
-        <target state="new">Source code language information was not found in PDB.</target>
+        <target state="translated">PDB にソース コードのプログラミング言語情報が見つかりませんでした。</target>
         <note />
       </trans-unit>
       <trans-unit id="Source_is_a_reference_assembly">
         <source>Source is a reference assembly, not enough information to find PDB.</source>
-        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <target state="translated">ソースは参照アセンブリであり、PDB を見つけるのに十分な情報がありません。</target>
         <note />
       </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
@@ -2397,7 +2397,7 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Symbol_found_in_assembly_path_0">
         <source>Symbol found in assembly path '{0}'</source>
-        <target state="new">Symbol found in assembly path '{0}'</target>
+        <target state="translated">アセンブリ パス '{0}' にシンボルが見つかりました</target>
         <note />
       </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
@@ -2427,12 +2427,12 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Timeout_SourceLink">
         <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <target state="translated">SourceLink からソース コードをダウンロードしようとしてタイムアウトしました。後続の要求は成功する可能性があります。</target>
         <note />
       </trans-unit>
       <trans-unit id="Timeout_symbol_server">
         <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <target state="translated">シンボル サーバーから PDB をダウンロードしようとしてタイムアウトしました。後続の要求は成功する可能性があります。</target>
         <note />
       </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
@@ -2447,7 +2447,7 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Types_colon">
         <source>Types:</source>
-        <target state="new">Types:</target>
+        <target state="translated">型:</target>
         <note />
       </trans-unit>
       <trans-unit id="UnableToReadSourceFileOrPdb">
@@ -2737,42 +2737,42 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB">
         <source>'{0}' found in embedded PDB.</source>
-        <target state="new">'{0}' found in embedded PDB.</target>
+        <target state="translated">埋め込み PDB に '{0}' が見つかりました。</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
         <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">埋め込み PDB に '{0}' が見つかりましたが、チェックサムが正しくないか、一時ファイルを読み取れませんでした。</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
         <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
-        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <target state="translated">埋め込み PDB に '{0}' が見つかりましたが、一時ファイルに書き込めませんでした: "{1}"</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
         <source>'{0}' found in embedded PDB and found cached source file.</source>
-        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <target state="translated">埋め込み PDB に '{0}' が見つかり、キャッシュされたソース ファイルが見つかりました。</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location">
         <source>'{0}' found in original location.</source>
-        <target state="new">'{0}' found in original location.</target>
+        <target state="translated">元の場所に '{0}' が見つかりました。</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location_but_checksum_failed">
         <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">元の場所に '{0}' が見つかりましたが、チェックサムが正しくないか、一時ファイルを読み取れませんでした。</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink">
         <source>'{0}' found via SourceLink.</source>
-        <target state="new">'{0}' found via SourceLink.</target>
+        <target state="translated">'{0}' が SourceLink を通じて見つかりました。</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
         <source>'{0}' found via SourceLink but couldn't read temp file.</source>
-        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <target state="translated">'{0}' が SourceLink を通じて見つかりましたが、一時ファイルを読み取ることができませんでした。</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_is_not_null_here">
@@ -3105,12 +3105,12 @@ If the "d" format specifier is used without other custom format specifiers, it's
       </trans-unit>
       <trans-unit id="embedded">
         <source>embedded</source>
-        <target state="new">embedded</target>
+        <target state="translated">埋め込み</target>
         <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
       </trans-unit>
       <trans-unit id="external">
         <source>external</source>
-        <target state="new">external</target>
+        <target state="translated">外部</target>
         <note>External means "external source", meaning source files that are not part of the current solution</note>
       </trans-unit>
       <trans-unit id="from_metadata">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf
index ebfa13a27f00a..da2341fce4044 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf
@@ -242,12 +242,12 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression">
         <source>Await the preceding expression</source>
-        <target state="new">Await the preceding expression</target>
+        <target state="translated">이전 식을 기다립니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression_and_add_ConfigureAwait_0">
         <source>Await the preceding expression and add ConfigureAwait({0}).</source>
-        <target state="new">Await the preceding expression and add ConfigureAwait({0}).</target>
+        <target state="translated">이전 식을 기다리고 ConfigureAwait({0})를 추가합니다.</target>
         <note>{Locked="ConfigureAwait"} "ConfigureAwait" is an api name and should not be localized. {0} is a placeholder for the language specific keyword 'false'.</note>
       </trans-unit>
       <trans-unit id="Awaited_task_returns_0">
@@ -472,12 +472,12 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
         <source>Could not find portable PDB on disk or embedded.</source>
-        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <target state="translated">디스크 또는 포함에서 이식 가능한 PDB를 찾을 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
         <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
-        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <target state="translated">디스크에서 PDB를 찾거나 포함된 PDB 또는 기호 서버에서 PDB를 찾을 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
@@ -562,7 +562,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Error_reading_PDB_0">
         <source>Error reading PDB: '{0}'</source>
-        <target state="new">Error reading PDB: '{0}'</target>
+        <target state="translated">PDB를 읽는 동안 오류 발생: '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Example">
@@ -582,7 +582,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Explicitly_inherit_documentation">
         <source>Explicitly inherit documentation</source>
-        <target state="new">Explicitly inherit documentation</target>
+        <target state="translated">명시적으로 상속 문서</target>
         <note />
       </trans-unit>
       <trans-unit id="Extract_base_class">
@@ -632,32 +632,32 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Found_PDB_file_at_0">
         <source>Found PDB file at '{0}'</source>
-        <target state="new">Found PDB file at '{0}'</target>
+        <target state="translated">'{0}'에서 PDB 파일을 찾음</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server">
         <source>Found PDB on symbol server.</source>
-        <target state="new">Found PDB on symbol server.</target>
+        <target state="translated">기호 서버에서 PDB를 찾았습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
         <source>Found PDB on symbol server but could not read file.</source>
-        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <target state="translated">기호 서버에서 PDB를 찾았지만 파일을 읽을 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_embedded_PDB_file">
         <source>Found embedded PDB file.</source>
-        <target state="new">Found embedded PDB file.</target>
+        <target state="translated">포함된 PDB 파일을 찾았습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
-        <target state="new">Generate abstract method '{0}'</target>
+        <target state="translated">'{0}' 요약 메서드 생성</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_property_0">
         <source>Generate abstract property '{0}'</source>
-        <target state="new">Generate abstract property '{0}'</target>
+        <target state="translated">'{0}' 요약 속성 생성</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_comparison_operators">
@@ -667,7 +667,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Generate_constant_0">
         <source>Generate constant '{0}'</source>
-        <target state="new">Generate constant '{0}'</target>
+        <target state="translated">'{0}' 상수 생성</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_constructor_in_0_with_fields">
@@ -682,12 +682,12 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Generate_enum_member_0">
         <source>Generate enum member '{0}'</source>
-        <target state="new">Generate enum member '{0}'</target>
+        <target state="translated">'{0}' 열거형 멤버 생성</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_field_0">
         <source>Generate field '{0}'</source>
-        <target state="new">Generate field '{0}'</target>
+        <target state="translated">'{0}' 필드 생성</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_for_0">
@@ -697,7 +697,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Generate_method_0">
         <source>Generate method '{0}'</source>
-        <target state="new">Generate method '{0}'</target>
+        <target state="translated">‘{0}’ 메서드 생성</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_parameter_0">
@@ -712,17 +712,17 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Generate_property_0">
         <source>Generate property '{0}'</source>
-        <target state="new">Generate property '{0}'</target>
+        <target state="translated">'{0}' 속성 생성</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_field_0">
         <source>Generate read-only field '{0}'</source>
-        <target state="new">Generate read-only field '{0}'</target>
+        <target state="translated">'{0}' 읽기 전용 필드 생성</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_property_0">
         <source>Generate read-only property '{0}'</source>
-        <target state="new">Generate read-only property '{0}'</target>
+        <target state="translated">'{0}' 읽기 전용 속성 생성</target>
         <note />
       </trans-unit>
       <trans-unit id="Illegal_backslash_at_end_of_pattern">
@@ -947,7 +947,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Miscellaneous_Files">
         <source>Miscellaneous Files</source>
-        <target state="new">Miscellaneous Files</target>
+        <target state="translated">기타 파일</target>
         <note />
       </trans-unit>
       <trans-unit id="Missing_control_character">
@@ -1057,7 +1057,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type">
         <source>Move static members to another type...</source>
-        <target state="new">Move static members to another type...</target>
+        <target state="translated">정적 멤버를 다른 형식으로 이동...</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -1072,7 +1072,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Navigating_to_symbol_0_from_1">
         <source>Navigating to symbol '{0}' from '{1}'.</source>
-        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <target state="translated">'{1}'에서 기호 '{0}'(으)로 이동하는 중입니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="Nested_quantifier_0">
@@ -1087,7 +1087,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="No_source_document_info_found_in_PDB">
         <source>No source document info found in PDB.</source>
-        <target state="new">No source document info found in PDB.</target>
+        <target state="translated">PDB에서 원본 문서 정보를 찾을 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
@@ -1275,11 +1275,11 @@ This option is recommended if you know that backtracking will not succeed. Preve
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
+        <target state="translated">균형 조정 그룹 정의는 이전에 정의된 그룹의 정의를 삭제하고, 이전에 정의된 그룹과 현재 그룹 사이의 간격을 현재 그룹에 저장합니다.
 
-'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+'name1'은 현재 그룹이고(선택 사항), 'name2'는 이전에 정의된 그룹이며, 'subexpression'은 유효한 정규식 패턴입니다. 균형 조정 그룹 정의는 name2의 정의를 삭제하고 name2와 name1 사이의 간격을 name1에 저장합니다. name2 그룹이 정의되어 있지 않으면 일치에서 역추적합니다. name2의 마지막 정의를 삭제하면 name2의 이전 정의가 표시되므로 이 구문을 통해 name2 그룹에 대한 캡처 스택을 괄호 또는 여는 대괄호 및 닫는 대괄호와 같은 중첩 구문을 추적하기 위한 카운터로 사용할 수 있습니다.
 
-The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
+균형 조정 그룹 정의에서는 'name2'를 스택으로 사용합니다. 각 중첩 구문의 시작 문자는 그룹 및 해당 Group.Captures 컬렉션에 배치됩니다. 닫는 문자가 일치되면 해당하는 여는 문자가 그룹에서 제거되고 Captures 컬렉션이 하나 감소합니다. 모든 중첩 구문의 여는 문자와 닫는 문자가 일치되고 나면 'name1'은 비어 있는 상태가 됩니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
@@ -2352,7 +2352,7 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Silent">
         <source>Silent</source>
-        <target state="new">Silent</target>
+        <target state="translated">침묵</target>
         <note />
       </trans-unit>
       <trans-unit id="Sort_accessibility_modifiers">
@@ -2362,12 +2362,12 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
         <source>Source code language information was not found in PDB.</source>
-        <target state="new">Source code language information was not found in PDB.</target>
+        <target state="translated">PDB에서 원본 코드 언어 정보를 찾을 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="Source_is_a_reference_assembly">
         <source>Source is a reference assembly, not enough information to find PDB.</source>
-        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <target state="translated">원본은 참조 어셈블리이며 PDB를 찾을 수 있는 정보가 부족합니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
@@ -2397,7 +2397,7 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Symbol_found_in_assembly_path_0">
         <source>Symbol found in assembly path '{0}'</source>
-        <target state="new">Symbol found in assembly path '{0}'</target>
+        <target state="translated">어셈블리 경로 '{0}'에서 기호를 찾음</target>
         <note />
       </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
@@ -2427,12 +2427,12 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Timeout_SourceLink">
         <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <target state="translated">SourceLink에서 원본 코드를 다운로드하는 동안 시간이 초과되었습니다. 후속 요청이 성공할 수 있습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="Timeout_symbol_server">
         <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <target state="translated">기호 서버에서 PDB를 다운로드하는 동안 시간이 초과되었습니다. 후속 요청이 성공할 수 있습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
@@ -2447,7 +2447,7 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Types_colon">
         <source>Types:</source>
-        <target state="new">Types:</target>
+        <target state="translated">형식:</target>
         <note />
       </trans-unit>
       <trans-unit id="UnableToReadSourceFileOrPdb">
@@ -2737,42 +2737,42 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB">
         <source>'{0}' found in embedded PDB.</source>
-        <target state="new">'{0}' found in embedded PDB.</target>
+        <target state="translated">포함된 PDB에서 '{0}'을(를) 찾았습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
         <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">포함된 PDB에서 '{0}'을(를) 찾았지만 체크섬이 잘못되었거나 임시 파일을 읽을 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
         <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
-        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <target state="translated">포함된 PDB에서 '{0}'을 찾았지만 임시 파일 '{1}'에 쓸 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
         <source>'{0}' found in embedded PDB and found cached source file.</source>
-        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <target state="translated">포함된 PDB에서 '{0}'을(를) 찾았으며 캐시된 원본 파일을 찾았습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location">
         <source>'{0}' found in original location.</source>
-        <target state="new">'{0}' found in original location.</target>
+        <target state="translated">원래 위치에 '{0}'이(가) 있습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location_but_checksum_failed">
         <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">'{0}'이(가) 원래 위치에서 발견되었지만 체크섬이 잘못되었거나 임시 파일을 읽을 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink">
         <source>'{0}' found via SourceLink.</source>
-        <target state="new">'{0}' found via SourceLink.</target>
+        <target state="translated">SourceLink를 통해 '{0}'을(를) 찾았습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
         <source>'{0}' found via SourceLink but couldn't read temp file.</source>
-        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <target state="translated">SourceLink를 통해 '{0}'을(를) 찾았지만 임시 파일을 읽을 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_is_not_null_here">
@@ -3105,12 +3105,12 @@ If the "d" format specifier is used without other custom format specifiers, it's
       </trans-unit>
       <trans-unit id="embedded">
         <source>embedded</source>
-        <target state="new">embedded</target>
+        <target state="translated">포함됨</target>
         <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
       </trans-unit>
       <trans-unit id="external">
         <source>external</source>
-        <target state="new">external</target>
+        <target state="translated">외부</target>
         <note>External means "external source", meaning source files that are not part of the current solution</note>
       </trans-unit>
       <trans-unit id="from_metadata">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf
index 49e4074b833bc..ca0c8d5f25aa4 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf
@@ -242,12 +242,12 @@ Pamiętaj, aby nie używać specyfikatora „tt” dla wszystkich języków, w k
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression">
         <source>Await the preceding expression</source>
-        <target state="new">Await the preceding expression</target>
+        <target state="translated">Oczekuj poprzedniego wyrażenia</target>
         <note />
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression_and_add_ConfigureAwait_0">
         <source>Await the preceding expression and add ConfigureAwait({0}).</source>
-        <target state="new">Await the preceding expression and add ConfigureAwait({0}).</target>
+        <target state="translated">Oczekuj poprzedniego wyrażenia i dodaj ConfigureAwait({0}).</target>
         <note>{Locked="ConfigureAwait"} "ConfigureAwait" is an api name and should not be localized. {0} is a placeholder for the language specific keyword 'false'.</note>
       </trans-unit>
       <trans-unit id="Awaited_task_returns_0">
@@ -472,12 +472,12 @@ Pamiętaj, aby nie używać specyfikatora „tt” dla wszystkich języków, w k
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
         <source>Could not find portable PDB on disk or embedded.</source>
-        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <target state="translated">Nie można odnaleźć przenośnego pliku PDB na dysku lub w trybie osadzonym.</target>
         <note />
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
         <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
-        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <target state="translated">Nie można odnaleźć pliku PDB na dysku, w trybie osadzonym lub na serwerze symboli.</target>
         <note />
       </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
@@ -562,7 +562,7 @@ Pamiętaj, aby nie używać specyfikatora „tt” dla wszystkich języków, w k
       </trans-unit>
       <trans-unit id="Error_reading_PDB_0">
         <source>Error reading PDB: '{0}'</source>
-        <target state="new">Error reading PDB: '{0}'</target>
+        <target state="translated">Błąd podczas odczytywania pliku PDB: „{0}”</target>
         <note />
       </trans-unit>
       <trans-unit id="Example">
@@ -582,7 +582,7 @@ Pamiętaj, aby nie używać specyfikatora „tt” dla wszystkich języków, w k
       </trans-unit>
       <trans-unit id="Explicitly_inherit_documentation">
         <source>Explicitly inherit documentation</source>
-        <target state="new">Explicitly inherit documentation</target>
+        <target state="translated">Wyraźnie dziedziczona dokumentacja</target>
         <note />
       </trans-unit>
       <trans-unit id="Extract_base_class">
@@ -632,32 +632,32 @@ Pamiętaj, aby nie używać specyfikatora „tt” dla wszystkich języków, w k
       </trans-unit>
       <trans-unit id="Found_PDB_file_at_0">
         <source>Found PDB file at '{0}'</source>
-        <target state="new">Found PDB file at '{0}'</target>
+        <target state="translated">Znaleziono plik PDB w lokalizacji „{0}”</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server">
         <source>Found PDB on symbol server.</source>
-        <target state="new">Found PDB on symbol server.</target>
+        <target state="translated">Znaleziono plik PDB na serwerze symboli.</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
         <source>Found PDB on symbol server but could not read file.</source>
-        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <target state="translated">Znaleziono plik PDB na serwerze symboli, ale nie można było odczytać pliku.</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_embedded_PDB_file">
         <source>Found embedded PDB file.</source>
-        <target state="new">Found embedded PDB file.</target>
+        <target state="translated">Znaleziono osadzony plik PDB.</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
-        <target state="new">Generate abstract method '{0}'</target>
+        <target state="translated">Generuj metodę abstrakcyjną „{0}”</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_property_0">
         <source>Generate abstract property '{0}'</source>
-        <target state="new">Generate abstract property '{0}'</target>
+        <target state="translated">Generuj właściwość abstrakcyjną „{0}”</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_comparison_operators">
@@ -667,7 +667,7 @@ Pamiętaj, aby nie używać specyfikatora „tt” dla wszystkich języków, w k
       </trans-unit>
       <trans-unit id="Generate_constant_0">
         <source>Generate constant '{0}'</source>
-        <target state="new">Generate constant '{0}'</target>
+        <target state="translated">Generuj stałą „{0}”</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_constructor_in_0_with_fields">
@@ -682,12 +682,12 @@ Pamiętaj, aby nie używać specyfikatora „tt” dla wszystkich języków, w k
       </trans-unit>
       <trans-unit id="Generate_enum_member_0">
         <source>Generate enum member '{0}'</source>
-        <target state="new">Generate enum member '{0}'</target>
+        <target state="translated">Generuj składową wyliczenia „{0}”</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_field_0">
         <source>Generate field '{0}'</source>
-        <target state="new">Generate field '{0}'</target>
+        <target state="translated">Generuj pole „{0}”</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_for_0">
@@ -697,7 +697,7 @@ Pamiętaj, aby nie używać specyfikatora „tt” dla wszystkich języków, w k
       </trans-unit>
       <trans-unit id="Generate_method_0">
         <source>Generate method '{0}'</source>
-        <target state="new">Generate method '{0}'</target>
+        <target state="translated">Generuj metodę „{0}”</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_parameter_0">
@@ -712,17 +712,17 @@ Pamiętaj, aby nie używać specyfikatora „tt” dla wszystkich języków, w k
       </trans-unit>
       <trans-unit id="Generate_property_0">
         <source>Generate property '{0}'</source>
-        <target state="new">Generate property '{0}'</target>
+        <target state="translated">Generuj właściwość „{0}”</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_field_0">
         <source>Generate read-only field '{0}'</source>
-        <target state="new">Generate read-only field '{0}'</target>
+        <target state="translated">Generuj pole tylko do odczytu „{0}”</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_property_0">
         <source>Generate read-only property '{0}'</source>
-        <target state="new">Generate read-only property '{0}'</target>
+        <target state="translated">Generuj właściwość tylko do odczytu „{0}”</target>
         <note />
       </trans-unit>
       <trans-unit id="Illegal_backslash_at_end_of_pattern">
@@ -947,7 +947,7 @@ Pamiętaj, aby nie używać specyfikatora „tt” dla wszystkich języków, w k
       </trans-unit>
       <trans-unit id="Miscellaneous_Files">
         <source>Miscellaneous Files</source>
-        <target state="new">Miscellaneous Files</target>
+        <target state="translated">Różne pliki</target>
         <note />
       </trans-unit>
       <trans-unit id="Missing_control_character">
@@ -1057,7 +1057,7 @@ Pamiętaj, aby nie używać specyfikatora „tt” dla wszystkich języków, w k
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type">
         <source>Move static members to another type...</source>
-        <target state="new">Move static members to another type...</target>
+        <target state="translated">Przenieś statyczne składowe do innego typu...</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -1072,7 +1072,7 @@ Pamiętaj, aby nie używać specyfikatora „tt” dla wszystkich języków, w k
       </trans-unit>
       <trans-unit id="Navigating_to_symbol_0_from_1">
         <source>Navigating to symbol '{0}' from '{1}'.</source>
-        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <target state="translated">Trwa przechodzenie do symbolu „{0}” z „{1}”.</target>
         <note />
       </trans-unit>
       <trans-unit id="Nested_quantifier_0">
@@ -1087,7 +1087,7 @@ Pamiętaj, aby nie używać specyfikatora „tt” dla wszystkich języków, w k
       </trans-unit>
       <trans-unit id="No_source_document_info_found_in_PDB">
         <source>No source document info found in PDB.</source>
-        <target state="new">No source document info found in PDB.</target>
+        <target state="translated">Nie znaleziono informacji o dokumencie źródłowym w pliku PDB.</target>
         <note />
       </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
@@ -1275,11 +1275,11 @@ Ta opcja jest zalecana, jeśli wiesz, że cofanie się nie powiedzie się. Zapob
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
+        <target state="translated">Definicja grupy dopasowywania usuwa definicję uprzednio sprecyzowanej grupy i zapisuje w aktualnej grupie interwał między poprzednio zdefiniowaną grupą a aktualną grupą.
 
-'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+Element „name1” to aktualna grupa (opcjonalna), element „name2” to wcześniej zdefiniowana grupa, a element „subexpression” to dowolny prawidłowy wzorzec wyrażenia regularnego. Definicja grupy dopasowywania usuwa definicję elementu name2 i zapisuje interwał między elementami name2 i name1 w elemencie name1. Jeśli nie zdefiniowano grupy name2, następują śledzenia wsteczne dopasowania. Ponieważ usunięcie ostatniej definicji elementu name2 ujawnia jego poprzednią definicję, ta konstrukcja umożliwia użycie stosu przechwyceń dla grupy name2 jako licznika służącego do śledzenia zagnieżdżonych konstrukcji, takich jak nawiasy lub otwierające i zamykające nawiasy klamrowe.
 
-The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
+Definicja grupy dopasowywania używa elementu „name2” jako stosu. Początkowy znak każdej zagnieżdżonej konstrukcji jest umieszczany w grupie i w jej kolekcji Group.Captures. Po dopasowaniu znaku zamykającego odpowiadający mu znak otwierający jest usuwany z grupy, a kolekcja Captures jest zmniejszana o jeden. Po dopasowaniu otwierających i zamykających znaków wszystkich zagnieżdżonych konstrukcji element „name1” będzie pusty.</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
@@ -2352,7 +2352,7 @@ Pozytywne asercje wsteczne o zerowej szerokości są zwykle używane na początk
       </trans-unit>
       <trans-unit id="Silent">
         <source>Silent</source>
-        <target state="new">Silent</target>
+        <target state="translated">Cichy</target>
         <note />
       </trans-unit>
       <trans-unit id="Sort_accessibility_modifiers">
@@ -2362,12 +2362,12 @@ Pozytywne asercje wsteczne o zerowej szerokości są zwykle używane na początk
       </trans-unit>
       <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
         <source>Source code language information was not found in PDB.</source>
-        <target state="new">Source code language information was not found in PDB.</target>
+        <target state="translated">Nie znaleziono informacji o języku kodu źródłowego w pliku PDB.</target>
         <note />
       </trans-unit>
       <trans-unit id="Source_is_a_reference_assembly">
         <source>Source is a reference assembly, not enough information to find PDB.</source>
-        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <target state="translated">Źródło jest zestawem odwołania, brak wystarczających informacji do znalezienia pliku PDB.</target>
         <note />
       </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
@@ -2397,7 +2397,7 @@ Pozytywne asercje wsteczne o zerowej szerokości są zwykle używane na początk
       </trans-unit>
       <trans-unit id="Symbol_found_in_assembly_path_0">
         <source>Symbol found in assembly path '{0}'</source>
-        <target state="new">Symbol found in assembly path '{0}'</target>
+        <target state="translated">Znaleziono symbol w ścieżce zestawu „{0}”</target>
         <note />
       </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
@@ -2427,12 +2427,12 @@ Pozytywne asercje wsteczne o zerowej szerokości są zwykle używane na początk
       </trans-unit>
       <trans-unit id="Timeout_SourceLink">
         <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <target state="translated">Przekroczono limit czasu podczas próby pobrania kodu źródłowego z elementu SourceLink. Kolejne żądania mogą zakończyć się pomyślnie.</target>
         <note />
       </trans-unit>
       <trans-unit id="Timeout_symbol_server">
         <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <target state="translated">Przekroczono limit czasu podczas próby pobrania pliku PDB z serwera symboli. Kolejne żądania mogą zakończyć się pomyślnie.</target>
         <note />
       </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
@@ -2447,7 +2447,7 @@ Pozytywne asercje wsteczne o zerowej szerokości są zwykle używane na początk
       </trans-unit>
       <trans-unit id="Types_colon">
         <source>Types:</source>
-        <target state="new">Types:</target>
+        <target state="translated">Typy:</target>
         <note />
       </trans-unit>
       <trans-unit id="UnableToReadSourceFileOrPdb">
@@ -2737,42 +2737,42 @@ Pozytywne asercje wsteczne o zerowej szerokości są zwykle używane na początk
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB">
         <source>'{0}' found in embedded PDB.</source>
-        <target state="new">'{0}' found in embedded PDB.</target>
+        <target state="translated">Znaleziono „{0}” w osadzonym pliku PDB.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
         <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">Znaleziono „{0}” w osadzonym pliku PDB, ale suma kontrolna była nieprawidłowa lub nie można było odczytać pliku tymczasowego.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
         <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
-        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <target state="translated">Znaleziono „{0}” w osadzonym pliku PDB, ale nie można było zapisać do pliku tymczasowego: „{1}”</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
         <source>'{0}' found in embedded PDB and found cached source file.</source>
-        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <target state="translated">Znaleziono „{0}” w osadzonym pliku PDB i znaleziono buforowany plik źródłowy.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location">
         <source>'{0}' found in original location.</source>
-        <target state="new">'{0}' found in original location.</target>
+        <target state="translated">Znaleziono „{0}” w oryginalnej lokalizacji.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location_but_checksum_failed">
         <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">Znaleziono „{0}” w oryginalnej lokalizacji, ale suma kontrolna była nieprawidłowa lub nie można było odczytać pliku tymczasowego.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink">
         <source>'{0}' found via SourceLink.</source>
-        <target state="new">'{0}' found via SourceLink.</target>
+        <target state="translated">Znaleziono „{0}” za pośrednictwem elementu SourceLink.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
         <source>'{0}' found via SourceLink but couldn't read temp file.</source>
-        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <target state="translated">Znaleziono „{0}” za pośrednictwem elementu SourceLink, ale nie można było odczytać pliku tymczasowego.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_is_not_null_here">
@@ -3105,12 +3105,12 @@ Jeśli specyfikator formatu „d” zostanie użyty bez innych indywidualnych sp
       </trans-unit>
       <trans-unit id="embedded">
         <source>embedded</source>
-        <target state="new">embedded</target>
+        <target state="translated">osadzone</target>
         <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
       </trans-unit>
       <trans-unit id="external">
         <source>external</source>
-        <target state="new">external</target>
+        <target state="translated">zewnętrzny</target>
         <note>External means "external source", meaning source files that are not part of the current solution</note>
       </trans-unit>
       <trans-unit id="from_metadata">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf
index 20478d1f97b63..a1ddedb268287 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf
@@ -242,12 +242,12 @@ Verifique se o especificador "tt" foi usado para idiomas para os quais é necess
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression">
         <source>Await the preceding expression</source>
-        <target state="new">Await the preceding expression</target>
+        <target state="translated">Aguarde a expressão anterior</target>
         <note />
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression_and_add_ConfigureAwait_0">
         <source>Await the preceding expression and add ConfigureAwait({0}).</source>
-        <target state="new">Await the preceding expression and add ConfigureAwait({0}).</target>
+        <target state="translated">Aguarde a expressão anterior e adicione ConfigureAwait ({0}).</target>
         <note>{Locked="ConfigureAwait"} "ConfigureAwait" is an api name and should not be localized. {0} is a placeholder for the language specific keyword 'false'.</note>
       </trans-unit>
       <trans-unit id="Awaited_task_returns_0">
@@ -472,12 +472,12 @@ Verifique se o especificador "tt" foi usado para idiomas para os quais é necess
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
         <source>Could not find portable PDB on disk or embedded.</source>
-        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <target state="translated">Não foi possível encontrar PDB portátil no disco ou incorporado.</target>
         <note />
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
         <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
-        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <target state="translated">Não foi possível localizar o PDB no disco, integrado ou em um servidor de símbolo.</target>
         <note />
       </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
@@ -562,7 +562,7 @@ Verifique se o especificador "tt" foi usado para idiomas para os quais é necess
       </trans-unit>
       <trans-unit id="Error_reading_PDB_0">
         <source>Error reading PDB: '{0}'</source>
-        <target state="new">Error reading PDB: '{0}'</target>
+        <target state="translated">Erro ao ler PDB: '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Example">
@@ -582,7 +582,7 @@ Verifique se o especificador "tt" foi usado para idiomas para os quais é necess
       </trans-unit>
       <trans-unit id="Explicitly_inherit_documentation">
         <source>Explicitly inherit documentation</source>
-        <target state="new">Explicitly inherit documentation</target>
+        <target state="translated">Herdar explicitamente a documentação</target>
         <note />
       </trans-unit>
       <trans-unit id="Extract_base_class">
@@ -632,32 +632,32 @@ Verifique se o especificador "tt" foi usado para idiomas para os quais é necess
       </trans-unit>
       <trans-unit id="Found_PDB_file_at_0">
         <source>Found PDB file at '{0}'</source>
-        <target state="new">Found PDB file at '{0}'</target>
+        <target state="translated">Arquivo PDB encontrado em '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server">
         <source>Found PDB on symbol server.</source>
-        <target state="new">Found PDB on symbol server.</target>
+        <target state="translated">PDB encontrado no servidor de símbolo.</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
         <source>Found PDB on symbol server but could not read file.</source>
-        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <target state="translated">PDB encontrado no servidor de símbolos, mas não foi possível ler o arquivo.</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_embedded_PDB_file">
         <source>Found embedded PDB file.</source>
-        <target state="new">Found embedded PDB file.</target>
+        <target state="translated">Arquivo PDB incorporado encontrado.</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
-        <target state="new">Generate abstract method '{0}'</target>
+        <target state="translated">Gerar o método abstrato '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_property_0">
         <source>Generate abstract property '{0}'</source>
-        <target state="new">Generate abstract property '{0}'</target>
+        <target state="translated">Gerar a propriedade abstrata '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_comparison_operators">
@@ -667,7 +667,7 @@ Verifique se o especificador "tt" foi usado para idiomas para os quais é necess
       </trans-unit>
       <trans-unit id="Generate_constant_0">
         <source>Generate constant '{0}'</source>
-        <target state="new">Generate constant '{0}'</target>
+        <target state="translated">Gerar constante '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_constructor_in_0_with_fields">
@@ -682,12 +682,12 @@ Verifique se o especificador "tt" foi usado para idiomas para os quais é necess
       </trans-unit>
       <trans-unit id="Generate_enum_member_0">
         <source>Generate enum member '{0}'</source>
-        <target state="new">Generate enum member '{0}'</target>
+        <target state="translated">Gerar o membro de enumeração '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_field_0">
         <source>Generate field '{0}'</source>
-        <target state="new">Generate field '{0}'</target>
+        <target state="translated">Gerar campo '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_for_0">
@@ -697,7 +697,7 @@ Verifique se o especificador "tt" foi usado para idiomas para os quais é necess
       </trans-unit>
       <trans-unit id="Generate_method_0">
         <source>Generate method '{0}'</source>
-        <target state="new">Generate method '{0}'</target>
+        <target state="translated">Gerar método '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_parameter_0">
@@ -712,17 +712,17 @@ Verifique se o especificador "tt" foi usado para idiomas para os quais é necess
       </trans-unit>
       <trans-unit id="Generate_property_0">
         <source>Generate property '{0}'</source>
-        <target state="new">Generate property '{0}'</target>
+        <target state="translated">Gerar propriedade '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_field_0">
         <source>Generate read-only field '{0}'</source>
-        <target state="new">Generate read-only field '{0}'</target>
+        <target state="translated">Gerar o campo somente leitura '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_property_0">
         <source>Generate read-only property '{0}'</source>
-        <target state="new">Generate read-only property '{0}'</target>
+        <target state="translated">Gerar a propriedade somente leitura '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Illegal_backslash_at_end_of_pattern">
@@ -947,7 +947,7 @@ Verifique se o especificador "tt" foi usado para idiomas para os quais é necess
       </trans-unit>
       <trans-unit id="Miscellaneous_Files">
         <source>Miscellaneous Files</source>
-        <target state="new">Miscellaneous Files</target>
+        <target state="translated">Arquivos Diversos</target>
         <note />
       </trans-unit>
       <trans-unit id="Missing_control_character">
@@ -1057,7 +1057,7 @@ Verifique se o especificador "tt" foi usado para idiomas para os quais é necess
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type">
         <source>Move static members to another type...</source>
-        <target state="new">Move static members to another type...</target>
+        <target state="translated">Mover membros estáticos para outro tipo...</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -1072,7 +1072,7 @@ Verifique se o especificador "tt" foi usado para idiomas para os quais é necess
       </trans-unit>
       <trans-unit id="Navigating_to_symbol_0_from_1">
         <source>Navigating to symbol '{0}' from '{1}'.</source>
-        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <target state="translated">Navegando para o símbolo '{0}' de '{1}'.</target>
         <note />
       </trans-unit>
       <trans-unit id="Nested_quantifier_0">
@@ -1087,7 +1087,7 @@ Verifique se o especificador "tt" foi usado para idiomas para os quais é necess
       </trans-unit>
       <trans-unit id="No_source_document_info_found_in_PDB">
         <source>No source document info found in PDB.</source>
-        <target state="new">No source document info found in PDB.</target>
+        <target state="translated">Nenhuma informação do documento de origem encontrada no PDB.</target>
         <note />
       </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
@@ -1275,11 +1275,11 @@ Essa opção é recomendada quando você sabe que o rastreamento inverso não se
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
+        <target state="translated">Uma definição de grupo de balanceamento exclui a definição de um grupo definido anteriormente e armazena, no grupo atual, o intervalo entre o grupo definido anteriormente e o grupo atual.
 
-'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+'name1' é o grupo atual (opcional), 'name2' é um grupo definido anteriormente e 'subexpression' é qualquer padrão de expressão regular válido. A definição de grupo de balanceamento exclui a definição de name2 e armazena o intervalo entre name2 e name1 no name1. Se não for definido nenhum name2, a correspondência retrocederá. Como a exclusão da última definição de name2 revela a definição anterior de name2, essa construção permite usar a pilha de capturas para o grupo name2 como um contador para manter o controle de construções aninhadas, como parênteses ou colchetes de abertura e fechamento.
 
-The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
+A definição de grupo de balanceamento usa 'name2' como uma pilha. O caractere inicial de cada construção aninhada é colocada no grupo e em sua coleção Group.Captures. Quando o caractere de fechamento é correspondido, seu caractere de abertura correspondente é removido do grupo e a coleção Captures é reduzida em um. Após a correspondência dos caracteres de abertura e fechamento de todas as construções aninhadas, 'name1' estará vazio.</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
@@ -2352,7 +2352,7 @@ As declarações de lookbehind positivas de largura zero normalmente são usadas
       </trans-unit>
       <trans-unit id="Silent">
         <source>Silent</source>
-        <target state="new">Silent</target>
+        <target state="translated">Silencioso</target>
         <note />
       </trans-unit>
       <trans-unit id="Sort_accessibility_modifiers">
@@ -2362,12 +2362,12 @@ As declarações de lookbehind positivas de largura zero normalmente são usadas
       </trans-unit>
       <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
         <source>Source code language information was not found in PDB.</source>
-        <target state="new">Source code language information was not found in PDB.</target>
+        <target state="translated">As informações de idioma do código-fonte não foram encontradas no PDB.</target>
         <note />
       </trans-unit>
       <trans-unit id="Source_is_a_reference_assembly">
         <source>Source is a reference assembly, not enough information to find PDB.</source>
-        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <target state="translated">A origem é um assembly de referência, não há informações suficientes para localizar o PDB.</target>
         <note />
       </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
@@ -2397,7 +2397,7 @@ As declarações de lookbehind positivas de largura zero normalmente são usadas
       </trans-unit>
       <trans-unit id="Symbol_found_in_assembly_path_0">
         <source>Symbol found in assembly path '{0}'</source>
-        <target state="new">Symbol found in assembly path '{0}'</target>
+        <target state="translated">Símbolo encontrado no caminho de montagem '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
@@ -2427,12 +2427,12 @@ As declarações de lookbehind positivas de largura zero normalmente são usadas
       </trans-unit>
       <trans-unit id="Timeout_SourceLink">
         <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <target state="translated">Tempo limite esgotado ao tentar baixar o código-fonte do SourceLink. As solicitações subsequentes podem ser bem-sucedidas.</target>
         <note />
       </trans-unit>
       <trans-unit id="Timeout_symbol_server">
         <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <target state="translated">Tempo limite esgotado ao tentar fazer download do PDB do servidor de símbolos. As solicitações subsequentes podem ser bem-sucedidas.</target>
         <note />
       </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
@@ -2447,7 +2447,7 @@ As declarações de lookbehind positivas de largura zero normalmente são usadas
       </trans-unit>
       <trans-unit id="Types_colon">
         <source>Types:</source>
-        <target state="new">Types:</target>
+        <target state="translated">Tipos:</target>
         <note />
       </trans-unit>
       <trans-unit id="UnableToReadSourceFileOrPdb">
@@ -2737,42 +2737,42 @@ As declarações de lookbehind positivas de largura zero normalmente são usadas
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB">
         <source>'{0}' found in embedded PDB.</source>
-        <target state="new">'{0}' found in embedded PDB.</target>
+        <target state="translated">'{0}' encontrado no PDB integrado.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
         <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">'{0}' encontrado no PDB integrado, mas a soma de verificação estava errada ou não foi possível ler o arquivo temporário.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
         <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
-        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <target state="translated">'{0}' encontrado no PDB incorporado, mas não foi possível gravar no arquivo temporário: '{1}'</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
         <source>'{0}' found in embedded PDB and found cached source file.</source>
-        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <target state="translated">'{0}' encontrado no PDB incorporado e arquivo de origem em cache encontrado.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location">
         <source>'{0}' found in original location.</source>
-        <target state="new">'{0}' found in original location.</target>
+        <target state="translated">'{0}' encontrado no local original.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location_but_checksum_failed">
         <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">'{0}' encontrado no local original, mas a soma de verificação estava errada ou não foi possível ler o arquivo temporário.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink">
         <source>'{0}' found via SourceLink.</source>
-        <target state="new">'{0}' found via SourceLink.</target>
+        <target state="translated">'{0}' encontrado via SourceLink.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
         <source>'{0}' found via SourceLink but couldn't read temp file.</source>
-        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <target state="translated">'{0}' encontrado via SourceLink, mas não pôde ler o arquivo temporário.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_is_not_null_here">
@@ -3105,12 +3105,12 @@ Se o especificador de formato "d" for usado sem outros especificadores de format
       </trans-unit>
       <trans-unit id="embedded">
         <source>embedded</source>
-        <target state="new">embedded</target>
+        <target state="translated">embutido</target>
         <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
       </trans-unit>
       <trans-unit id="external">
         <source>external</source>
-        <target state="new">external</target>
+        <target state="translated">externo</target>
         <note>External means "external source", meaning source files that are not part of the current solution</note>
       </trans-unit>
       <trans-unit id="from_metadata">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf
index 7f4407dc96737..056492df1c31b 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf
@@ -242,12 +242,12 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression">
         <source>Await the preceding expression</source>
-        <target state="new">Await the preceding expression</target>
+        <target state="translated">Ожидание предыдущего выражения</target>
         <note />
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression_and_add_ConfigureAwait_0">
         <source>Await the preceding expression and add ConfigureAwait({0}).</source>
-        <target state="new">Await the preceding expression and add ConfigureAwait({0}).</target>
+        <target state="translated">Ожидание предыдущего выражения и добавление ConfigureAwait({0}).</target>
         <note>{Locked="ConfigureAwait"} "ConfigureAwait" is an api name and should not be localized. {0} is a placeholder for the language specific keyword 'false'.</note>
       </trans-unit>
       <trans-unit id="Awaited_task_returns_0">
@@ -472,12 +472,12 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
         <source>Could not find portable PDB on disk or embedded.</source>
-        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <target state="translated">Не удалось найти переносимый PDB-файл на диске или во внедренном источнике.</target>
         <note />
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
         <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
-        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <target state="translated">Не удалось найти PDB-файл на диске, во внедренном источнике или на сервере символов.</target>
         <note />
       </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
@@ -562,7 +562,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Error_reading_PDB_0">
         <source>Error reading PDB: '{0}'</source>
-        <target state="new">Error reading PDB: '{0}'</target>
+        <target state="translated">Ошибка чтения PDB-файла: "{0}"</target>
         <note />
       </trans-unit>
       <trans-unit id="Example">
@@ -582,7 +582,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Explicitly_inherit_documentation">
         <source>Explicitly inherit documentation</source>
-        <target state="new">Explicitly inherit documentation</target>
+        <target state="translated">Явно наследовать документацию</target>
         <note />
       </trans-unit>
       <trans-unit id="Extract_base_class">
@@ -632,32 +632,32 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Found_PDB_file_at_0">
         <source>Found PDB file at '{0}'</source>
-        <target state="new">Found PDB file at '{0}'</target>
+        <target state="translated">Найден PDB-файл в "{0}"</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server">
         <source>Found PDB on symbol server.</source>
-        <target state="new">Found PDB on symbol server.</target>
+        <target state="translated">Найден PDB-файл на сервере символов.</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
         <source>Found PDB on symbol server but could not read file.</source>
-        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <target state="translated">Найден PDB-файл на сервере символов, но не удалось прочитать файл.</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_embedded_PDB_file">
         <source>Found embedded PDB file.</source>
-        <target state="new">Found embedded PDB file.</target>
+        <target state="translated">Найден внедренный PDB-файл.</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
-        <target state="new">Generate abstract method '{0}'</target>
+        <target state="translated">Создать абстрактный метод "{0}"</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_property_0">
         <source>Generate abstract property '{0}'</source>
-        <target state="new">Generate abstract property '{0}'</target>
+        <target state="translated">Создать абстрактное свойство "{0}"</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_comparison_operators">
@@ -667,7 +667,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Generate_constant_0">
         <source>Generate constant '{0}'</source>
-        <target state="new">Generate constant '{0}'</target>
+        <target state="translated">Создать константу "{0}"</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_constructor_in_0_with_fields">
@@ -682,12 +682,12 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Generate_enum_member_0">
         <source>Generate enum member '{0}'</source>
-        <target state="new">Generate enum member '{0}'</target>
+        <target state="translated">Создать элемент перечисления "{0}"</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_field_0">
         <source>Generate field '{0}'</source>
-        <target state="new">Generate field '{0}'</target>
+        <target state="translated">Создать поле "{0}"</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_for_0">
@@ -697,7 +697,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Generate_method_0">
         <source>Generate method '{0}'</source>
-        <target state="new">Generate method '{0}'</target>
+        <target state="translated">Создать метод "{0}"</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_parameter_0">
@@ -712,17 +712,17 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Generate_property_0">
         <source>Generate property '{0}'</source>
-        <target state="new">Generate property '{0}'</target>
+        <target state="translated">Создать свойство "{0}"</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_field_0">
         <source>Generate read-only field '{0}'</source>
-        <target state="new">Generate read-only field '{0}'</target>
+        <target state="translated">Создать поле только для чтения "{0}"</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_property_0">
         <source>Generate read-only property '{0}'</source>
-        <target state="new">Generate read-only property '{0}'</target>
+        <target state="translated">Создать свойство только для чтения "{0}"</target>
         <note />
       </trans-unit>
       <trans-unit id="Illegal_backslash_at_end_of_pattern">
@@ -947,7 +947,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Miscellaneous_Files">
         <source>Miscellaneous Files</source>
-        <target state="new">Miscellaneous Files</target>
+        <target state="translated">Прочие файлы</target>
         <note />
       </trans-unit>
       <trans-unit id="Missing_control_character">
@@ -1057,7 +1057,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type">
         <source>Move static members to another type...</source>
-        <target state="new">Move static members to another type...</target>
+        <target state="translated">Переместить статические элементы в другой тип...</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -1072,7 +1072,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Navigating_to_symbol_0_from_1">
         <source>Navigating to symbol '{0}' from '{1}'.</source>
-        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <target state="translated">Переход к символу "{0}" от "{1}".</target>
         <note />
       </trans-unit>
       <trans-unit id="Nested_quantifier_0">
@@ -1087,7 +1087,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="No_source_document_info_found_in_PDB">
         <source>No source document info found in PDB.</source>
-        <target state="new">No source document info found in PDB.</target>
+        <target state="translated">В PDB-файле не найдены сведения об исходном документе.</target>
         <note />
       </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
@@ -1275,11 +1275,11 @@ This option is recommended if you know that backtracking will not succeed. Preve
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
+        <target state="translated">Сбалансированное определение группы удаляет определение ранее определенной группы и сохраняет (в текущей группе) интервал между ранее определенной группой и текущей группой.
 
-'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+Значение "имя1" является текущей группой (необязательная), "имя2" является ранее определенной группой, а "часть выражения" является любым допустимым шаблоном регулярного выражения. Сбалансированное определение группы удаляет определение "имя2" и сохраняет интервал между "имя2" и "имя1" в "имя1". Если группа "имя2" не определена, соответствие определяется по обратному отслеживанию. Так как удаление последнего определения "имя2" приводит к раскрытию предыдущего определения "имя2", эта конструкция позволяет использовать стек записей для группы "имя2" в качестве счетчика для отслеживания вложенных конструкций, таких как круглые скобки или открывающие и закрывающие скобки.
 
-The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
+Сбалансированное определение группы использует "имя2" в качестве стека. Начальный символ каждой вложенной конструкции помещается в группу и ее коллекцию Group.Captures. При появлении совпадения для закрывающего символа соответствующий ему открывающий символ удаляется из группы, а коллекция Captures уменьшается на единицу. После обнаружения совпадений для всех открывающих и закрывающих символов всех вложенных конструкций группа "имя1" остается пустой.</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
@@ -2352,7 +2352,7 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Silent">
         <source>Silent</source>
-        <target state="new">Silent</target>
+        <target state="translated">Тихий</target>
         <note />
       </trans-unit>
       <trans-unit id="Sort_accessibility_modifiers">
@@ -2362,12 +2362,12 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
         <source>Source code language information was not found in PDB.</source>
-        <target state="new">Source code language information was not found in PDB.</target>
+        <target state="translated">Сведения о языке исходного кода не найдены в PDB-файле.</target>
         <note />
       </trans-unit>
       <trans-unit id="Source_is_a_reference_assembly">
         <source>Source is a reference assembly, not enough information to find PDB.</source>
-        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <target state="translated">Источник является базовой сборкой. Недостаточно сведений для поиска PDB-файла.</target>
         <note />
       </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
@@ -2397,7 +2397,7 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Symbol_found_in_assembly_path_0">
         <source>Symbol found in assembly path '{0}'</source>
-        <target state="new">Symbol found in assembly path '{0}'</target>
+        <target state="translated">Найден символ в пути сборки "{0}"</target>
         <note />
       </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
@@ -2427,12 +2427,12 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Timeout_SourceLink">
         <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <target state="translated">Истекло время ожидания при попытке скачать исходный код из SourceLink. Последующие запросы могут быть успешными.</target>
         <note />
       </trans-unit>
       <trans-unit id="Timeout_symbol_server">
         <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <target state="translated">Истекло время ожидания при попытке скачать PDB-файл с сервера символов. Последующие запросы могут быть успешными.</target>
         <note />
       </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
@@ -2447,7 +2447,7 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Types_colon">
         <source>Types:</source>
-        <target state="new">Types:</target>
+        <target state="translated">Типы:</target>
         <note />
       </trans-unit>
       <trans-unit id="UnableToReadSourceFileOrPdb">
@@ -2737,42 +2737,42 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB">
         <source>'{0}' found in embedded PDB.</source>
-        <target state="new">'{0}' found in embedded PDB.</target>
+        <target state="translated">Найдено "{0}" во внедренном PDB-файле.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
         <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">Найдено "{0}" во внедренном PDB-файле, но контрольная сумма неверна или не удалось прочитать временный файл.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
         <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
-        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <target state="translated">Найдено "{0}" во внедренном PDB-файле, но не удалось выполнить запись во временном файле: "{1}"</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
         <source>'{0}' found in embedded PDB and found cached source file.</source>
-        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <target state="translated">Обнаружено "{0}" во внедренном PDB-файле и найден кэшированный исходный файл.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location">
         <source>'{0}' found in original location.</source>
-        <target state="new">'{0}' found in original location.</target>
+        <target state="translated">Найдено "{0}" в исходном расположении.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location_but_checksum_failed">
         <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">Найдено "{0}" в исходном расположении, но контрольная сумма неверна или не удалось прочитать временный файл.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink">
         <source>'{0}' found via SourceLink.</source>
-        <target state="new">'{0}' found via SourceLink.</target>
+        <target state="translated">Найдено "{0}" с помощью SourceLink.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
         <source>'{0}' found via SourceLink but couldn't read temp file.</source>
-        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <target state="translated">Найдено "{0}" с помощью SourceLink, но не удалось прочитать временный файл.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_is_not_null_here">
@@ -3105,12 +3105,12 @@ If the "d" format specifier is used without other custom format specifiers, it's
       </trans-unit>
       <trans-unit id="embedded">
         <source>embedded</source>
-        <target state="new">embedded</target>
+        <target state="translated">внедренный</target>
         <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
       </trans-unit>
       <trans-unit id="external">
         <source>external</source>
-        <target state="new">external</target>
+        <target state="translated">внешний</target>
         <note>External means "external source", meaning source files that are not part of the current solution</note>
       </trans-unit>
       <trans-unit id="from_metadata">

From 6ba66ac69ddc0af8919b429466ab440f574ecf60 Mon Sep 17 00:00:00 2001
From: dotnet bot <dotnet-bot@dotnetfoundation.org>
Date: Fri, 7 Jan 2022 12:10:02 -0800
Subject: [PATCH 278/444] Localized file check-in by OneLocBuild Task: Build
 definition ID 327: Build ID 1541625

---
 .../xlf/CSharpFeaturesResources.cs.xlf        |  8 +-
 .../xlf/CSharpFeaturesResources.de.xlf        | 12 +--
 .../xlf/CSharpFeaturesResources.es.xlf        | 12 +--
 .../xlf/CSharpFeaturesResources.fr.xlf        | 12 +--
 .../xlf/CSharpFeaturesResources.it.xlf        | 12 +--
 .../xlf/CSharpFeaturesResources.ja.xlf        | 12 +--
 .../xlf/CSharpFeaturesResources.ko.xlf        | 12 +--
 .../xlf/CSharpFeaturesResources.pl.xlf        |  8 +-
 .../xlf/CSharpFeaturesResources.pt-BR.xlf     | 12 +--
 .../xlf/CSharpFeaturesResources.ru.xlf        | 10 +--
 .../xlf/CSharpFeaturesResources.tr.xlf        | 28 +++---
 .../xlf/CSharpFeaturesResources.zh-Hans.xlf   | 12 +--
 .../xlf/CSharpFeaturesResources.zh-Hant.xlf   | 12 +--
 .../Portable/xlf/FeaturesResources.tr.xlf     | 90 +++++++++----------
 .../xlf/FeaturesResources.zh-Hans.xlf         | 86 +++++++++---------
 .../xlf/FeaturesResources.zh-Hant.xlf         | 86 +++++++++---------
 .../Portable/xlf/VBFeaturesResources.es.xlf   |  8 +-
 .../Portable/xlf/VBFeaturesResources.it.xlf   |  4 +-
 .../xlf/VBFeaturesResources.pt-BR.xlf         |  2 +-
 .../Portable/xlf/VBFeaturesResources.tr.xlf   |  2 +-
 .../xlf/VBFeaturesResources.zh-Hans.xlf       | 18 ++--
 .../xlf/VBFeaturesResources.zh-Hant.xlf       | 10 +--
 .../xlf/CSharpScriptingResources.de.xlf       |  2 +-
 .../xlf/VBScriptingResources.it.xlf           |  2 +-
 .../CSharp/Impl/xlf/CSharpVSResources.cs.xlf  |  2 +-
 .../CSharp/Impl/xlf/CSharpVSResources.de.xlf  |  2 +-
 .../CSharp/Impl/xlf/CSharpVSResources.es.xlf  |  2 +-
 .../CSharp/Impl/xlf/CSharpVSResources.fr.xlf  |  2 +-
 .../CSharp/Impl/xlf/CSharpVSResources.it.xlf  |  2 +-
 .../CSharp/Impl/xlf/CSharpVSResources.ja.xlf  |  2 +-
 .../CSharp/Impl/xlf/CSharpVSResources.ko.xlf  |  2 +-
 .../CSharp/Impl/xlf/CSharpVSResources.pl.xlf  |  2 +-
 .../Impl/xlf/CSharpVSResources.pt-BR.xlf      |  2 +-
 .../CSharp/Impl/xlf/CSharpVSResources.ru.xlf  |  2 +-
 .../CSharp/Impl/xlf/CSharpVSResources.tr.xlf  |  4 +-
 .../Impl/xlf/CSharpVSResources.zh-Hans.xlf    |  2 +-
 .../Impl/xlf/CSharpVSResources.zh-Hant.xlf    |  2 +-
 .../CSharp/Impl/xlf/VSPackage.ko.xlf          |  8 +-
 .../Core/Def/xlf/Commands.vsct.cs.xlf         | 14 +--
 .../Core/Def/xlf/Commands.vsct.de.xlf         |  8 +-
 .../Core/Def/xlf/Commands.vsct.es.xlf         |  8 +-
 .../Core/Def/xlf/Commands.vsct.fr.xlf         | 12 +--
 .../Core/Def/xlf/Commands.vsct.it.xlf         |  8 +-
 .../Core/Def/xlf/Commands.vsct.ja.xlf         |  8 +-
 .../Core/Def/xlf/Commands.vsct.ko.xlf         | 10 +--
 .../Core/Def/xlf/Commands.vsct.pl.xlf         |  8 +-
 .../Core/Def/xlf/Commands.vsct.pt-BR.xlf      |  8 +-
 .../Core/Def/xlf/Commands.vsct.ru.xlf         |  8 +-
 .../Core/Def/xlf/Commands.vsct.tr.xlf         |  8 +-
 .../Core/Def/xlf/Commands.vsct.zh-Hans.xlf    |  8 +-
 .../Core/Def/xlf/Commands.vsct.zh-Hant.xlf    |  8 +-
 .../Core/Def/xlf/ServicesVSResources.cs.xlf   | 36 ++++----
 .../Core/Def/xlf/ServicesVSResources.de.xlf   | 36 ++++----
 .../Core/Def/xlf/ServicesVSResources.es.xlf   | 36 ++++----
 .../Core/Def/xlf/ServicesVSResources.fr.xlf   | 36 ++++----
 .../Core/Def/xlf/ServicesVSResources.it.xlf   | 36 ++++----
 .../Core/Def/xlf/ServicesVSResources.ja.xlf   | 36 ++++----
 .../Core/Def/xlf/ServicesVSResources.ko.xlf   | 36 ++++----
 .../Core/Def/xlf/ServicesVSResources.pl.xlf   | 36 ++++----
 .../Def/xlf/ServicesVSResources.pt-BR.xlf     | 36 ++++----
 .../Core/Def/xlf/ServicesVSResources.ru.xlf   | 36 ++++----
 .../Core/Def/xlf/ServicesVSResources.tr.xlf   | 36 ++++----
 .../Def/xlf/ServicesVSResources.zh-Hans.xlf   | 36 ++++----
 .../Def/xlf/ServicesVSResources.zh-Hant.xlf   | 36 ++++----
 .../Impl/xlf/BasicVSResources.tr.xlf          |  2 +-
 65 files changed, 547 insertions(+), 547 deletions(-)

diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.cs.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.cs.xlf
index baaabc7568ed9..0973c83d3f393 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.cs.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.cs.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Enable_nullable_reference_types_in_project">
         <source>Enable nullable reference types in project</source>
-        <target state="new">Enable nullable reference types in project</target>
+        <target state="translated">Povolit v projektu typy odkazů s možnou hodnotou null</target>
         <note />
       </trans-unit>
       <trans-unit id="Fix_return_type">
@@ -169,12 +169,12 @@
       </trans-unit>
       <trans-unit id="Selection_cannot_include_global_statements">
         <source>Selection cannot include global statements</source>
-        <target state="new">Selection cannot include global statements</target>
+        <target state="translated">Výběr nemůže obsahovat globální příkazy.</target>
         <note />
       </trans-unit>
       <trans-unit id="Selection_cannot_include_top_level_statements">
         <source>Selection cannot include top-level statements</source>
-        <target state="new">Selection cannot include top-level statements</target>
+        <target state="translated">Výběr nemůže obsahovat příkazy nejvyšší úrovně.</target>
         <note />
       </trans-unit>
       <trans-unit id="Simplify_lambda_expression">
@@ -204,7 +204,7 @@
       </trans-unit>
       <trans-unit id="Warning_Expression_may_change_code_meaning">
         <source>Warning: Expression may have side effects. Code meaning may change.</source>
-        <target state="new">Warning: Expression may have side effects. Code meaning may change.</target>
+        <target state="translated">Upozornění: Výraz může mít vedlejší účinky. Význam kódu se může změnit.</target>
         <note />
       </trans-unit>
       <trans-unit id="Warning_Inlining_temporary_into_conditional_method_call">
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.de.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.de.xlf
index 376773309e5cb..1f32da3391bfe 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.de.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.de.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Enable_nullable_reference_types_in_project">
         <source>Enable nullable reference types in project</source>
-        <target state="new">Enable nullable reference types in project</target>
+        <target state="translated">Nullwerte zulassende Verweistypen im Projekt aktivieren</target>
         <note />
       </trans-unit>
       <trans-unit id="Fix_return_type">
@@ -169,12 +169,12 @@
       </trans-unit>
       <trans-unit id="Selection_cannot_include_global_statements">
         <source>Selection cannot include global statements</source>
-        <target state="new">Selection cannot include global statements</target>
+        <target state="translated">Die Auswahl darf keine globalen Anweisungen enthalten.</target>
         <note />
       </trans-unit>
       <trans-unit id="Selection_cannot_include_top_level_statements">
         <source>Selection cannot include top-level statements</source>
-        <target state="new">Selection cannot include top-level statements</target>
+        <target state="translated">Die Auswahl darf keine Anweisungen der obersten Ebene enthalten.</target>
         <note />
       </trans-unit>
       <trans-unit id="Simplify_lambda_expression">
@@ -204,7 +204,7 @@
       </trans-unit>
       <trans-unit id="Warning_Expression_may_change_code_meaning">
         <source>Warning: Expression may have side effects. Code meaning may change.</source>
-        <target state="new">Warning: Expression may have side effects. Code meaning may change.</target>
+        <target state="translated">Warnung: Der Ausdruck kann Nebeneffekte haben. Die Bedeutung des Codes kann sich ändern.</target>
         <note />
       </trans-unit>
       <trans-unit id="Warning_Inlining_temporary_into_conditional_method_call">
@@ -249,7 +249,7 @@
       </trans-unit>
       <trans-unit id="member_name">
         <source>&lt;member name&gt; = </source>
-        <target state="translated">&lt;Membername&gt; =</target>
+        <target state="translated">&lt;Membername&gt; = </target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_possible_explicitly_named_anonymous_type_member_creation">
@@ -259,7 +259,7 @@
       </trans-unit>
       <trans-unit id="element_name">
         <source>&lt;element name&gt; : </source>
-        <target state="translated">&lt;Elementname&gt; :</target>
+        <target state="translated">&lt;Elementname&gt; : </target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_possible_tuple_type_element_creation">
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.es.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.es.xlf
index 7d0fb4a8accbc..4511fe240f950 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.es.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.es.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Enable_nullable_reference_types_in_project">
         <source>Enable nullable reference types in project</source>
-        <target state="new">Enable nullable reference types in project</target>
+        <target state="translated">Habilitar tipos de referencia que aceptan valores NULL en el proyecto</target>
         <note />
       </trans-unit>
       <trans-unit id="Fix_return_type">
@@ -169,12 +169,12 @@
       </trans-unit>
       <trans-unit id="Selection_cannot_include_global_statements">
         <source>Selection cannot include global statements</source>
-        <target state="new">Selection cannot include global statements</target>
+        <target state="translated">La selección no puede incluir declaraciones globales</target>
         <note />
       </trans-unit>
       <trans-unit id="Selection_cannot_include_top_level_statements">
         <source>Selection cannot include top-level statements</source>
-        <target state="new">Selection cannot include top-level statements</target>
+        <target state="translated">La selección no puede incluir instrucciones de nivel superior</target>
         <note />
       </trans-unit>
       <trans-unit id="Simplify_lambda_expression">
@@ -204,7 +204,7 @@
       </trans-unit>
       <trans-unit id="Warning_Expression_may_change_code_meaning">
         <source>Warning: Expression may have side effects. Code meaning may change.</source>
-        <target state="new">Warning: Expression may have side effects. Code meaning may change.</target>
+        <target state="translated">Advertencia: la expresión puede tener efectos secundarios. El significado del código puede cambiar.</target>
         <note />
       </trans-unit>
       <trans-unit id="Warning_Inlining_temporary_into_conditional_method_call">
@@ -249,7 +249,7 @@
       </trans-unit>
       <trans-unit id="member_name">
         <source>&lt;member name&gt; = </source>
-        <target state="translated">&lt;nombre&gt; =</target>
+        <target state="translated">&lt;nombre&gt; = </target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_possible_explicitly_named_anonymous_type_member_creation">
@@ -259,7 +259,7 @@
       </trans-unit>
       <trans-unit id="element_name">
         <source>&lt;element name&gt; : </source>
-        <target state="translated">&lt;nombre de elemento&gt; :</target>
+        <target state="translated">&lt;nombre de elemento&gt; : </target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_possible_tuple_type_element_creation">
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.fr.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.fr.xlf
index 84863ce766a93..83c192c454017 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.fr.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.fr.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Enable_nullable_reference_types_in_project">
         <source>Enable nullable reference types in project</source>
-        <target state="new">Enable nullable reference types in project</target>
+        <target state="translated">Activer les types de référence nullables dans le projet</target>
         <note />
       </trans-unit>
       <trans-unit id="Fix_return_type">
@@ -169,12 +169,12 @@
       </trans-unit>
       <trans-unit id="Selection_cannot_include_global_statements">
         <source>Selection cannot include global statements</source>
-        <target state="new">Selection cannot include global statements</target>
+        <target state="translated">La sélection ne peut pas inclure d'instructions globales</target>
         <note />
       </trans-unit>
       <trans-unit id="Selection_cannot_include_top_level_statements">
         <source>Selection cannot include top-level statements</source>
-        <target state="new">Selection cannot include top-level statements</target>
+        <target state="translated">La sélection ne peut pas inclure d'instructions de niveau supérieur</target>
         <note />
       </trans-unit>
       <trans-unit id="Simplify_lambda_expression">
@@ -204,7 +204,7 @@
       </trans-unit>
       <trans-unit id="Warning_Expression_may_change_code_meaning">
         <source>Warning: Expression may have side effects. Code meaning may change.</source>
-        <target state="new">Warning: Expression may have side effects. Code meaning may change.</target>
+        <target state="translated">Avertissement : L'expression peut avoir des effets secondaires. La signification du code peut changer.</target>
         <note />
       </trans-unit>
       <trans-unit id="Warning_Inlining_temporary_into_conditional_method_call">
@@ -249,7 +249,7 @@
       </trans-unit>
       <trans-unit id="member_name">
         <source>&lt;member name&gt; = </source>
-        <target state="translated">&lt;nom de membre&gt; =</target>
+        <target state="translated">&lt;nom de membre&gt; = </target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_possible_explicitly_named_anonymous_type_member_creation">
@@ -259,7 +259,7 @@
       </trans-unit>
       <trans-unit id="element_name">
         <source>&lt;element name&gt; : </source>
-        <target state="translated">&lt;nom d'élément&gt; :</target>
+        <target state="translated">&lt;nom d'élément&gt; : </target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_possible_tuple_type_element_creation">
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.it.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.it.xlf
index 7fc6cb6f484a8..059515829ba39 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.it.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.it.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Enable_nullable_reference_types_in_project">
         <source>Enable nullable reference types in project</source>
-        <target state="new">Enable nullable reference types in project</target>
+        <target state="translated">Abilita tipi riferimento nullable nel progetto</target>
         <note />
       </trans-unit>
       <trans-unit id="Fix_return_type">
@@ -169,12 +169,12 @@
       </trans-unit>
       <trans-unit id="Selection_cannot_include_global_statements">
         <source>Selection cannot include global statements</source>
-        <target state="new">Selection cannot include global statements</target>
+        <target state="translated">La selezione non può includere istruzioni globali</target>
         <note />
       </trans-unit>
       <trans-unit id="Selection_cannot_include_top_level_statements">
         <source>Selection cannot include top-level statements</source>
-        <target state="new">Selection cannot include top-level statements</target>
+        <target state="translated">La selezione non può includere istruzioni di primo livello</target>
         <note />
       </trans-unit>
       <trans-unit id="Simplify_lambda_expression">
@@ -204,7 +204,7 @@
       </trans-unit>
       <trans-unit id="Warning_Expression_may_change_code_meaning">
         <source>Warning: Expression may have side effects. Code meaning may change.</source>
-        <target state="new">Warning: Expression may have side effects. Code meaning may change.</target>
+        <target state="translated">Avviso: l'espressione può avere effetti collaterali. Il significato del codice può cambiare.</target>
         <note />
       </trans-unit>
       <trans-unit id="Warning_Inlining_temporary_into_conditional_method_call">
@@ -249,7 +249,7 @@
       </trans-unit>
       <trans-unit id="member_name">
         <source>&lt;member name&gt; = </source>
-        <target state="translated">&lt;nome membro&gt; =</target>
+        <target state="translated">&lt;nome membro&gt; = </target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_possible_explicitly_named_anonymous_type_member_creation">
@@ -259,7 +259,7 @@
       </trans-unit>
       <trans-unit id="element_name">
         <source>&lt;element name&gt; : </source>
-        <target state="translated">&lt;nome elemento&gt;:</target>
+        <target state="translated">&lt;nome elemento&gt;: </target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_possible_tuple_type_element_creation">
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ja.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ja.xlf
index 6672b4f562bbb..a730dfa534ff3 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ja.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ja.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Enable_nullable_reference_types_in_project">
         <source>Enable nullable reference types in project</source>
-        <target state="new">Enable nullable reference types in project</target>
+        <target state="translated">プロジェクトで null 許容参照型を有効にする</target>
         <note />
       </trans-unit>
       <trans-unit id="Fix_return_type">
@@ -169,12 +169,12 @@
       </trans-unit>
       <trans-unit id="Selection_cannot_include_global_statements">
         <source>Selection cannot include global statements</source>
-        <target state="new">Selection cannot include global statements</target>
+        <target state="translated">選択にグローバル ステートメントを含めることはできません</target>
         <note />
       </trans-unit>
       <trans-unit id="Selection_cannot_include_top_level_statements">
         <source>Selection cannot include top-level statements</source>
-        <target state="new">Selection cannot include top-level statements</target>
+        <target state="translated">選択に最上位レベルのステートメントを含めることはできません</target>
         <note />
       </trans-unit>
       <trans-unit id="Simplify_lambda_expression">
@@ -204,7 +204,7 @@
       </trans-unit>
       <trans-unit id="Warning_Expression_may_change_code_meaning">
         <source>Warning: Expression may have side effects. Code meaning may change.</source>
-        <target state="new">Warning: Expression may have side effects. Code meaning may change.</target>
+        <target state="translated">警告: 式に副作用がある可能性があります。コードの意味が変更される可能性があります。</target>
         <note />
       </trans-unit>
       <trans-unit id="Warning_Inlining_temporary_into_conditional_method_call">
@@ -249,7 +249,7 @@
       </trans-unit>
       <trans-unit id="member_name">
         <source>&lt;member name&gt; = </source>
-        <target state="translated">&lt;メンバー名&gt; =</target>
+        <target state="translated">&lt;メンバー名&gt; = </target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_possible_explicitly_named_anonymous_type_member_creation">
@@ -259,7 +259,7 @@
       </trans-unit>
       <trans-unit id="element_name">
         <source>&lt;element name&gt; : </source>
-        <target state="translated">&lt;要素名&gt;:</target>
+        <target state="translated">&lt;要素名&gt; : </target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_possible_tuple_type_element_creation">
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ko.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ko.xlf
index f2c7a88d8dfac..4091a3a7311f6 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ko.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ko.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Enable_nullable_reference_types_in_project">
         <source>Enable nullable reference types in project</source>
-        <target state="new">Enable nullable reference types in project</target>
+        <target state="translated">프로젝트에서 null 허용 참조 형식 사용</target>
         <note />
       </trans-unit>
       <trans-unit id="Fix_return_type">
@@ -169,12 +169,12 @@
       </trans-unit>
       <trans-unit id="Selection_cannot_include_global_statements">
         <source>Selection cannot include global statements</source>
-        <target state="new">Selection cannot include global statements</target>
+        <target state="translated">선택 영역에 전체 문을 포함할 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="Selection_cannot_include_top_level_statements">
         <source>Selection cannot include top-level statements</source>
-        <target state="new">Selection cannot include top-level statements</target>
+        <target state="translated">선택 영역에는 최상위 문을 포함할 수 없습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="Simplify_lambda_expression">
@@ -204,7 +204,7 @@
       </trans-unit>
       <trans-unit id="Warning_Expression_may_change_code_meaning">
         <source>Warning: Expression may have side effects. Code meaning may change.</source>
-        <target state="new">Warning: Expression may have side effects. Code meaning may change.</target>
+        <target state="translated">경고: 식에 부작용이 있을 수 있습니다. 코드 의미가 변경될 수 있습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="Warning_Inlining_temporary_into_conditional_method_call">
@@ -249,7 +249,7 @@
       </trans-unit>
       <trans-unit id="member_name">
         <source>&lt;member name&gt; = </source>
-        <target state="translated">&lt;멤버 이름&gt; =</target>
+        <target state="translated">&lt;멤버 이름&gt; = </target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_possible_explicitly_named_anonymous_type_member_creation">
@@ -259,7 +259,7 @@
       </trans-unit>
       <trans-unit id="element_name">
         <source>&lt;element name&gt; : </source>
-        <target state="translated">&lt;요소 이름&gt;:</target>
+        <target state="translated">&lt;요소 이름&gt;: </target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_possible_tuple_type_element_creation">
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pl.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pl.xlf
index 408b6b1e82f9b..958bc8e9e885c 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pl.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pl.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Enable_nullable_reference_types_in_project">
         <source>Enable nullable reference types in project</source>
-        <target state="new">Enable nullable reference types in project</target>
+        <target state="translated">Włącz typy referencyjne dopuszczające wartości null w projekcie</target>
         <note />
       </trans-unit>
       <trans-unit id="Fix_return_type">
@@ -169,12 +169,12 @@
       </trans-unit>
       <trans-unit id="Selection_cannot_include_global_statements">
         <source>Selection cannot include global statements</source>
-        <target state="new">Selection cannot include global statements</target>
+        <target state="translated">Zaznaczenie nie może zawierać instrukcji globalnych</target>
         <note />
       </trans-unit>
       <trans-unit id="Selection_cannot_include_top_level_statements">
         <source>Selection cannot include top-level statements</source>
-        <target state="new">Selection cannot include top-level statements</target>
+        <target state="translated">Zaznaczenie nie może zawierać instrukcji najwyższego poziomu</target>
         <note />
       </trans-unit>
       <trans-unit id="Simplify_lambda_expression">
@@ -204,7 +204,7 @@
       </trans-unit>
       <trans-unit id="Warning_Expression_may_change_code_meaning">
         <source>Warning: Expression may have side effects. Code meaning may change.</source>
-        <target state="new">Warning: Expression may have side effects. Code meaning may change.</target>
+        <target state="translated">Ostrzeżenie: wyrażenie może mieć efekty uboczne. Znaczenie kodu może ulec zmianie.</target>
         <note />
       </trans-unit>
       <trans-unit id="Warning_Inlining_temporary_into_conditional_method_call">
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pt-BR.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pt-BR.xlf
index 8ed10a0406553..7de4bca5edbea 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pt-BR.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pt-BR.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Enable_nullable_reference_types_in_project">
         <source>Enable nullable reference types in project</source>
-        <target state="new">Enable nullable reference types in project</target>
+        <target state="translated">Habilitar os tipos de referência anuláveis no projeto</target>
         <note />
       </trans-unit>
       <trans-unit id="Fix_return_type">
@@ -169,12 +169,12 @@
       </trans-unit>
       <trans-unit id="Selection_cannot_include_global_statements">
         <source>Selection cannot include global statements</source>
-        <target state="new">Selection cannot include global statements</target>
+        <target state="translated">A seleção não pode incluir instruções globais</target>
         <note />
       </trans-unit>
       <trans-unit id="Selection_cannot_include_top_level_statements">
         <source>Selection cannot include top-level statements</source>
-        <target state="new">Selection cannot include top-level statements</target>
+        <target state="translated">A seleção não pode incluir instruções de nível superior</target>
         <note />
       </trans-unit>
       <trans-unit id="Simplify_lambda_expression">
@@ -204,7 +204,7 @@
       </trans-unit>
       <trans-unit id="Warning_Expression_may_change_code_meaning">
         <source>Warning: Expression may have side effects. Code meaning may change.</source>
-        <target state="new">Warning: Expression may have side effects. Code meaning may change.</target>
+        <target state="translated">Aviso: A expressão pode ter efeitos colaterais. O significado do código pode alterar.</target>
         <note />
       </trans-unit>
       <trans-unit id="Warning_Inlining_temporary_into_conditional_method_call">
@@ -249,7 +249,7 @@
       </trans-unit>
       <trans-unit id="member_name">
         <source>&lt;member name&gt; = </source>
-        <target state="translated">&lt;nome do membro&gt; =</target>
+        <target state="translated">&lt;nome do membro&gt; = </target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_possible_explicitly_named_anonymous_type_member_creation">
@@ -259,7 +259,7 @@
       </trans-unit>
       <trans-unit id="element_name">
         <source>&lt;element name&gt; : </source>
-        <target state="translated">&lt;nome do elemento&gt; :</target>
+        <target state="translated">&lt;nome do elemento&gt; : </target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_possible_tuple_type_element_creation">
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ru.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ru.xlf
index e68bc8ca82658..b00ad6f2adc8b 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ru.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ru.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Enable_nullable_reference_types_in_project">
         <source>Enable nullable reference types in project</source>
-        <target state="new">Enable nullable reference types in project</target>
+        <target state="translated">Включить типы ссылок, допускающие значение NULL, в проекте</target>
         <note />
       </trans-unit>
       <trans-unit id="Fix_return_type">
@@ -169,12 +169,12 @@
       </trans-unit>
       <trans-unit id="Selection_cannot_include_global_statements">
         <source>Selection cannot include global statements</source>
-        <target state="new">Selection cannot include global statements</target>
+        <target state="translated">Выбор не может включать глобальные операторы</target>
         <note />
       </trans-unit>
       <trans-unit id="Selection_cannot_include_top_level_statements">
         <source>Selection cannot include top-level statements</source>
-        <target state="new">Selection cannot include top-level statements</target>
+        <target state="translated">Выбор не может включать операторы верхнего уровня</target>
         <note />
       </trans-unit>
       <trans-unit id="Simplify_lambda_expression">
@@ -204,7 +204,7 @@
       </trans-unit>
       <trans-unit id="Warning_Expression_may_change_code_meaning">
         <source>Warning: Expression may have side effects. Code meaning may change.</source>
-        <target state="new">Warning: Expression may have side effects. Code meaning may change.</target>
+        <target state="translated">Внимание! Выражение может иметь побочные эффекты. Значение кода может измениться.</target>
         <note />
       </trans-unit>
       <trans-unit id="Warning_Inlining_temporary_into_conditional_method_call">
@@ -699,7 +699,7 @@
       </trans-unit>
       <trans-unit id="interface_name">
         <source>&lt;interface name&gt;</source>
-        <target state="translated">&lt; имя интерфейса &gt;</target>
+        <target state="translated">&lt;имя интерфейса&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="designation_name">
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.tr.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.tr.xlf
index 457212e20619c..ac56005f5a0e8 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.tr.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.tr.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Enable_nullable_reference_types_in_project">
         <source>Enable nullable reference types in project</source>
-        <target state="new">Enable nullable reference types in project</target>
+        <target state="translated">Projedeki null atanabilir başvuru türlerini etkinleştir</target>
         <note />
       </trans-unit>
       <trans-unit id="Fix_return_type">
@@ -169,12 +169,12 @@
       </trans-unit>
       <trans-unit id="Selection_cannot_include_global_statements">
         <source>Selection cannot include global statements</source>
-        <target state="new">Selection cannot include global statements</target>
+        <target state="translated">Seçim genel deyimleri içeremez</target>
         <note />
       </trans-unit>
       <trans-unit id="Selection_cannot_include_top_level_statements">
         <source>Selection cannot include top-level statements</source>
-        <target state="new">Selection cannot include top-level statements</target>
+        <target state="translated">Seçim en üst düzey deyimleri içeremez</target>
         <note />
       </trans-unit>
       <trans-unit id="Simplify_lambda_expression">
@@ -204,7 +204,7 @@
       </trans-unit>
       <trans-unit id="Warning_Expression_may_change_code_meaning">
         <source>Warning: Expression may have side effects. Code meaning may change.</source>
-        <target state="new">Warning: Expression may have side effects. Code meaning may change.</target>
+        <target state="translated">Uyarı: İfadenin yan etkileri olabilir. Kod anlamı değişebilir.</target>
         <note />
       </trans-unit>
       <trans-unit id="Warning_Inlining_temporary_into_conditional_method_call">
@@ -234,7 +234,7 @@
       </trans-unit>
       <trans-unit id="lambda_expression">
         <source>&lt;lambda expression&gt;</source>
-        <target state="translated">&lt; lambda ifadesi &gt;</target>
+        <target state="translated">&lt;lambda ifadesi&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_potential_lambda_declaration">
@@ -249,7 +249,7 @@
       </trans-unit>
       <trans-unit id="member_name">
         <source>&lt;member name&gt; = </source>
-        <target state="translated">&lt; üye adı &gt; = </target>
+        <target state="translated">&lt;üye adı&gt; = </target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_possible_explicitly_named_anonymous_type_member_creation">
@@ -259,7 +259,7 @@
       </trans-unit>
       <trans-unit id="element_name">
         <source>&lt;element name&gt; : </source>
-        <target state="translated">&lt; öğe adı &gt;: </target>
+        <target state="translated">&lt;öğe adı&gt;: </target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_possible_tuple_type_element_creation">
@@ -274,7 +274,7 @@
       </trans-unit>
       <trans-unit id="range_variable">
         <source>&lt;range variable&gt;</source>
-        <target state="translated">&lt; Aralık değişkeni &gt;</target>
+        <target state="translated">&lt;Aralık değişkeni&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_potential_range_variable_declaration">
@@ -669,7 +669,7 @@
       </trans-unit>
       <trans-unit id="namespace_name">
         <source>&lt;namespace name&gt;</source>
-        <target state="translated">&lt; ad alanı adı &gt;</target>
+        <target state="translated">&lt;ad alanı adı&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_type_declaration">
@@ -694,22 +694,22 @@
       </trans-unit>
       <trans-unit id="class_name">
         <source>&lt;class name&gt;</source>
-        <target state="translated">&lt; sınıf adı &gt;</target>
+        <target state="translated">&lt;sınıf adı&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="interface_name">
         <source>&lt;interface name&gt;</source>
-        <target state="translated">&lt; arabirim adı &gt;</target>
+        <target state="translated">&lt;arabirim adı&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="designation_name">
         <source>&lt;designation name&gt;</source>
-        <target state="translated">&lt; atama adı &gt;</target>
+        <target state="translated">&lt;atama adı&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="struct_name">
         <source>&lt;struct name&gt;</source>
-        <target state="translated">&lt; yapı adı &gt;</target>
+        <target state="translated">&lt;yapı adı&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="Make_method_async">
@@ -724,7 +724,7 @@
       </trans-unit>
       <trans-unit id="Name">
         <source>&lt;Name&gt;</source>
-        <target state="translated">&lt; ad &gt;</target>
+        <target state="translated">&lt;ad&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_member_declaration">
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hans.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hans.xlf
index 896d35ecbaed4..5c8d1d8e66197 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hans.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hans.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Enable_nullable_reference_types_in_project">
         <source>Enable nullable reference types in project</source>
-        <target state="new">Enable nullable reference types in project</target>
+        <target state="translated">在项目中启用可为 null 的引用类型</target>
         <note />
       </trans-unit>
       <trans-unit id="Fix_return_type">
@@ -169,12 +169,12 @@
       </trans-unit>
       <trans-unit id="Selection_cannot_include_global_statements">
         <source>Selection cannot include global statements</source>
-        <target state="new">Selection cannot include global statements</target>
+        <target state="translated">所选内容不能包含全局语句</target>
         <note />
       </trans-unit>
       <trans-unit id="Selection_cannot_include_top_level_statements">
         <source>Selection cannot include top-level statements</source>
-        <target state="new">Selection cannot include top-level statements</target>
+        <target state="translated">所选内容不能包含顶级语句</target>
         <note />
       </trans-unit>
       <trans-unit id="Simplify_lambda_expression">
@@ -204,7 +204,7 @@
       </trans-unit>
       <trans-unit id="Warning_Expression_may_change_code_meaning">
         <source>Warning: Expression may have side effects. Code meaning may change.</source>
-        <target state="new">Warning: Expression may have side effects. Code meaning may change.</target>
+        <target state="translated">警告: 表达式可能有副作用。代码含义可能更改。</target>
         <note />
       </trans-unit>
       <trans-unit id="Warning_Inlining_temporary_into_conditional_method_call">
@@ -249,7 +249,7 @@
       </trans-unit>
       <trans-unit id="member_name">
         <source>&lt;member name&gt; = </source>
-        <target state="translated">&lt;成员名称&gt; =</target>
+        <target state="translated">&lt;成员名称&gt;= </target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_possible_explicitly_named_anonymous_type_member_creation">
@@ -259,7 +259,7 @@
       </trans-unit>
       <trans-unit id="element_name">
         <source>&lt;element name&gt; : </source>
-        <target state="translated">&lt;元素名称&gt;:</target>
+        <target state="translated">&lt;元素名称&gt;: </target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_possible_tuple_type_element_creation">
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hant.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hant.xlf
index 9cc8236bb002c..c563694b3a485 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hant.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hant.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Enable_nullable_reference_types_in_project">
         <source>Enable nullable reference types in project</source>
-        <target state="new">Enable nullable reference types in project</target>
+        <target state="translated">在專案中啟用可為 Null 的參考類型</target>
         <note />
       </trans-unit>
       <trans-unit id="Fix_return_type">
@@ -169,12 +169,12 @@
       </trans-unit>
       <trans-unit id="Selection_cannot_include_global_statements">
         <source>Selection cannot include global statements</source>
-        <target state="new">Selection cannot include global statements</target>
+        <target state="translated">選取範圍不能包含全域陳述式</target>
         <note />
       </trans-unit>
       <trans-unit id="Selection_cannot_include_top_level_statements">
         <source>Selection cannot include top-level statements</source>
-        <target state="new">Selection cannot include top-level statements</target>
+        <target state="translated">選取範圍不能包含最上層陳述式</target>
         <note />
       </trans-unit>
       <trans-unit id="Simplify_lambda_expression">
@@ -204,7 +204,7 @@
       </trans-unit>
       <trans-unit id="Warning_Expression_may_change_code_meaning">
         <source>Warning: Expression may have side effects. Code meaning may change.</source>
-        <target state="new">Warning: Expression may have side effects. Code meaning may change.</target>
+        <target state="translated">警告: 運算式可能有副作用。代碼意義可能變更。</target>
         <note />
       </trans-unit>
       <trans-unit id="Warning_Inlining_temporary_into_conditional_method_call">
@@ -249,7 +249,7 @@
       </trans-unit>
       <trans-unit id="member_name">
         <source>&lt;member name&gt; = </source>
-        <target state="translated">&lt;成員名稱&gt; =</target>
+        <target state="translated">&lt;成員名稱&gt;= </target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_possible_explicitly_named_anonymous_type_member_creation">
@@ -259,7 +259,7 @@
       </trans-unit>
       <trans-unit id="element_name">
         <source>&lt;element name&gt; : </source>
-        <target state="translated">&lt;元素名稱&gt; :</target>
+        <target state="translated">&lt;元素名稱&gt;: </target>
         <note />
       </trans-unit>
       <trans-unit id="Autoselect_disabled_due_to_possible_tuple_type_element_creation">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf
index f7c69013300f7..9b6b513ed3e45 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf
@@ -242,12 +242,12 @@ AM ve PM arasındaki farkın korunmasının gerekli olduğu diller için "tt" be
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression">
         <source>Await the preceding expression</source>
-        <target state="new">Await the preceding expression</target>
+        <target state="translated">Önceki ifadeyi bekle</target>
         <note />
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression_and_add_ConfigureAwait_0">
         <source>Await the preceding expression and add ConfigureAwait({0}).</source>
-        <target state="new">Await the preceding expression and add ConfigureAwait({0}).</target>
+        <target state="translated">Önceki ifadeyi bekleyin ve ConfigureAwait({0}) ekleyin.</target>
         <note>{Locked="ConfigureAwait"} "ConfigureAwait" is an api name and should not be localized. {0} is a placeholder for the language specific keyword 'false'.</note>
       </trans-unit>
       <trans-unit id="Awaited_task_returns_0">
@@ -472,12 +472,12 @@ AM ve PM arasındaki farkın korunmasının gerekli olduğu diller için "tt" be
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
         <source>Could not find portable PDB on disk or embedded.</source>
-        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <target state="translated">Diskte veya gömülü olarak taşınabilir PDB bulunamadı.</target>
         <note />
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
         <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
-        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <target state="translated">PDB diskte, gömülü veya bir sembol sunucusunda bulunamadı.</target>
         <note />
       </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
@@ -562,7 +562,7 @@ AM ve PM arasındaki farkın korunmasının gerekli olduğu diller için "tt" be
       </trans-unit>
       <trans-unit id="Error_reading_PDB_0">
         <source>Error reading PDB: '{0}'</source>
-        <target state="new">Error reading PDB: '{0}'</target>
+        <target state="translated">PDB okuma hatası: “{0}”</target>
         <note />
       </trans-unit>
       <trans-unit id="Example">
@@ -582,7 +582,7 @@ AM ve PM arasındaki farkın korunmasının gerekli olduğu diller için "tt" be
       </trans-unit>
       <trans-unit id="Explicitly_inherit_documentation">
         <source>Explicitly inherit documentation</source>
-        <target state="new">Explicitly inherit documentation</target>
+        <target state="translated">Belgeleri açıkça devral</target>
         <note />
       </trans-unit>
       <trans-unit id="Extract_base_class">
@@ -632,32 +632,32 @@ AM ve PM arasındaki farkın korunmasının gerekli olduğu diller için "tt" be
       </trans-unit>
       <trans-unit id="Found_PDB_file_at_0">
         <source>Found PDB file at '{0}'</source>
-        <target state="new">Found PDB file at '{0}'</target>
+        <target state="translated">“{0}” konumunda PDB dosyası bulundu</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server">
         <source>Found PDB on symbol server.</source>
-        <target state="new">Found PDB on symbol server.</target>
+        <target state="translated">Sembol sunucusunda PDB bulundu.</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
         <source>Found PDB on symbol server but could not read file.</source>
-        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <target state="translated">Sembol sunucusunda PDB bulundu ancak dosya okunamadı.</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_embedded_PDB_file">
         <source>Found embedded PDB file.</source>
-        <target state="new">Found embedded PDB file.</target>
+        <target state="translated">Gömülü PDB dosyası bulundu.</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
-        <target state="new">Generate abstract method '{0}'</target>
+        <target state="translated">'{0}' soyut metodunu üret</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_property_0">
         <source>Generate abstract property '{0}'</source>
-        <target state="new">Generate abstract property '{0}'</target>
+        <target state="translated">'{0}' soyut özelliğini üret</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_comparison_operators">
@@ -667,7 +667,7 @@ AM ve PM arasındaki farkın korunmasının gerekli olduğu diller için "tt" be
       </trans-unit>
       <trans-unit id="Generate_constant_0">
         <source>Generate constant '{0}'</source>
-        <target state="new">Generate constant '{0}'</target>
+        <target state="translated">'{0}' sabitini üret</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_constructor_in_0_with_fields">
@@ -682,12 +682,12 @@ AM ve PM arasındaki farkın korunmasının gerekli olduğu diller için "tt" be
       </trans-unit>
       <trans-unit id="Generate_enum_member_0">
         <source>Generate enum member '{0}'</source>
-        <target state="new">Generate enum member '{0}'</target>
+        <target state="translated">'{0}' sabit listesi üyesini üret</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_field_0">
         <source>Generate field '{0}'</source>
-        <target state="new">Generate field '{0}'</target>
+        <target state="translated">'{0}' alanını üret</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_for_0">
@@ -697,7 +697,7 @@ AM ve PM arasındaki farkın korunmasının gerekli olduğu diller için "tt" be
       </trans-unit>
       <trans-unit id="Generate_method_0">
         <source>Generate method '{0}'</source>
-        <target state="new">Generate method '{0}'</target>
+        <target state="translated">'{0}' metodunu üret</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_parameter_0">
@@ -712,17 +712,17 @@ AM ve PM arasındaki farkın korunmasının gerekli olduğu diller için "tt" be
       </trans-unit>
       <trans-unit id="Generate_property_0">
         <source>Generate property '{0}'</source>
-        <target state="new">Generate property '{0}'</target>
+        <target state="translated">'{0}' özelliğini üret</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_field_0">
         <source>Generate read-only field '{0}'</source>
-        <target state="new">Generate read-only field '{0}'</target>
+        <target state="translated">'{0}' salt okunur alanını üret</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_property_0">
         <source>Generate read-only property '{0}'</source>
-        <target state="new">Generate read-only property '{0}'</target>
+        <target state="translated">'{0}' salt okunur özelliğini üret</target>
         <note />
       </trans-unit>
       <trans-unit id="Illegal_backslash_at_end_of_pattern">
@@ -917,7 +917,7 @@ AM ve PM arasındaki farkın korunmasının gerekli olduğu diller için "tt" be
       </trans-unit>
       <trans-unit id="Malformed_named_back_reference">
         <source>Malformed \k&lt;...&gt; named back reference</source>
-        <target state="translated">Hatalı biçimlendirilmiş \k &lt;&gt;... arka başvuru adı</target>
+        <target state="translated">Hatalı biçimlendirilmiş \k&lt;...&gt; arka başvuru adı</target>
         <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: \k'</note>
       </trans-unit>
       <trans-unit id="Merge_with_nested_0_statement">
@@ -947,7 +947,7 @@ AM ve PM arasındaki farkın korunmasının gerekli olduğu diller için "tt" be
       </trans-unit>
       <trans-unit id="Miscellaneous_Files">
         <source>Miscellaneous Files</source>
-        <target state="new">Miscellaneous Files</target>
+        <target state="translated">Diğer Dosyalar</target>
         <note />
       </trans-unit>
       <trans-unit id="Missing_control_character">
@@ -1057,7 +1057,7 @@ AM ve PM arasındaki farkın korunmasının gerekli olduğu diller için "tt" be
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type">
         <source>Move static members to another type...</source>
-        <target state="new">Move static members to another type...</target>
+        <target state="translated">Statik üyeleri başka bir türe taşı...</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -1072,7 +1072,7 @@ AM ve PM arasındaki farkın korunmasının gerekli olduğu diller için "tt" be
       </trans-unit>
       <trans-unit id="Navigating_to_symbol_0_from_1">
         <source>Navigating to symbol '{0}' from '{1}'.</source>
-        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <target state="translated">“{1}“den "{0}" sembolüne gidiliyor.</target>
         <note />
       </trans-unit>
       <trans-unit id="Nested_quantifier_0">
@@ -1087,7 +1087,7 @@ AM ve PM arasındaki farkın korunmasının gerekli olduğu diller için "tt" be
       </trans-unit>
       <trans-unit id="No_source_document_info_found_in_PDB">
         <source>No source document info found in PDB.</source>
-        <target state="new">No source document info found in PDB.</target>
+        <target state="translated">PDB'de kaynak belge bilgisi bulunamadı.</target>
         <note />
       </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
@@ -1275,11 +1275,11 @@ Bu seçenek, geri izlemenin başarısız olacağını biliyorsanız önerilir. N
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
+        <target state="translated">Bir dengeleme grubu tanımı, geçerli grupta, önceden tanımlanmış grup ile geçerli grup arasındaki aralıkta, önceden tanımlanmış bir grubun ve depoların tanımını siler.
 
-'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+'name1' geçerli grup (isteğe bağlı), 'name2' önceden tanımlanmış bir grup ve 'subexpression' ise herhangi bir geçerli normal ifade desenidir. Dengeleme grubu tanımı name2'nin tanımını siler ve name2 ile name1 arasındaki aralığı name1'e depolar. Bir name2 grubu tanımlanmamışsa, eşleşme geri iz sürer. name2'nin son tanımını silmek, name2'nin önceki tanımını ortaya çıkardığından, bu yapı name2 grubu için yakalama yığınını, parantez veya açma ve kapama ayracı gibi iç içe yapıları izlemek için bir sayaç olarak kullanmanıza olanak sağlar.
 
-The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
+Dengeleme grubu tanımı 'name2' öğesini bir yığın olarak kullanır. Her iç içe yapının başlangıç karakteri, gruba ve grubun Group.Captures koleksiyonuna yerleştirilir. Kapanış karakteri eşleştiğinde, karşılık gelen açma karakteri gruptan kaldırılır ve Captures koleksiyonunda bir öğe azalır. İç içe tüm yapıların açılış ve kapanış karakterleri eşleştirildikten sonra, 'name1' boş olur.</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
@@ -2352,7 +2352,7 @@ Sıfır genişlikli pozitif geri yönlü onaylamalar genellikle normal ifadeleri
       </trans-unit>
       <trans-unit id="Silent">
         <source>Silent</source>
-        <target state="new">Silent</target>
+        <target state="translated">Sessiz</target>
         <note />
       </trans-unit>
       <trans-unit id="Sort_accessibility_modifiers">
@@ -2362,12 +2362,12 @@ Sıfır genişlikli pozitif geri yönlü onaylamalar genellikle normal ifadeleri
       </trans-unit>
       <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
         <source>Source code language information was not found in PDB.</source>
-        <target state="new">Source code language information was not found in PDB.</target>
+        <target state="translated">Kaynak kodu dil bilgisi PDB'de bulunamadı.</target>
         <note />
       </trans-unit>
       <trans-unit id="Source_is_a_reference_assembly">
         <source>Source is a reference assembly, not enough information to find PDB.</source>
-        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <target state="translated">Kaynak bir başvuru bütünleştirilmiş kodudur, PDB'yi bulmak için yeterli bilgi yoktur.</target>
         <note />
       </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
@@ -2397,7 +2397,7 @@ Sıfır genişlikli pozitif geri yönlü onaylamalar genellikle normal ifadeleri
       </trans-unit>
       <trans-unit id="Symbol_found_in_assembly_path_0">
         <source>Symbol found in assembly path '{0}'</source>
-        <target state="new">Symbol found in assembly path '{0}'</target>
+        <target state="translated">“{0}” derleme yolunda sembol bulundu</target>
         <note />
       </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
@@ -2427,12 +2427,12 @@ Sıfır genişlikli pozitif geri yönlü onaylamalar genellikle normal ifadeleri
       </trans-unit>
       <trans-unit id="Timeout_SourceLink">
         <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <target state="translated">SourceLink'ten kaynak kodu indirmeye çalışırken zaman aşımına uğradı. Sonraki istekler başarılı olabilir.</target>
         <note />
       </trans-unit>
       <trans-unit id="Timeout_symbol_server">
         <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <target state="translated">PDB'yi sembol sunucusundan indirmeye çalışırken zaman aşımına uğradı. Sonraki istekler başarılı olabilir.</target>
         <note />
       </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
@@ -2447,7 +2447,7 @@ Sıfır genişlikli pozitif geri yönlü onaylamalar genellikle normal ifadeleri
       </trans-unit>
       <trans-unit id="Types_colon">
         <source>Types:</source>
-        <target state="new">Types:</target>
+        <target state="translated">Türler:</target>
         <note />
       </trans-unit>
       <trans-unit id="UnableToReadSourceFileOrPdb">
@@ -2737,42 +2737,42 @@ Sıfır genişlikli pozitif geri yönlü onaylamalar genellikle normal ifadeleri
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB">
         <source>'{0}' found in embedded PDB.</source>
-        <target state="new">'{0}' found in embedded PDB.</target>
+        <target state="translated">“{0}”, gömülü PDB'de bulundu.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
         <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">“{0}” gömülü PDB'de bulundu ancak sağlama toplamı yanlıştı veya geçici dosyayı okuyamadı.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
         <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
-        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <target state="translated">“{0}” gömülü PDB'de bulundu ancak geçici dosyaya yazamadı:”{1}”</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
         <source>'{0}' found in embedded PDB and found cached source file.</source>
-        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <target state="translated">“{0}” gömülü PDB'de bulundu ve önbelleğe alınmış kaynak dosya bulundu.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location">
         <source>'{0}' found in original location.</source>
-        <target state="new">'{0}' found in original location.</target>
+        <target state="translated">“{0}” orijinal konumunda bulundu.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location_but_checksum_failed">
         <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">“{0}” orijinal konumda bulundu ancak sağlama toplamı yanlıştı veya geçici dosyayı okuyamadı.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink">
         <source>'{0}' found via SourceLink.</source>
-        <target state="new">'{0}' found via SourceLink.</target>
+        <target state="translated">“{0}” SourceLink aracılığıyla bulundu.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
         <source>'{0}' found via SourceLink but couldn't read temp file.</source>
-        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <target state="translated">“{0}” SourceLink aracılığıyla bulundu ancak geçici dosyayı okuyamadı.</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_is_not_null_here">
@@ -3105,12 +3105,12 @@ If the "d" format specifier is used without other custom format specifiers, it's
       </trans-unit>
       <trans-unit id="embedded">
         <source>embedded</source>
-        <target state="new">embedded</target>
+        <target state="translated">gömülü</target>
         <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
       </trans-unit>
       <trans-unit id="external">
         <source>external</source>
-        <target state="new">external</target>
+        <target state="translated">dış</target>
         <note>External means "external source", meaning source files that are not part of the current solution</note>
       </trans-unit>
       <trans-unit id="from_metadata">
@@ -3762,7 +3762,7 @@ Devam etmek istiyor musunuz?</target>
       </trans-unit>
       <trans-unit id="Pending">
         <source>&lt;Pending&gt;</source>
-        <target state="translated">&lt; bekleyen &gt;</target>
+        <target state="translated">&lt;bekleyen&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="Note_colon_Tab_twice_to_insert_the_0_snippet">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf
index a3567a2002967..7ee893d23e7bb 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf
@@ -242,12 +242,12 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression">
         <source>Await the preceding expression</source>
-        <target state="new">Await the preceding expression</target>
+        <target state="translated">等待前面的表达式</target>
         <note />
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression_and_add_ConfigureAwait_0">
         <source>Await the preceding expression and add ConfigureAwait({0}).</source>
-        <target state="new">Await the preceding expression and add ConfigureAwait({0}).</target>
+        <target state="translated">等待前面的表达式并添加 ConfigureAwait({0})。</target>
         <note>{Locked="ConfigureAwait"} "ConfigureAwait" is an api name and should not be localized. {0} is a placeholder for the language specific keyword 'false'.</note>
       </trans-unit>
       <trans-unit id="Awaited_task_returns_0">
@@ -472,12 +472,12 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
         <source>Could not find portable PDB on disk or embedded.</source>
-        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <target state="translated">在磁盘或嵌入源上找不到可移植 PDB。</target>
         <note />
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
         <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
-        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <target state="translated">在磁盘、嵌入源或符号服务器上找不到 PDB。</target>
         <note />
       </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
@@ -562,7 +562,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Error_reading_PDB_0">
         <source>Error reading PDB: '{0}'</source>
-        <target state="new">Error reading PDB: '{0}'</target>
+        <target state="translated">读取 PDB 时出错:“{0}”</target>
         <note />
       </trans-unit>
       <trans-unit id="Example">
@@ -582,7 +582,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Explicitly_inherit_documentation">
         <source>Explicitly inherit documentation</source>
-        <target state="new">Explicitly inherit documentation</target>
+        <target state="translated">显式继承文档</target>
         <note />
       </trans-unit>
       <trans-unit id="Extract_base_class">
@@ -632,32 +632,32 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Found_PDB_file_at_0">
         <source>Found PDB file at '{0}'</source>
-        <target state="new">Found PDB file at '{0}'</target>
+        <target state="translated">在“{0}”处找到 PDB 文件</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server">
         <source>Found PDB on symbol server.</source>
-        <target state="new">Found PDB on symbol server.</target>
+        <target state="translated">在符号服务器上找到 PDB。</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
         <source>Found PDB on symbol server but could not read file.</source>
-        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <target state="translated">在符号服务器上找到 PDB，但无法读取文件。</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_embedded_PDB_file">
         <source>Found embedded PDB file.</source>
-        <target state="new">Found embedded PDB file.</target>
+        <target state="translated">找到嵌入的 PDB 文件。</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
-        <target state="new">Generate abstract method '{0}'</target>
+        <target state="translated">生成抽象方法“{0}”</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_property_0">
         <source>Generate abstract property '{0}'</source>
-        <target state="new">Generate abstract property '{0}'</target>
+        <target state="translated">生成抽象属性“{0}”</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_comparison_operators">
@@ -667,7 +667,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Generate_constant_0">
         <source>Generate constant '{0}'</source>
-        <target state="new">Generate constant '{0}'</target>
+        <target state="translated">生成常数“{0}”</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_constructor_in_0_with_fields">
@@ -682,12 +682,12 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Generate_enum_member_0">
         <source>Generate enum member '{0}'</source>
-        <target state="new">Generate enum member '{0}'</target>
+        <target state="translated">生成枚举成员“{0}”</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_field_0">
         <source>Generate field '{0}'</source>
-        <target state="new">Generate field '{0}'</target>
+        <target state="translated">生成字段“{0}”</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_for_0">
@@ -697,7 +697,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Generate_method_0">
         <source>Generate method '{0}'</source>
-        <target state="new">Generate method '{0}'</target>
+        <target state="translated">生成方法“{0}”</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_parameter_0">
@@ -712,17 +712,17 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Generate_property_0">
         <source>Generate property '{0}'</source>
-        <target state="new">Generate property '{0}'</target>
+        <target state="translated">生成属性“{0}”</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_field_0">
         <source>Generate read-only field '{0}'</source>
-        <target state="new">Generate read-only field '{0}'</target>
+        <target state="translated">生成只读字段“{0}”</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_property_0">
         <source>Generate read-only property '{0}'</source>
-        <target state="new">Generate read-only property '{0}'</target>
+        <target state="translated">生成只读属性“{0}”</target>
         <note />
       </trans-unit>
       <trans-unit id="Illegal_backslash_at_end_of_pattern">
@@ -947,7 +947,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Miscellaneous_Files">
         <source>Miscellaneous Files</source>
-        <target state="new">Miscellaneous Files</target>
+        <target state="translated">杂项文件</target>
         <note />
       </trans-unit>
       <trans-unit id="Missing_control_character">
@@ -1057,7 +1057,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type">
         <source>Move static members to another type...</source>
-        <target state="new">Move static members to another type...</target>
+        <target state="translated">将静态成员移到另一类型...</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -1072,7 +1072,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Navigating_to_symbol_0_from_1">
         <source>Navigating to symbol '{0}' from '{1}'.</source>
-        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <target state="translated">从“{1}”导航到符号“{0}”。</target>
         <note />
       </trans-unit>
       <trans-unit id="Nested_quantifier_0">
@@ -1087,7 +1087,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="No_source_document_info_found_in_PDB">
         <source>No source document info found in PDB.</source>
-        <target state="new">No source document info found in PDB.</target>
+        <target state="translated">未在 PDB 中找到源文档信息。</target>
         <note />
       </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
@@ -1275,11 +1275,11 @@ This option is recommended if you know that backtracking will not succeed. Preve
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
+        <target state="translated">均衡组定义删除以前定义的组的定义，并在当前组中存储以前定义的组和当前组之间的时间间隔。
 
-'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+“name1” 是当前组(可选)，“name2” 是以前定义的组，而 “subexpression” 是任何有效的正则表达式模式。均衡组定义将删除 name2 的定义，并在 name1 中存储 name2 和 name1 之间的间隔。如果未定义 name2 组，则匹配回溯。由于删除 name2 的最后一个定义会发现 name2 的上一个定义，此构造使你能够将组 name2 的捕获堆栈用作计数器来跟踪嵌套构造(如括号或左括号和右括号)。
 
-The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
+均衡组定义使用 “name2” 作为堆栈。每个嵌套构造的开始字符都放在该组中并位于其组中。捕获集合。匹配结束字符时，将从组中删除其相应的开始字符，并且捕获集合将减少 1。在所有嵌套构造的开始和结束字符都匹配后，“name1” 为空。</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
@@ -2352,7 +2352,7 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Silent">
         <source>Silent</source>
-        <target state="new">Silent</target>
+        <target state="translated">无提示</target>
         <note />
       </trans-unit>
       <trans-unit id="Sort_accessibility_modifiers">
@@ -2362,12 +2362,12 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
         <source>Source code language information was not found in PDB.</source>
-        <target state="new">Source code language information was not found in PDB.</target>
+        <target state="translated">在 PDB 中找不到源代码语言信息。</target>
         <note />
       </trans-unit>
       <trans-unit id="Source_is_a_reference_assembly">
         <source>Source is a reference assembly, not enough information to find PDB.</source>
-        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <target state="translated">源是引用程序集，信息不足，无法查找 PDB。</target>
         <note />
       </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
@@ -2397,7 +2397,7 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Symbol_found_in_assembly_path_0">
         <source>Symbol found in assembly path '{0}'</source>
-        <target state="new">Symbol found in assembly path '{0}'</target>
+        <target state="translated">在程序集路径 "{0}" 中找到符号</target>
         <note />
       </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
@@ -2427,12 +2427,12 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Timeout_SourceLink">
         <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <target state="translated">尝试从 SourceLink 下载源代码时超时。如果继续尝试进行请求，有可能会成功。</target>
         <note />
       </trans-unit>
       <trans-unit id="Timeout_symbol_server">
         <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <target state="translated">尝试从符号服务器下载 PDB 时超时。如果继续尝试进行请求，有可能会成功。</target>
         <note />
       </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
@@ -2447,7 +2447,7 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Types_colon">
         <source>Types:</source>
-        <target state="new">Types:</target>
+        <target state="translated">类型:</target>
         <note />
       </trans-unit>
       <trans-unit id="UnableToReadSourceFileOrPdb">
@@ -2737,42 +2737,42 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB">
         <source>'{0}' found in embedded PDB.</source>
-        <target state="new">'{0}' found in embedded PDB.</target>
+        <target state="translated">在嵌入的 PDB 中找到“{0}”。</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
         <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">在嵌入 PDB 中找到“{0}”，但校验和错误或无法读取临时文件。</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
         <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
-        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <target state="translated">在嵌入的 PDB 中找到“{0}”，但无法写入临时文件:“{1}”</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
         <source>'{0}' found in embedded PDB and found cached source file.</source>
-        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <target state="translated">在嵌入的 PDB 中找到“{0}”，并找到缓存的源文件。</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location">
         <source>'{0}' found in original location.</source>
-        <target state="new">'{0}' found in original location.</target>
+        <target state="translated">在原始位置找到“{0}”。</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location_but_checksum_failed">
         <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">在原始位置找到“{0}”，但校验和错误或无法读取临时文件。</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink">
         <source>'{0}' found via SourceLink.</source>
-        <target state="new">'{0}' found via SourceLink.</target>
+        <target state="translated">通过 SourceLink 找到“{0}”。</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
         <source>'{0}' found via SourceLink but couldn't read temp file.</source>
-        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <target state="translated">通过 SourceLink 找到“{0}”，但无法读取临时文件。</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_is_not_null_here">
@@ -3105,12 +3105,12 @@ If the "d" format specifier is used without other custom format specifiers, it's
       </trans-unit>
       <trans-unit id="embedded">
         <source>embedded</source>
-        <target state="new">embedded</target>
+        <target state="translated">嵌入源</target>
         <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
       </trans-unit>
       <trans-unit id="external">
         <source>external</source>
-        <target state="new">external</target>
+        <target state="translated">外部源</target>
         <note>External means "external source", meaning source files that are not part of the current solution</note>
       </trans-unit>
       <trans-unit id="from_metadata">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf
index 4b1b6c5456124..db0472a9be682 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf
@@ -242,12 +242,12 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression">
         <source>Await the preceding expression</source>
-        <target state="new">Await the preceding expression</target>
+        <target state="translated">等待上述運算式</target>
         <note />
       </trans-unit>
       <trans-unit id="Await_the_preceding_expression_and_add_ConfigureAwait_0">
         <source>Await the preceding expression and add ConfigureAwait({0}).</source>
-        <target state="new">Await the preceding expression and add ConfigureAwait({0}).</target>
+        <target state="translated">等待上述運算式並新增 ConfigureAwait({0})。</target>
         <note>{Locked="ConfigureAwait"} "ConfigureAwait" is an api name and should not be localized. {0} is a placeholder for the language specific keyword 'false'.</note>
       </trans-unit>
       <trans-unit id="Awaited_task_returns_0">
@@ -472,12 +472,12 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded">
         <source>Could not find portable PDB on disk or embedded.</source>
-        <target state="new">Could not find portable PDB on disk or embedded.</target>
+        <target state="translated">磁碟或內嵌上找不到可攜式 PDB。</target>
         <note />
       </trans-unit>
       <trans-unit id="Could_not_find_PDB_on_disk_or_embedded_or_server">
         <source>Could not find PDB on disk, or embedded, or on a symbol server.</source>
-        <target state="new">Could not find PDB on disk, or embedded, or on a symbol server.</target>
+        <target state="translated">在磁碟、內嵌或符號伺服器上找不到 PDB。</target>
         <note />
       </trans-unit>
       <trans-unit id="Create_and_assign_field_0">
@@ -562,7 +562,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Error_reading_PDB_0">
         <source>Error reading PDB: '{0}'</source>
-        <target state="new">Error reading PDB: '{0}'</target>
+        <target state="translated">讀取 PDB 時發生錯誤: '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Example">
@@ -582,7 +582,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Explicitly_inherit_documentation">
         <source>Explicitly inherit documentation</source>
-        <target state="new">Explicitly inherit documentation</target>
+        <target state="translated">明確繼承文件</target>
         <note />
       </trans-unit>
       <trans-unit id="Extract_base_class">
@@ -632,32 +632,32 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Found_PDB_file_at_0">
         <source>Found PDB file at '{0}'</source>
-        <target state="new">Found PDB file at '{0}'</target>
+        <target state="translated">在 '{0}' 找到 PDB 檔案</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server">
         <source>Found PDB on symbol server.</source>
-        <target state="new">Found PDB on symbol server.</target>
+        <target state="translated">在符號伺服器上找到 PDB。</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_PDB_on_symbol_server_but_could_not_read_file">
         <source>Found PDB on symbol server but could not read file.</source>
-        <target state="new">Found PDB on symbol server but could not read file.</target>
+        <target state="translated">在符號伺服器上找到 PDB，但無法讀取檔案。</target>
         <note />
       </trans-unit>
       <trans-unit id="Found_embedded_PDB_file">
         <source>Found embedded PDB file.</source>
-        <target state="new">Found embedded PDB file.</target>
+        <target state="translated">找到內嵌的 PDB 檔案。</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_method_0">
         <source>Generate abstract method '{0}'</source>
-        <target state="new">Generate abstract method '{0}'</target>
+        <target state="translated">產生抽象方法 '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_abstract_property_0">
         <source>Generate abstract property '{0}'</source>
-        <target state="new">Generate abstract property '{0}'</target>
+        <target state="translated">產生抽象屬性 '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_comparison_operators">
@@ -667,7 +667,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Generate_constant_0">
         <source>Generate constant '{0}'</source>
-        <target state="new">Generate constant '{0}'</target>
+        <target state="translated">產生常數 '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_constructor_in_0_with_fields">
@@ -682,12 +682,12 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Generate_enum_member_0">
         <source>Generate enum member '{0}'</source>
-        <target state="new">Generate enum member '{0}'</target>
+        <target state="translated">產生列舉成員 '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_field_0">
         <source>Generate field '{0}'</source>
-        <target state="new">Generate field '{0}'</target>
+        <target state="translated">產生欄位 '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_for_0">
@@ -697,7 +697,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Generate_method_0">
         <source>Generate method '{0}'</source>
-        <target state="new">Generate method '{0}'</target>
+        <target state="translated">產生方法 '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_parameter_0">
@@ -712,17 +712,17 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Generate_property_0">
         <source>Generate property '{0}'</source>
-        <target state="new">Generate property '{0}'</target>
+        <target state="translated">產生屬性 '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_field_0">
         <source>Generate read-only field '{0}'</source>
-        <target state="new">Generate read-only field '{0}'</target>
+        <target state="translated">產生唯讀欄位 '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Generate_read_only_property_0">
         <source>Generate read-only property '{0}'</source>
-        <target state="new">Generate read-only property '{0}'</target>
+        <target state="translated">產生唯讀屬性 '{0}'</target>
         <note />
       </trans-unit>
       <trans-unit id="Illegal_backslash_at_end_of_pattern">
@@ -947,7 +947,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Miscellaneous_Files">
         <source>Miscellaneous Files</source>
-        <target state="new">Miscellaneous Files</target>
+        <target state="translated">其他檔案</target>
         <note />
       </trans-unit>
       <trans-unit id="Missing_control_character">
@@ -1057,7 +1057,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type">
         <source>Move static members to another type...</source>
-        <target state="new">Move static members to another type...</target>
+        <target state="translated">將靜態成員移至其他類型...</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -1072,7 +1072,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="Navigating_to_symbol_0_from_1">
         <source>Navigating to symbol '{0}' from '{1}'.</source>
-        <target state="new">Navigating to symbol '{0}' from '{1}'.</target>
+        <target state="translated">正在從 '{1}' 瀏覽至符號 '{0}'。</target>
         <note />
       </trans-unit>
       <trans-unit id="Nested_quantifier_0">
@@ -1087,7 +1087,7 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
       </trans-unit>
       <trans-unit id="No_source_document_info_found_in_PDB">
         <source>No source document info found in PDB.</source>
-        <target state="new">No source document info found in PDB.</target>
+        <target state="translated">PDB 中找不到來源文件資訊。</target>
         <note />
       </trans-unit>
       <trans-unit id="No_valid_location_to_insert_method_call">
@@ -1275,11 +1275,11 @@ This option is recommended if you know that backtracking will not succeed. Preve
 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
 
 The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
-        <target state="new">A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
+        <target state="translated">平衡群組定義會刪除先前已定義群組的定義，並將先前定義的群組和目前群組間的間隔儲存在目前的群組內。
 
-'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.
+'name1' 是目前的群組 (選擇性)，'name2' 是先前定義的群組，'subexpression' 是任何有效的規則運算式模式。平衡群組定義會刪除 name2 的定義，並將 name2 與 name1 之間的間隔儲存在 name1 內。如果未指定 name2 群組，則比對會回溯。因為刪除 name2 的上一個定義會顯示 name2 先前的定義，所以此建構可讓您使用群組 name2 的擷取堆疊來作為計數器，用來追蹤括號或左右括弧等巢狀建構。
 
-The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</target>
+平衡群組定義會使用 'name2' 作為堆疊。各巢狀建構的開頭字元會置於群組和其 Group.Captures 集合內。符合右側字元時，會將其對應的左側字元從群組移除，使 Captures 集合減少一。當所有巢狀建構的左側和右側字元均相符後，'name1' 會空白。</target>
         <note />
       </trans-unit>
       <trans-unit id="Regex_balancing_group_short">
@@ -2352,7 +2352,7 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Silent">
         <source>Silent</source>
-        <target state="new">Silent</target>
+        <target state="translated">Silent</target>
         <note />
       </trans-unit>
       <trans-unit id="Sort_accessibility_modifiers">
@@ -2362,12 +2362,12 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Source_code_language_information_was_not_found_in_PDB">
         <source>Source code language information was not found in PDB.</source>
-        <target state="new">Source code language information was not found in PDB.</target>
+        <target state="translated">PDB 中找不到原始程式碼語言資訊。</target>
         <note />
       </trans-unit>
       <trans-unit id="Source_is_a_reference_assembly">
         <source>Source is a reference assembly, not enough information to find PDB.</source>
-        <target state="new">Source is a reference assembly, not enough information to find PDB.</target>
+        <target state="translated">來源是參考組件，資訊不足，無法尋找 PDB。</target>
         <note />
       </trans-unit>
       <trans-unit id="Split_into_consecutive_0_statements">
@@ -2397,7 +2397,7 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Symbol_found_in_assembly_path_0">
         <source>Symbol found in assembly path '{0}'</source>
-        <target state="new">Symbol found in assembly path '{0}'</target>
+        <target state="translated">在組件路徑 '{0}' 中找到符號</target>
         <note />
       </trans-unit>
       <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
@@ -2427,12 +2427,12 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Timeout_SourceLink">
         <source>Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download source code from SourceLink. Subsequent requests may succeed.</target>
+        <target state="translated">嘗試從 SourceLink 下載原始程式碼時發生逾時。後續的要求可能會成功。</target>
         <note />
       </trans-unit>
       <trans-unit id="Timeout_symbol_server">
         <source>Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</source>
-        <target state="new">Timed out trying to download PDB from symbol server. Subsequent requests may succeed.</target>
+        <target state="translated">嘗試從符號伺服器下載 PDB 時發生逾時。後續的要求可能會成功。</target>
         <note />
       </trans-unit>
       <trans-unit id="Too_many_bars_in_conditional_grouping">
@@ -2447,7 +2447,7 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Types_colon">
         <source>Types:</source>
-        <target state="new">Types:</target>
+        <target state="translated">類型:</target>
         <note />
       </trans-unit>
       <trans-unit id="UnableToReadSourceFileOrPdb">
@@ -2737,42 +2737,42 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB">
         <source>'{0}' found in embedded PDB.</source>
-        <target state="new">'{0}' found in embedded PDB.</target>
+        <target state="translated">在內嵌 PDB 中找到 '{0}'。</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_checksum_failed">
         <source>'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in embedded PDB but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">在內嵌 PDB 中找到 '{0}'，但總和檢查碼錯誤或無法讀取暫存檔案。</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_but_could_not_write_file_1">
         <source>'{0}' found in embedded PDB but could not write to temp file: '{1}'</source>
-        <target state="new">'{0}' found in embedded PDB but could not write to temp file: '{1}'</target>
+        <target state="translated">在內嵌 PDB 中找到 '{0}'，但無法寫入暫存檔案: '{1}'</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_embedded_PDB_cached_source_file">
         <source>'{0}' found in embedded PDB and found cached source file.</source>
-        <target state="new">'{0}' found in embedded PDB and found cached source file.</target>
+        <target state="translated">在內嵌 PDB 中找到 '{0}'，並找到快取的來源檔案。</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location">
         <source>'{0}' found in original location.</source>
-        <target state="new">'{0}' found in original location.</target>
+        <target state="translated">在原始位置找到 '{0}'。</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_in_original_location_but_checksum_failed">
         <source>'{0}' found in original location but checksum was wrong, or couldn't read temp file.</source>
-        <target state="new">'{0}' found in original location but checksum was wrong, or couldn't read temp file.</target>
+        <target state="translated">在原始位置找到 '{0}'，但總和檢查碼錯誤或無法讀取暫存檔案。</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink">
         <source>'{0}' found via SourceLink.</source>
-        <target state="new">'{0}' found via SourceLink.</target>
+        <target state="translated">透過 SourceLink 找到 '{0}'。</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_found_via_SourceLink_but_couldnt_read_file">
         <source>'{0}' found via SourceLink but couldn't read temp file.</source>
-        <target state="new">'{0}' found via SourceLink but couldn't read temp file.</target>
+        <target state="translated">透過 SourceLink 找到 '{0}'，但無法讀取暫存檔案。</target>
         <note />
       </trans-unit>
       <trans-unit id="_0_is_not_null_here">
@@ -3105,12 +3105,12 @@ If the "d" format specifier is used without other custom format specifiers, it's
       </trans-unit>
       <trans-unit id="embedded">
         <source>embedded</source>
-        <target state="new">embedded</target>
+        <target state="translated">內嵌</target>
         <note>Embedded is a technical term for "Embedded source", where souce files are embedded into the PDB</note>
       </trans-unit>
       <trans-unit id="external">
         <source>external</source>
-        <target state="new">external</target>
+        <target state="translated">外部</target>
         <note>External means "external source", meaning source files that are not part of the current solution</note>
       </trans-unit>
       <trans-unit id="from_metadata">
diff --git a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.es.xlf b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.es.xlf
index 907e9ff0f86c3..610773f10b381 100644
--- a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.es.xlf
+++ b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.es.xlf
@@ -1469,7 +1469,7 @@ Function(&lt;listaDeParámetros&gt;) &lt;expresión&gt;</target>
         <source>Defines a lambda expression that can execute statements and does not return a value. Can be used wherever a delegate type is expected.
 Sub(&lt;parameterList&gt;) &lt;statement&gt;</source>
         <target state="translated">Define una expresión lambda que puede ejecutar instrucciones y no devuelve un valor. Se puede usar dondequiera que se espere un tipo de delegado.
-Sub(&lt;listaDeParámetros&gt;) &lt;instrucción&gt;</target>
+Sub(&lt;listaDeParámetros&gt;) &lt;instrucción&gt;wo laopo fuke</target>
         <note />
       </trans-unit>
       <trans-unit id="Disables_reporting_of_specified_warnings_in_the_portion_of_the_source_file_below_the_current_line">
@@ -1719,7 +1719,7 @@ Sub(&lt;listaDeParámetros&gt;) &lt;instrucción&gt;</target>
       </trans-unit>
       <trans-unit id="namespace_name">
         <source>&lt;namespace name&gt;</source>
-        <target state="translated">&lt;nombre del espacio de nombres&gt;</target>
+        <target state="translated">&lt;nombre de espacio de nombres&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="Type_a_name_here_to_declare_a_namespace">
@@ -1734,12 +1734,12 @@ Sub(&lt;listaDeParámetros&gt;) &lt;instrucción&gt;</target>
       </trans-unit>
       <trans-unit id="class_name">
         <source>&lt;class name&gt;</source>
-        <target state="translated">&lt;nombre de clase&gt;</target>
+        <target state="translated">&lt;nombre de la clase&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="interface_name">
         <source>&lt;interface name&gt;</source>
-        <target state="translated">&lt;nombre de interfaz&gt;</target>
+        <target state="translated">&lt;nombre de la interfaz&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="module_name">
diff --git a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.it.xlf b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.it.xlf
index f7c65da246cda..f802a35c45e58 100644
--- a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.it.xlf
+++ b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.it.xlf
@@ -1719,7 +1719,7 @@ Sub(&lt;elencoParametri&gt;) &lt;istruzione&gt;</target>
       </trans-unit>
       <trans-unit id="namespace_name">
         <source>&lt;namespace name&gt;</source>
-        <target state="translated">&lt;nome dello spazio dei nomi&gt;</target>
+        <target state="translated">&lt;nome spazio dei nomi&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="Type_a_name_here_to_declare_a_namespace">
@@ -1734,7 +1734,7 @@ Sub(&lt;elencoParametri&gt;) &lt;istruzione&gt;</target>
       </trans-unit>
       <trans-unit id="class_name">
         <source>&lt;class name&gt;</source>
-        <target state="translated">&lt;nome della classe&gt;</target>
+        <target state="translated">&lt;nome classe&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="interface_name">
diff --git a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.pt-BR.xlf b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.pt-BR.xlf
index 11dcb816be114..ec3334f79b88e 100644
--- a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.pt-BR.xlf
+++ b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.pt-BR.xlf
@@ -1734,7 +1734,7 @@ Sub(&lt;parameterList&gt;) &lt;statement&gt;</target>
       </trans-unit>
       <trans-unit id="class_name">
         <source>&lt;class name&gt;</source>
-        <target state="translated">&lt;nome de classe&gt;</target>
+        <target state="translated">&lt;nome da classe&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="interface_name">
diff --git a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.tr.xlf b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.tr.xlf
index 67163ec9ee876..a14226a4972ef 100644
--- a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.tr.xlf
+++ b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.tr.xlf
@@ -1719,7 +1719,7 @@ Sub(&lt;parameterList&gt;) &lt;statement&gt;</target>
       </trans-unit>
       <trans-unit id="namespace_name">
         <source>&lt;namespace name&gt;</source>
-        <target state="translated">&lt;namespace name&gt;</target>
+        <target state="translated">&lt;ad alanı adı&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="Type_a_name_here_to_declare_a_namespace">
diff --git a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.zh-Hans.xlf b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.zh-Hans.xlf
index c27a1d70e0ece..454b7d9b2673a 100644
--- a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.zh-Hans.xlf
+++ b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.zh-Hans.xlf
@@ -1043,15 +1043,15 @@ Do...Loop {While | Until} &lt;condition&gt;</target>
       <trans-unit id="Repeats_a_block_of_statements_until_a_Boolean_condition_becomes_true_Do_Until_condition_Loop">
         <source>Repeats a block of statements until a Boolean condition becomes true.
 Do Until &lt;condition&gt;...Loop</source>
-        <target state="translated">在布尔条件变为 true 之前重复语句块。
-Do Until &lt;condition&gt;...Loop</target>
+        <target state="translated">重复语句块，直到布尔条件变为 true。
+直到&lt;条件&gt;...环</target>
         <note />
       </trans-unit>
       <trans-unit id="Repeats_a_block_of_statements_while_a_Boolean_condition_is_true_Do_While_condition_Loop">
         <source>Repeats a block of statements while a Boolean condition is true.
 Do While &lt;condition&gt;...Loop</source>
-        <target state="translated">在布尔条件为 true 时重复语句块。
-Do While &lt;condition&gt;...Loop</target>
+        <target state="translated">当布尔条件为 true 时重复语句块。
+&lt;条件时执行操作&gt;...环</target>
         <note />
       </trans-unit>
       <trans-unit id="Introduces_a_group_of_statements_in_an_SharpIf_statement_that_is_compiled_if_no_previous_condition_evaluates_to_True">
@@ -1233,15 +1233,15 @@ Option Infer {On | Off}</target>
       <trans-unit id="Repeats_a_block_of_statements_until_a_Boolean_condition_becomes_true_Do_Loop_Until_condition">
         <source>Repeats a block of statements until a Boolean condition becomes true.
 Do...Loop Until &lt;condition&gt;</source>
-        <target state="translated">在布尔条件变为 true 之前重复语句块。
-Do...Loop Until &lt;condition&gt;</target>
+        <target state="translated">重复语句块，直到布尔条件变为 true。
+...循环到&lt;条件&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="Repeats_a_block_of_statements_while_a_Boolean_condition_is_true_Do_Loop_While_condition">
         <source>Repeats a block of statements while a Boolean condition is true.
 Do...Loop While &lt;condition&gt;</source>
-        <target state="translated">在布尔条件为 true 时重复语句块。
-Do...Loop While &lt;condition&gt;</target>
+        <target state="translated">当布尔条件为 true 时重复语句块。
+...循环 While&lt;条件&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="Provides_a_way_to_refer_to_the_current_instance_of_a_class_or_structure_that_is_the_instance_in_which_the_code_is_running">
@@ -1443,7 +1443,7 @@ New &lt;typeName&gt; With {[.&lt;property&gt; = &lt;expression&gt;][,...]}</targ
         <source>Runs a series of statements that refer to a single object or structure.
 With &lt;object&gt;...End With</source>
         <target state="translated">运行引用单个对象或结构的一系列语句。
-With &lt;object&gt;...End With</target>
+使用&lt;object&gt;...结尾为</target>
         <note />
       </trans-unit>
       <trans-unit id="Produces_an_element_of_an_IEnumerable_or_IEnumerator">
diff --git a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.zh-Hant.xlf b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.zh-Hant.xlf
index d3845dce4d5e1..56d63d942b184 100644
--- a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.zh-Hant.xlf
+++ b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.zh-Hant.xlf
@@ -1369,8 +1369,8 @@ Option Strict {On | Off}</target>
       <trans-unit id="Ensures_that_multiple_threads_do_not_execute_the_statement_block_at_the_same_time_SyncLock_object_End_Synclock">
         <source>Ensures that multiple threads do not execute the statement block at the same time.
 SyncLock &lt;object&gt;...End Synclock</source>
-        <target state="translated">確定不會有多個執行緒同時執行此陳述式區塊。
-SyncLock &lt;object&gt;...End Synclock</target>
+        <target state="translated">確保多個執行緒不會同時執行語句區塊。
+SyncLock &lt;object&gt;...結束同步鎖定</target>
         <note />
       </trans-unit>
       <trans-unit id="Includes_elements_up_to_a_specified_position_in_the_collection">
@@ -1442,8 +1442,8 @@ New &lt;typeName&gt; With {[.&lt;property&gt; = &lt;expression&gt;][,...]}</targ
       <trans-unit id="Runs_a_series_of_statements_that_refer_to_a_single_object_or_structure_With_object_End_With">
         <source>Runs a series of statements that refer to a single object or structure.
 With &lt;object&gt;...End With</source>
-        <target state="translated">執行一系列參考單一物件或結構的陳述式。
-With &lt;object&gt;...End With</target>
+        <target state="translated">執行一系列參照單一物件或結構的語句。
+物件&lt;object&gt;...結尾為</target>
         <note />
       </trans-unit>
       <trans-unit id="Produces_an_element_of_an_IEnumerable_or_IEnumerator">
@@ -1739,7 +1739,7 @@ Sub(&lt;parameterList&gt;) &lt;statement&gt;</target>
       </trans-unit>
       <trans-unit id="interface_name">
         <source>&lt;interface name&gt;</source>
-        <target state="translated">&lt;介面名稱&gt;</target>
+        <target state="translated">&lt;interface name&gt;</target>
         <note />
       </trans-unit>
       <trans-unit id="module_name">
diff --git a/src/Scripting/CSharp/xlf/CSharpScriptingResources.de.xlf b/src/Scripting/CSharp/xlf/CSharpScriptingResources.de.xlf
index 8a2762c3048e2..755eb3efcb599 100644
--- a/src/Scripting/CSharp/xlf/CSharpScriptingResources.de.xlf
+++ b/src/Scripting/CSharp/xlf/CSharpScriptingResources.de.xlf
@@ -50,7 +50,7 @@ Optionen:
                                  (alternative Formate: /libPath /libPaths).
   /u:&lt;Namespace&gt;                 Definiert einen globalen Namespace mit "using" (alternative Formate: /using, /usings, /import, /imports).
   /langversion:?                 Zeigt die zulässigen Werte für die Sprachversion an und beendet den Vorgang.
-  /langversion:&lt;string&gt;          Gibt die Sprachversion an, z. B.
+  /langversion:&lt;string&gt;          Gibt die Sprachversion an, z.B.
                                  "latest" (neueste Version, einschließlich Nebenversionen),
                                  "default" (entspricht "latest"),
                                  "latestmajor" (neueste Version ohne Nebenversionen),
diff --git a/src/Scripting/VisualBasic/xlf/VBScriptingResources.it.xlf b/src/Scripting/VisualBasic/xlf/VBScriptingResources.it.xlf
index 9d62eb2c52122..065035bef7b32 100644
--- a/src/Scripting/VisualBasic/xlf/VBScriptingResources.it.xlf
+++ b/src/Scripting/VisualBasic/xlf/VBScriptingResources.it.xlf
@@ -27,7 +27,7 @@ Options:
   /define:&lt;name&gt;=&lt;value&gt;,...     Declare global conditional compilation symbol(s) (Short form: /d)
   @&lt;file&gt;                        Read response file for more options
 </source>
-        <target state="translated">Sintassi: vbi [opzioni] [file-script.vbx] [-- argomenti-script]
+        <target state="translated">Sintassi: vbi [options] [script-file.vbx] [-- script-arguments]
 
 Esegue lo script se è specificato un valore per file-script; in caso contrario, avvia un REPL (Read Eval Print Loop) interattivo.
 
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.cs.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.cs.xlf
index bcb0b9dda1e3a..09e95666b9598 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.cs.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.cs.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Prefer_extended_property_pattern">
         <source>Prefer extended property pattern</source>
-        <target state="new">Prefer extended property pattern</target>
+        <target state="translated">Upřednostňovat rozšířený vzor vlastností</target>
         <note />
       </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.de.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.de.xlf
index c8727c855de95..bd12f0794f18c 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.de.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.de.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Prefer_extended_property_pattern">
         <source>Prefer extended property pattern</source>
-        <target state="new">Prefer extended property pattern</target>
+        <target state="translated">Muster für erweiterte Eigenschaften bevorzugen</target>
         <note />
       </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.es.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.es.xlf
index 9f520f7aa0694..5bc61708c9bed 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.es.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.es.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Prefer_extended_property_pattern">
         <source>Prefer extended property pattern</source>
-        <target state="new">Prefer extended property pattern</target>
+        <target state="translated">Preferir patrón de propiedad extendido</target>
         <note />
       </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.fr.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.fr.xlf
index 4b3d4bbe92c02..83b96c364db75 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.fr.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.fr.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Prefer_extended_property_pattern">
         <source>Prefer extended property pattern</source>
-        <target state="new">Prefer extended property pattern</target>
+        <target state="translated">Préférer le modèle de propriété étendue</target>
         <note />
       </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.it.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.it.xlf
index 436467d250a55..52109aa4312f5 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.it.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.it.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Prefer_extended_property_pattern">
         <source>Prefer extended property pattern</source>
-        <target state="new">Prefer extended property pattern</target>
+        <target state="translated">Preferisci il modello di proprietà estesa</target>
         <note />
       </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ja.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ja.xlf
index 74ded6521f820..8dee71f43d296 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ja.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ja.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Prefer_extended_property_pattern">
         <source>Prefer extended property pattern</source>
-        <target state="new">Prefer extended property pattern</target>
+        <target state="translated">拡張プロパティ パターンを優先する</target>
         <note />
       </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ko.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ko.xlf
index ae5e528b54aef..5e0ba18814888 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ko.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ko.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Prefer_extended_property_pattern">
         <source>Prefer extended property pattern</source>
-        <target state="new">Prefer extended property pattern</target>
+        <target state="translated">확장 속성 패턴 선호</target>
         <note />
       </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pl.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pl.xlf
index 230dbc961c0fd..d37e715cf06f5 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pl.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pl.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Prefer_extended_property_pattern">
         <source>Prefer extended property pattern</source>
-        <target state="new">Prefer extended property pattern</target>
+        <target state="translated">Preferuj wzorzec właściwości rozszerzonej</target>
         <note />
       </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pt-BR.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pt-BR.xlf
index c5ae128b775b0..d480bc26e835b 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pt-BR.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pt-BR.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Prefer_extended_property_pattern">
         <source>Prefer extended property pattern</source>
-        <target state="new">Prefer extended property pattern</target>
+        <target state="translated">Prefere o padrão de propriedade estendida</target>
         <note />
       </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ru.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ru.xlf
index c020550f114e7..170bed209c897 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ru.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ru.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Prefer_extended_property_pattern">
         <source>Prefer extended property pattern</source>
-        <target state="new">Prefer extended property pattern</target>
+        <target state="translated">Предпочитать расширенный шаблон свойства</target>
         <note />
       </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.tr.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.tr.xlf
index d95ae7aa6044c..4522ccc8964ec 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.tr.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.tr.xlf
@@ -89,7 +89,7 @@
       </trans-unit>
       <trans-unit id="In_relational_binary_operators">
         <source>In relational operators:  &lt;   &gt;   &lt;=   &gt;=   is   as   ==   !=</source>
-        <target state="translated">İlişkisel işleçleri içinde: &lt;&gt; = &lt; &gt; = == gibi! =</target>
+        <target state="translated">İlişkisel işleçleri içinde: &lt;&gt; = &lt;&gt; = == gibi! =</target>
         <note>'is' and 'as' are C# keywords and should not be localized</note>
       </trans-unit>
       <trans-unit id="Insert_slash_slash_at_the_start_of_new_lines_when_writing_slash_slash_comments">
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Prefer_extended_property_pattern">
         <source>Prefer extended property pattern</source>
-        <target state="new">Prefer extended property pattern</target>
+        <target state="translated">Genişletilmiş özellik desenini tercih et</target>
         <note />
       </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hans.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hans.xlf
index 36757db206d37..4f9a891e435ca 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hans.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hans.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Prefer_extended_property_pattern">
         <source>Prefer extended property pattern</source>
-        <target state="new">Prefer extended property pattern</target>
+        <target state="translated">首选扩展属性模式</target>
         <note />
       </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hant.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hant.xlf
index d020b3844fde6..0eb842208f890 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hant.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hant.xlf
@@ -124,7 +124,7 @@
       </trans-unit>
       <trans-unit id="Prefer_extended_property_pattern">
         <source>Prefer extended property pattern</source>
-        <target state="new">Prefer extended property pattern</target>
+        <target state="translated">偏好擴充屬性模式</target>
         <note />
       </trans-unit>
       <trans-unit id="Prefer_implicit_object_creation_when_type_is_apparent">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ko.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ko.xlf
index c44ad75ca228c..9c983ca43da96 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ko.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ko.xlf
@@ -305,10 +305,10 @@ Show items from unimported namespaces (experimental);</source>
 코드 조각 포함 안 함;
 코드 조각 항상 포함;
 식별자 뒤에 ?-Tab을 입력하면 코드 조각 포함;
-&amp;lt;Enter&amp;gt; 키 동작;
-&amp;lt;Enter&amp;gt; 키를 누를 때 새 줄 추가 안 함;
-단어를 모두 입력한 후 &amp;lt;Enter&amp;gt; 키를 누를 때만 새 줄 추가;
-&amp;lt;Enter&amp;gt; 키를 누를 때 항상 새 줄 추가;
+&lt;Enter&gt; 키 동작;
+&lt;Enter&gt; 키를 누를 때 새 줄 추가 안 함;
+단어를 모두 입력한 후 &lt;Enter&gt; 키를 누를 때만 새 줄 추가;
+&lt;Enter&gt; 키를 누를 때 항상 새 줄 추가;
 이름 제안 표시;
 가져오지 않은 네임스페이스의 항목 표시(실험적);</target>
         <note>C# IntelliSense options page keywords</note>
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.cs.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.cs.xlf
index 47016693a2da1..3a14c7cdea65e 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.cs.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.cs.xlf
@@ -4,22 +4,22 @@
     <body>
       <trans-unit id="ECMD_RUNFXCOPSEL|ButtonText">
         <source>Run Code &amp;Analysis on Selection</source>
-        <target state="translated">&amp;Spustit analýzu kódu na výběr</target>
+        <target state="translated">Spustit &amp;analýzu kódu při výběru</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|ButtonText">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Průzkumník trasování zásobníku</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|CommandName">
         <source>ShowStackTraceExplorerCommandName</source>
-        <target state="new">ShowStackTraceExplorerCommandName</target>
+        <target state="translated">ShowStackTraceExplorerCommandName</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|LocCanonicalName">
         <source>ShowStackTraceExplorer</source>
-        <target state="new">ShowStackTraceExplorer</target>
+        <target state="translated">ShowStackTraceExplorer</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdidAnalysisScopeCurrentFile|ButtonText">
@@ -319,7 +319,7 @@
       </trans-unit>
       <trans-unit id="cmdidRunCodeAnalysisForProject|ButtonText">
         <source>Run C&amp;ode Analysis</source>
-        <target state="translated">Spustit &amp;analýzu kódu</target>
+        <target state="translated">Spustit analýzu &amp;kódu</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdidRunCodeAnalysisForProject|CommandName">
@@ -514,7 +514,7 @@
       </trans-unit>
       <trans-unit id="cmdidSyncNamespaces|ButtonText">
         <source>Sync &amp;Namespaces</source>
-        <target state="translated">Synchronizovat &amp;obory názvů</target>
+        <target state="translated">Synchronizovat obory &amp;názvů</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdidSyncNamespaces|CommandName">
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="new">ShowValueTracking</target>
+        <target state="translated">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.de.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.de.xlf
index 5365882fb3c2e..2fde3db181821 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.de.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.de.xlf
@@ -9,17 +9,17 @@
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|ButtonText">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Stack Trace Explorer</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|CommandName">
         <source>ShowStackTraceExplorerCommandName</source>
-        <target state="new">ShowStackTraceExplorerCommandName</target>
+        <target state="translated">ShowStackTraceExplorerCommandName</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|LocCanonicalName">
         <source>ShowStackTraceExplorer</source>
-        <target state="new">ShowStackTraceExplorer</target>
+        <target state="translated">ShowStackTraceExplorer</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdidAnalysisScopeCurrentFile|ButtonText">
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="new">ShowValueTracking</target>
+        <target state="translated">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.es.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.es.xlf
index b2391b1b620d7..a3368d9150c9c 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.es.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.es.xlf
@@ -9,17 +9,17 @@
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|ButtonText">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Explorador de seguimiento de pila</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|CommandName">
         <source>ShowStackTraceExplorerCommandName</source>
-        <target state="new">ShowStackTraceExplorerCommandName</target>
+        <target state="translated">ShowStackTraceExplorerCommandName</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|LocCanonicalName">
         <source>ShowStackTraceExplorer</source>
-        <target state="new">ShowStackTraceExplorer</target>
+        <target state="translated">ShowStackTraceExplorer</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdidAnalysisScopeCurrentFile|ButtonText">
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="new">ShowValueTracking</target>
+        <target state="translated">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.fr.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.fr.xlf
index 3358da7a885d7..3688161baf5b5 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.fr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.fr.xlf
@@ -9,22 +9,22 @@
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|ButtonText">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Explorateur de traces de pile</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|CommandName">
         <source>ShowStackTraceExplorerCommandName</source>
-        <target state="new">ShowStackTraceExplorerCommandName</target>
+        <target state="translated">ShowStackTraceExplorerCommandName</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|LocCanonicalName">
         <source>ShowStackTraceExplorer</source>
-        <target state="new">ShowStackTraceExplorer</target>
+        <target state="translated">ShowStackTraceExplorer</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdidAnalysisScopeCurrentFile|ButtonText">
         <source>&amp;Current Document</source>
-        <target state="translated">&amp;Document actif</target>
+        <target state="translated">Document a&amp;ctif</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdidAnalysisScopeCurrentFile|CommandName">
@@ -69,7 +69,7 @@
       </trans-unit>
       <trans-unit id="cmdidAnalysisScopeOpenFiles|ButtonText">
         <source>&amp;Open Documents</source>
-        <target state="translated">&amp;Documents ouverts</target>
+        <target state="translated">Documents &amp;ouverts</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdidAnalysisScopeOpenFiles|CommandName">
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="new">ShowValueTracking</target>
+        <target state="translated">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.it.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.it.xlf
index 23ede8b3c63e0..c9ccec6cda20d 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.it.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.it.xlf
@@ -9,17 +9,17 @@
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|ButtonText">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Esplora analisi dello stack</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|CommandName">
         <source>ShowStackTraceExplorerCommandName</source>
-        <target state="new">ShowStackTraceExplorerCommandName</target>
+        <target state="translated">ShowStackTraceExplorerCommandName</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|LocCanonicalName">
         <source>ShowStackTraceExplorer</source>
-        <target state="new">ShowStackTraceExplorer</target>
+        <target state="translated">ShowStackTraceExplorer</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdidAnalysisScopeCurrentFile|ButtonText">
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="new">ShowValueTracking</target>
+        <target state="translated">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ja.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ja.xlf
index 16fbb59599d20..062a84fe657cb 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ja.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ja.xlf
@@ -9,17 +9,17 @@
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|ButtonText">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">スタック トレース エクスプローラー</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|CommandName">
         <source>ShowStackTraceExplorerCommandName</source>
-        <target state="new">ShowStackTraceExplorerCommandName</target>
+        <target state="translated">ShowStackTraceExplorerCommandName</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|LocCanonicalName">
         <source>ShowStackTraceExplorer</source>
-        <target state="new">ShowStackTraceExplorer</target>
+        <target state="translated">ShowStackTraceExplorer</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdidAnalysisScopeCurrentFile|ButtonText">
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="new">ShowValueTracking</target>
+        <target state="translated">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ko.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ko.xlf
index 6370a4b4f9349..f841df3844623 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ko.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ko.xlf
@@ -4,22 +4,22 @@
     <body>
       <trans-unit id="ECMD_RUNFXCOPSEL|ButtonText">
         <source>Run Code &amp;Analysis on Selection</source>
-        <target state="translated">선택 영역에 대해 코드 분석 실행(&amp;A)</target>
+        <target state="translated">선택 영역에 코드 분석 실행(&amp;A)</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|ButtonText">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">스택 추적 탐색기</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|CommandName">
         <source>ShowStackTraceExplorerCommandName</source>
-        <target state="new">ShowStackTraceExplorerCommandName</target>
+        <target state="translated">ShowStackTraceExplorerCommandName</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|LocCanonicalName">
         <source>ShowStackTraceExplorer</source>
-        <target state="new">ShowStackTraceExplorer</target>
+        <target state="translated">ShowStackTraceExplorer</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdidAnalysisScopeCurrentFile|ButtonText">
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="new">ShowValueTracking</target>
+        <target state="translated">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.pl.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.pl.xlf
index 1e087ee92161e..19b7613d96091 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.pl.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.pl.xlf
@@ -9,17 +9,17 @@
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|ButtonText">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Eksplorator śladu stosu</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|CommandName">
         <source>ShowStackTraceExplorerCommandName</source>
-        <target state="new">ShowStackTraceExplorerCommandName</target>
+        <target state="translated">ShowStackTraceExplorerCommandName</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|LocCanonicalName">
         <source>ShowStackTraceExplorer</source>
-        <target state="new">ShowStackTraceExplorer</target>
+        <target state="translated">ShowStackTraceExplorer</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdidAnalysisScopeCurrentFile|ButtonText">
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="new">ShowValueTracking</target>
+        <target state="translated">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.pt-BR.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.pt-BR.xlf
index 84b30b014a033..261151f921972 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.pt-BR.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.pt-BR.xlf
@@ -9,17 +9,17 @@
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|ButtonText">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Explorador de Rastreamento de Pilha</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|CommandName">
         <source>ShowStackTraceExplorerCommandName</source>
-        <target state="new">ShowStackTraceExplorerCommandName</target>
+        <target state="translated">ShowStackTraceExplorerCommandName</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|LocCanonicalName">
         <source>ShowStackTraceExplorer</source>
-        <target state="new">ShowStackTraceExplorer</target>
+        <target state="translated">ShowStackTraceExplorer</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdidAnalysisScopeCurrentFile|ButtonText">
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="new">ShowValueTracking</target>
+        <target state="translated">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ru.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ru.xlf
index 9a25da077a0d0..aa3e45a3c6b88 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ru.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ru.xlf
@@ -9,17 +9,17 @@
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|ButtonText">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Обозреватель трассировки стека</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|CommandName">
         <source>ShowStackTraceExplorerCommandName</source>
-        <target state="new">ShowStackTraceExplorerCommandName</target>
+        <target state="translated">ShowStackTraceExplorerCommandName</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|LocCanonicalName">
         <source>ShowStackTraceExplorer</source>
-        <target state="new">ShowStackTraceExplorer</target>
+        <target state="translated">ShowStackTraceExplorer</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdidAnalysisScopeCurrentFile|ButtonText">
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="new">ShowValueTracking</target>
+        <target state="translated">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.tr.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.tr.xlf
index 6f13ac38d8bf2..3aecee00a9172 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.tr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.tr.xlf
@@ -9,17 +9,17 @@
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|ButtonText">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Yığın İzlemesi Gezgini</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|CommandName">
         <source>ShowStackTraceExplorerCommandName</source>
-        <target state="new">ShowStackTraceExplorerCommandName</target>
+        <target state="translated">ShowStackTraceExplorerCommandName</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|LocCanonicalName">
         <source>ShowStackTraceExplorer</source>
-        <target state="new">ShowStackTraceExplorer</target>
+        <target state="translated">ShowStackTraceExplorer</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdidAnalysisScopeCurrentFile|ButtonText">
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="new">ShowValueTracking</target>
+        <target state="translated">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hans.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hans.xlf
index c54de2a375280..8466eb778ad49 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hans.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hans.xlf
@@ -9,17 +9,17 @@
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|ButtonText">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">堆栈跟踪资源管理器</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|CommandName">
         <source>ShowStackTraceExplorerCommandName</source>
-        <target state="new">ShowStackTraceExplorerCommandName</target>
+        <target state="translated">ShowStackTraceExplorerCommandName</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|LocCanonicalName">
         <source>ShowStackTraceExplorer</source>
-        <target state="new">ShowStackTraceExplorer</target>
+        <target state="translated">ShowStackTraceExplorer</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdidAnalysisScopeCurrentFile|ButtonText">
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="new">ShowValueTracking</target>
+        <target state="translated">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hant.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hant.xlf
index b94e275f845a7..e09c4f5462327 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hant.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hant.xlf
@@ -9,17 +9,17 @@
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|ButtonText">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">堆疊追蹤總管</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|CommandName">
         <source>ShowStackTraceExplorerCommandName</source>
-        <target state="new">ShowStackTraceExplorerCommandName</target>
+        <target state="translated">ShowStackTraceExplorerCommandName</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdIdShowStackTraceExplorer|LocCanonicalName">
         <source>ShowStackTraceExplorer</source>
-        <target state="new">ShowStackTraceExplorer</target>
+        <target state="translated">ShowStackTraceExplorer</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdidAnalysisScopeCurrentFile|ButtonText">
@@ -539,7 +539,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|LocCanonicalName">
         <source>ShowValueTracking</source>
-        <target state="new">ShowValueTracking</target>
+        <target state="translated">ShowValueTracking</target>
         <note />
       </trans-unit>
       <trans-unit id="guidCSharpInteractiveCommandSet|cmdidResetInteractiveFromProject|ButtonText">
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
index df778c63825d8..fcd981d487234 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
         <source>Automatically open Stack Trace Explorer on focus</source>
-        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <target state="translated">Automaticky otevírat Průzkumníka trasování zásobníku při fokusu</target>
         <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
       </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
@@ -204,12 +204,12 @@
       </trans-unit>
       <trans-unit id="Clear">
         <source>Clear</source>
-        <target state="new">Clear</target>
+        <target state="translated">Vymazat</target>
         <note>Clear content action</note>
       </trans-unit>
       <trans-unit id="Close_tab">
         <source>Close Tab</source>
-        <target state="new">Close Tab</target>
+        <target state="translated">Zavřít kartu</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Style">
@@ -314,7 +314,7 @@
       </trans-unit>
       <trans-unit id="Display_diagnostics_inline_experimental">
         <source>Display diagnostics inline (experimental)</source>
-        <target state="new">Display diagnostics inline (experimental)</target>
+        <target state="translated">Zobrazit vloženou diagnostiku (experimentální)</target>
         <note />
       </trans-unit>
       <trans-unit id="Display_inline_parameter_name_hints">
@@ -504,7 +504,7 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_experimental">
         <source>Inline Diagnostics (experimental)</source>
-        <target state="new">Inline Diagnostics (experimental)</target>
+        <target state="translated">Vložená diagnostika (experimentální)</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -534,7 +534,7 @@
       </trans-unit>
       <trans-unit id="Invalid_type_name">
         <source>Invalid type name</source>
-        <target state="new">Invalid type name</target>
+        <target state="translated">Neplatný název typu</target>
         <note />
       </trans-unit>
       <trans-unit id="Item_origin">
@@ -609,7 +609,7 @@
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type_colon">
         <source>Move Static Members to Another Type:</source>
-        <target state="new">Move Static Members to Another Type:</target>
+        <target state="translated">Přesunout statické členy do jiného typu:</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -809,7 +809,7 @@
       </trans-unit>
       <trans-unit id="Navigate_to_external_sources">
         <source>Navigate to External Sources</source>
-        <target state="new">Navigate to External Sources</target>
+        <target state="translated">Přejít na externí zdroje</target>
         <note />
       </trans-unit>
       <trans-unit id="Never">
@@ -959,12 +959,12 @@
       </trans-unit>
       <trans-unit id="Paste">
         <source>Paste</source>
-        <target state="new">Paste</target>
+        <target state="translated">Vložit</target>
         <note />
       </trans-unit>
       <trans-unit id="Paste_valid_stack_trace">
         <source>Paste a valid stack trace to view and navigate it's values</source>
-        <target state="new">Paste a valid stack trace to view and navigate it's values</target>
+        <target state="translated">Pokud chcete zobrazit a procházet jeho hodnoty, vložte platné trasování zásobníku.</target>
         <note>"Stack Trace" is a language term and should be kept the same. </note>
       </trans-unit>
       <trans-unit id="Paused_0_tasks_in_queue">
@@ -1029,7 +1029,7 @@
       </trans-unit>
       <trans-unit id="Prefer_tuple_swap">
         <source>Prefer tuple swap</source>
-        <target state="new">Prefer tuple swap</target>
+        <target state="translated">Preferovat prohození řazené kolekce členů</target>
         <note />
       </trans-unit>
       <trans-unit id="Projects">
@@ -1074,7 +1074,7 @@
       </trans-unit>
       <trans-unit id="Remove_unnecessary_usings">
         <source>Remove unnecessary usings</source>
-        <target state="new">Remove unnecessary usings</target>
+        <target state="translated">Odebrat nepotřebné direktivy using</target>
         <note />
       </trans-unit>
       <trans-unit id="Rename_0_to_1">
@@ -1254,17 +1254,17 @@
       </trans-unit>
       <trans-unit id="Sort_usings">
         <source>Sort usings</source>
-        <target state="new">Sort usings</target>
+        <target state="translated">Seřadit direktivy using</target>
         <note />
       </trans-unit>
       <trans-unit id="Stack_Trace_Explorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Průzkumník trasování zásobníku</target>
         <note>"Stack Trace" is a language term and should be kept the same. This is for viewing/exploring stack traces</note>
       </trans-unit>
       <trans-unit id="Stack_trace_0">
         <source>Stack Trace {0}</source>
-        <target state="new">Stack Trace {0}</target>
+        <target state="translated">Trasování zásobníku: {0}</target>
         <note>Header for numbered stack trace view tabs</note>
       </trans-unit>
       <trans-unit id="Suggestion">
@@ -1274,7 +1274,7 @@
       </trans-unit>
       <trans-unit id="Suppress_hints_when_argument_matches_parameter_name">
         <source>Suppress hints when argument matches parameter name</source>
-        <target state="new">Suppress hints when argument matches parameter name</target>
+        <target state="translated">Potlačit nápovědy, když argument odpovídá názvu parametru</target>
         <note />
       </trans-unit>
       <trans-unit id="Suppress_hints_when_parameter_name_matches_the_method_s_intent">
@@ -1619,7 +1619,7 @@
       </trans-unit>
       <trans-unit id="at_the_end_of_the_line_of_code">
         <source>at the end of the line of code</source>
-        <target state="new">at the end of the line of code</target>
+        <target state="translated">na konci řádku kódu</target>
         <note />
       </trans-unit>
       <trans-unit id="generated_by_0_suffix">
@@ -2645,7 +2645,7 @@ Další informace: {1}</target>
       </trans-unit>
       <trans-unit id="on_the_right_edge_of_the_editor_window">
         <source>on the right edge of the editor window</source>
-        <target state="new">on the right edge of the editor window</target>
+        <target state="translated">na pravém okraji okna editoru</target>
         <note />
       </trans-unit>
       <trans-unit id="with_other_members_of_the_same_kind">
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
index e685b1c144ccc..529459b546735 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
         <source>Automatically open Stack Trace Explorer on focus</source>
-        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <target state="translated">Stack Trace Explorer automatisch im Fokus öffnen</target>
         <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
       </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
@@ -204,12 +204,12 @@
       </trans-unit>
       <trans-unit id="Clear">
         <source>Clear</source>
-        <target state="new">Clear</target>
+        <target state="translated">Löschen</target>
         <note>Clear content action</note>
       </trans-unit>
       <trans-unit id="Close_tab">
         <source>Close Tab</source>
-        <target state="new">Close Tab</target>
+        <target state="translated">Registerkarte schließen</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Style">
@@ -314,7 +314,7 @@
       </trans-unit>
       <trans-unit id="Display_diagnostics_inline_experimental">
         <source>Display diagnostics inline (experimental)</source>
-        <target state="new">Display diagnostics inline (experimental)</target>
+        <target state="translated">Diagnose inline anzeigen (experimentell)</target>
         <note />
       </trans-unit>
       <trans-unit id="Display_inline_parameter_name_hints">
@@ -504,7 +504,7 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_experimental">
         <source>Inline Diagnostics (experimental)</source>
-        <target state="new">Inline Diagnostics (experimental)</target>
+        <target state="translated">Inline-Diagnose (experimentell)</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -534,7 +534,7 @@
       </trans-unit>
       <trans-unit id="Invalid_type_name">
         <source>Invalid type name</source>
-        <target state="new">Invalid type name</target>
+        <target state="translated">Ungültiger Typname</target>
         <note />
       </trans-unit>
       <trans-unit id="Item_origin">
@@ -609,7 +609,7 @@
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type_colon">
         <source>Move Static Members to Another Type:</source>
-        <target state="new">Move Static Members to Another Type:</target>
+        <target state="translated">Statische Mitglieder werden in einen anderen Typ verschoben:</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -809,7 +809,7 @@
       </trans-unit>
       <trans-unit id="Navigate_to_external_sources">
         <source>Navigate to External Sources</source>
-        <target state="new">Navigate to External Sources</target>
+        <target state="translated">Zu externen Quellen navigieren</target>
         <note />
       </trans-unit>
       <trans-unit id="Never">
@@ -959,12 +959,12 @@
       </trans-unit>
       <trans-unit id="Paste">
         <source>Paste</source>
-        <target state="new">Paste</target>
+        <target state="translated">Einfügen</target>
         <note />
       </trans-unit>
       <trans-unit id="Paste_valid_stack_trace">
         <source>Paste a valid stack trace to view and navigate it's values</source>
-        <target state="new">Paste a valid stack trace to view and navigate it's values</target>
+        <target state="translated">Fügen Sie eine gültige Stapelüberwachung ein, um ihre Werte anzuzeigen und durch sie zu navigieren.</target>
         <note>"Stack Trace" is a language term and should be kept the same. </note>
       </trans-unit>
       <trans-unit id="Paused_0_tasks_in_queue">
@@ -1029,7 +1029,7 @@
       </trans-unit>
       <trans-unit id="Prefer_tuple_swap">
         <source>Prefer tuple swap</source>
-        <target state="new">Prefer tuple swap</target>
+        <target state="translated">Tupeltausch bevorzugen</target>
         <note />
       </trans-unit>
       <trans-unit id="Projects">
@@ -1074,7 +1074,7 @@
       </trans-unit>
       <trans-unit id="Remove_unnecessary_usings">
         <source>Remove unnecessary usings</source>
-        <target state="new">Remove unnecessary usings</target>
+        <target state="translated">Nicht benötigte Using-Direktiven entfernen</target>
         <note />
       </trans-unit>
       <trans-unit id="Rename_0_to_1">
@@ -1254,17 +1254,17 @@
       </trans-unit>
       <trans-unit id="Sort_usings">
         <source>Sort usings</source>
-        <target state="new">Sort usings</target>
+        <target state="translated">Using-Direktiven sortieren</target>
         <note />
       </trans-unit>
       <trans-unit id="Stack_Trace_Explorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Stack Trace Explorer</target>
         <note>"Stack Trace" is a language term and should be kept the same. This is for viewing/exploring stack traces</note>
       </trans-unit>
       <trans-unit id="Stack_trace_0">
         <source>Stack Trace {0}</source>
-        <target state="new">Stack Trace {0}</target>
+        <target state="translated">Stapelüberwachung {0}</target>
         <note>Header for numbered stack trace view tabs</note>
       </trans-unit>
       <trans-unit id="Suggestion">
@@ -1274,7 +1274,7 @@
       </trans-unit>
       <trans-unit id="Suppress_hints_when_argument_matches_parameter_name">
         <source>Suppress hints when argument matches parameter name</source>
-        <target state="new">Suppress hints when argument matches parameter name</target>
+        <target state="translated">Hinweise unterdrücken, wenn das Argument mit dem Namen des Parameters übereinstimmt</target>
         <note />
       </trans-unit>
       <trans-unit id="Suppress_hints_when_parameter_name_matches_the_method_s_intent">
@@ -1619,7 +1619,7 @@
       </trans-unit>
       <trans-unit id="at_the_end_of_the_line_of_code">
         <source>at the end of the line of code</source>
-        <target state="new">at the end of the line of code</target>
+        <target state="translated">am Ende der Codezeile</target>
         <note />
       </trans-unit>
       <trans-unit id="generated_by_0_suffix">
@@ -2645,7 +2645,7 @@ Zusätzliche Informationen: {1}</target>
       </trans-unit>
       <trans-unit id="on_the_right_edge_of_the_editor_window">
         <source>on the right edge of the editor window</source>
-        <target state="new">on the right edge of the editor window</target>
+        <target state="translated">am rechten Rand des Editorfensters</target>
         <note />
       </trans-unit>
       <trans-unit id="with_other_members_of_the_same_kind">
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
index 5565e745ace81..1b36dfb32fe2d 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
         <source>Automatically open Stack Trace Explorer on focus</source>
-        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <target state="translated">Abrir automáticamente el Explorador de seguimiento de pila al centrarse</target>
         <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
       </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
@@ -204,12 +204,12 @@
       </trans-unit>
       <trans-unit id="Clear">
         <source>Clear</source>
-        <target state="new">Clear</target>
+        <target state="translated">Borrar</target>
         <note>Clear content action</note>
       </trans-unit>
       <trans-unit id="Close_tab">
         <source>Close Tab</source>
-        <target state="new">Close Tab</target>
+        <target state="translated">Cerrar pestaña</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Style">
@@ -314,7 +314,7 @@
       </trans-unit>
       <trans-unit id="Display_diagnostics_inline_experimental">
         <source>Display diagnostics inline (experimental)</source>
-        <target state="new">Display diagnostics inline (experimental)</target>
+        <target state="translated">Mostrar diagnósticos incorporados (experimental)</target>
         <note />
       </trans-unit>
       <trans-unit id="Display_inline_parameter_name_hints">
@@ -504,7 +504,7 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_experimental">
         <source>Inline Diagnostics (experimental)</source>
-        <target state="new">Inline Diagnostics (experimental)</target>
+        <target state="translated">Diagnósticos incorporados (experimental)</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -534,7 +534,7 @@
       </trans-unit>
       <trans-unit id="Invalid_type_name">
         <source>Invalid type name</source>
-        <target state="new">Invalid type name</target>
+        <target state="translated">Nombre de tipo no válido.</target>
         <note />
       </trans-unit>
       <trans-unit id="Item_origin">
@@ -609,7 +609,7 @@
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type_colon">
         <source>Move Static Members to Another Type:</source>
-        <target state="new">Move Static Members to Another Type:</target>
+        <target state="translated">Mover miembros estáticos a otro tipo:</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -809,7 +809,7 @@
       </trans-unit>
       <trans-unit id="Navigate_to_external_sources">
         <source>Navigate to External Sources</source>
-        <target state="new">Navigate to External Sources</target>
+        <target state="translated">Navegar a orígenes externos</target>
         <note />
       </trans-unit>
       <trans-unit id="Never">
@@ -959,12 +959,12 @@
       </trans-unit>
       <trans-unit id="Paste">
         <source>Paste</source>
-        <target state="new">Paste</target>
+        <target state="translated">Pegar</target>
         <note />
       </trans-unit>
       <trans-unit id="Paste_valid_stack_trace">
         <source>Paste a valid stack trace to view and navigate it's values</source>
-        <target state="new">Paste a valid stack trace to view and navigate it's values</target>
+        <target state="translated">Pegar un seguimiento de pila válido para ver y navegar sus valores</target>
         <note>"Stack Trace" is a language term and should be kept the same. </note>
       </trans-unit>
       <trans-unit id="Paused_0_tasks_in_queue">
@@ -1029,7 +1029,7 @@
       </trans-unit>
       <trans-unit id="Prefer_tuple_swap">
         <source>Prefer tuple swap</source>
-        <target state="new">Prefer tuple swap</target>
+        <target state="translated">Preferir el intercambio de tupla</target>
         <note />
       </trans-unit>
       <trans-unit id="Projects">
@@ -1074,7 +1074,7 @@
       </trans-unit>
       <trans-unit id="Remove_unnecessary_usings">
         <source>Remove unnecessary usings</source>
-        <target state="new">Remove unnecessary usings</target>
+        <target state="translated">Eliminar instrucciones Using innecesarias</target>
         <note />
       </trans-unit>
       <trans-unit id="Rename_0_to_1">
@@ -1254,17 +1254,17 @@
       </trans-unit>
       <trans-unit id="Sort_usings">
         <source>Sort usings</source>
-        <target state="new">Sort usings</target>
+        <target state="translated">Ordenar instrucciones Using</target>
         <note />
       </trans-unit>
       <trans-unit id="Stack_Trace_Explorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Explorador de seguimiento de pila</target>
         <note>"Stack Trace" is a language term and should be kept the same. This is for viewing/exploring stack traces</note>
       </trans-unit>
       <trans-unit id="Stack_trace_0">
         <source>Stack Trace {0}</source>
-        <target state="new">Stack Trace {0}</target>
+        <target state="translated">Seguimiento de la pila {0}</target>
         <note>Header for numbered stack trace view tabs</note>
       </trans-unit>
       <trans-unit id="Suggestion">
@@ -1274,7 +1274,7 @@
       </trans-unit>
       <trans-unit id="Suppress_hints_when_argument_matches_parameter_name">
         <source>Suppress hints when argument matches parameter name</source>
-        <target state="new">Suppress hints when argument matches parameter name</target>
+        <target state="translated">Suprimir las sugerencias cuando el argumento coincide con el nombre del parámetro</target>
         <note />
       </trans-unit>
       <trans-unit id="Suppress_hints_when_parameter_name_matches_the_method_s_intent">
@@ -1619,7 +1619,7 @@
       </trans-unit>
       <trans-unit id="at_the_end_of_the_line_of_code">
         <source>at the end of the line of code</source>
-        <target state="new">at the end of the line of code</target>
+        <target state="translated">al final de la línea de código</target>
         <note />
       </trans-unit>
       <trans-unit id="generated_by_0_suffix">
@@ -2645,7 +2645,7 @@ Información adicional: {1}</target>
       </trans-unit>
       <trans-unit id="on_the_right_edge_of_the_editor_window">
         <source>on the right edge of the editor window</source>
-        <target state="new">on the right edge of the editor window</target>
+        <target state="translated">En el borde derecho de la ventana del editor</target>
         <note />
       </trans-unit>
       <trans-unit id="with_other_members_of_the_same_kind">
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
index e348189b66c9b..bc379136aefad 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
         <source>Automatically open Stack Trace Explorer on focus</source>
-        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <target state="translated">Ouvrir automatiquement l’Explorateur de traces de pile en cas de focus</target>
         <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
       </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
@@ -204,12 +204,12 @@
       </trans-unit>
       <trans-unit id="Clear">
         <source>Clear</source>
-        <target state="new">Clear</target>
+        <target state="translated">Effacer</target>
         <note>Clear content action</note>
       </trans-unit>
       <trans-unit id="Close_tab">
         <source>Close Tab</source>
-        <target state="new">Close Tab</target>
+        <target state="translated">Fermer l'onglet</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Style">
@@ -314,7 +314,7 @@
       </trans-unit>
       <trans-unit id="Display_diagnostics_inline_experimental">
         <source>Display diagnostics inline (experimental)</source>
-        <target state="new">Display diagnostics inline (experimental)</target>
+        <target state="translated">Afficher les diagnostics en ligne (expérimental)</target>
         <note />
       </trans-unit>
       <trans-unit id="Display_inline_parameter_name_hints">
@@ -504,7 +504,7 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_experimental">
         <source>Inline Diagnostics (experimental)</source>
-        <target state="new">Inline Diagnostics (experimental)</target>
+        <target state="translated">Diagnostic en ligne (expérimental)</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -534,7 +534,7 @@
       </trans-unit>
       <trans-unit id="Invalid_type_name">
         <source>Invalid type name</source>
-        <target state="new">Invalid type name</target>
+        <target state="translated">Nom de type invalide</target>
         <note />
       </trans-unit>
       <trans-unit id="Item_origin">
@@ -609,7 +609,7 @@
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type_colon">
         <source>Move Static Members to Another Type:</source>
-        <target state="new">Move Static Members to Another Type:</target>
+        <target state="translated">Déplacer les membres statiques vers un autre type :</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -809,7 +809,7 @@
       </trans-unit>
       <trans-unit id="Navigate_to_external_sources">
         <source>Navigate to External Sources</source>
-        <target state="new">Navigate to External Sources</target>
+        <target state="translated">Accéder aux sources externes</target>
         <note />
       </trans-unit>
       <trans-unit id="Never">
@@ -959,12 +959,12 @@
       </trans-unit>
       <trans-unit id="Paste">
         <source>Paste</source>
-        <target state="new">Paste</target>
+        <target state="translated">Coller</target>
         <note />
       </trans-unit>
       <trans-unit id="Paste_valid_stack_trace">
         <source>Paste a valid stack trace to view and navigate it's values</source>
-        <target state="new">Paste a valid stack trace to view and navigate it's values</target>
+        <target state="translated">Collez une trace de pile valide pour afficher et parcourir ses valeurs</target>
         <note>"Stack Trace" is a language term and should be kept the same. </note>
       </trans-unit>
       <trans-unit id="Paused_0_tasks_in_queue">
@@ -1029,7 +1029,7 @@
       </trans-unit>
       <trans-unit id="Prefer_tuple_swap">
         <source>Prefer tuple swap</source>
-        <target state="new">Prefer tuple swap</target>
+        <target state="translated">Préférer l'échange de tuples</target>
         <note />
       </trans-unit>
       <trans-unit id="Projects">
@@ -1074,7 +1074,7 @@
       </trans-unit>
       <trans-unit id="Remove_unnecessary_usings">
         <source>Remove unnecessary usings</source>
-        <target state="new">Remove unnecessary usings</target>
+        <target state="translated">Supprimer les Usings inutiles</target>
         <note />
       </trans-unit>
       <trans-unit id="Rename_0_to_1">
@@ -1254,17 +1254,17 @@
       </trans-unit>
       <trans-unit id="Sort_usings">
         <source>Sort usings</source>
-        <target state="new">Sort usings</target>
+        <target state="translated">Trier les instructions using</target>
         <note />
       </trans-unit>
       <trans-unit id="Stack_Trace_Explorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Explorateur de traces de pile</target>
         <note>"Stack Trace" is a language term and should be kept the same. This is for viewing/exploring stack traces</note>
       </trans-unit>
       <trans-unit id="Stack_trace_0">
         <source>Stack Trace {0}</source>
-        <target state="new">Stack Trace {0}</target>
+        <target state="translated">Trace de la pile {0}</target>
         <note>Header for numbered stack trace view tabs</note>
       </trans-unit>
       <trans-unit id="Suggestion">
@@ -1274,7 +1274,7 @@
       </trans-unit>
       <trans-unit id="Suppress_hints_when_argument_matches_parameter_name">
         <source>Suppress hints when argument matches parameter name</source>
-        <target state="new">Suppress hints when argument matches parameter name</target>
+        <target state="translated">Supprimer les conseils lorsque l'argument correspond au nom du paramètre</target>
         <note />
       </trans-unit>
       <trans-unit id="Suppress_hints_when_parameter_name_matches_the_method_s_intent">
@@ -1619,7 +1619,7 @@
       </trans-unit>
       <trans-unit id="at_the_end_of_the_line_of_code">
         <source>at the end of the line of code</source>
-        <target state="new">at the end of the line of code</target>
+        <target state="translated">à la fin de la ligne de code</target>
         <note />
       </trans-unit>
       <trans-unit id="generated_by_0_suffix">
@@ -2645,7 +2645,7 @@ Informations supplémentaires : {1}</target>
       </trans-unit>
       <trans-unit id="on_the_right_edge_of_the_editor_window">
         <source>on the right edge of the editor window</source>
-        <target state="new">on the right edge of the editor window</target>
+        <target state="translated">sur le bord droit de la fenêtre de l'éditeur</target>
         <note />
       </trans-unit>
       <trans-unit id="with_other_members_of_the_same_kind">
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
index a3ebd3f58a5d6..dd280670703ec 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
         <source>Automatically open Stack Trace Explorer on focus</source>
-        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <target state="translated">Aprire automaticamente Stack Trace Explorer sullo stato attivo</target>
         <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
       </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
@@ -204,12 +204,12 @@
       </trans-unit>
       <trans-unit id="Clear">
         <source>Clear</source>
-        <target state="new">Clear</target>
+        <target state="translated">Cancella</target>
         <note>Clear content action</note>
       </trans-unit>
       <trans-unit id="Close_tab">
         <source>Close Tab</source>
-        <target state="new">Close Tab</target>
+        <target state="translated">Chiudi scheda</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Style">
@@ -314,7 +314,7 @@
       </trans-unit>
       <trans-unit id="Display_diagnostics_inline_experimental">
         <source>Display diagnostics inline (experimental)</source>
-        <target state="new">Display diagnostics inline (experimental)</target>
+        <target state="translated">Visualizza diagnostica inline (sperimentale)</target>
         <note />
       </trans-unit>
       <trans-unit id="Display_inline_parameter_name_hints">
@@ -504,7 +504,7 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_experimental">
         <source>Inline Diagnostics (experimental)</source>
-        <target state="new">Inline Diagnostics (experimental)</target>
+        <target state="translated">Diagnostica inline (sperimentale)</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -534,7 +534,7 @@
       </trans-unit>
       <trans-unit id="Invalid_type_name">
         <source>Invalid type name</source>
-        <target state="new">Invalid type name</target>
+        <target state="translated">Nome di tipo non valido</target>
         <note />
       </trans-unit>
       <trans-unit id="Item_origin">
@@ -609,7 +609,7 @@
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type_colon">
         <source>Move Static Members to Another Type:</source>
-        <target state="new">Move Static Members to Another Type:</target>
+        <target state="translated">Sposta membri statici in un altro tipo:</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -809,7 +809,7 @@
       </trans-unit>
       <trans-unit id="Navigate_to_external_sources">
         <source>Navigate to External Sources</source>
-        <target state="new">Navigate to External Sources</target>
+        <target state="translated">Passa a origini esterne</target>
         <note />
       </trans-unit>
       <trans-unit id="Never">
@@ -959,12 +959,12 @@
       </trans-unit>
       <trans-unit id="Paste">
         <source>Paste</source>
-        <target state="new">Paste</target>
+        <target state="translated">Incolla</target>
         <note />
       </trans-unit>
       <trans-unit id="Paste_valid_stack_trace">
         <source>Paste a valid stack trace to view and navigate it's values</source>
-        <target state="new">Paste a valid stack trace to view and navigate it's values</target>
+        <target state="translated">Incolla un'analisi dello stack valida per visualizzare e spostarti tra i relativi valori</target>
         <note>"Stack Trace" is a language term and should be kept the same. </note>
       </trans-unit>
       <trans-unit id="Paused_0_tasks_in_queue">
@@ -1029,7 +1029,7 @@
       </trans-unit>
       <trans-unit id="Prefer_tuple_swap">
         <source>Prefer tuple swap</source>
-        <target state="new">Prefer tuple swap</target>
+        <target state="translated">Preferisci lo scambio di tuple</target>
         <note />
       </trans-unit>
       <trans-unit id="Projects">
@@ -1074,7 +1074,7 @@
       </trans-unit>
       <trans-unit id="Remove_unnecessary_usings">
         <source>Remove unnecessary usings</source>
-        <target state="new">Remove unnecessary usings</target>
+        <target state="translated">Rimuovi istruzioni using non necessarie</target>
         <note />
       </trans-unit>
       <trans-unit id="Rename_0_to_1">
@@ -1254,17 +1254,17 @@
       </trans-unit>
       <trans-unit id="Sort_usings">
         <source>Sort usings</source>
-        <target state="new">Sort usings</target>
+        <target state="translated">Ordina using</target>
         <note />
       </trans-unit>
       <trans-unit id="Stack_Trace_Explorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Esplora analisi dello stack</target>
         <note>"Stack Trace" is a language term and should be kept the same. This is for viewing/exploring stack traces</note>
       </trans-unit>
       <trans-unit id="Stack_trace_0">
         <source>Stack Trace {0}</source>
-        <target state="new">Stack Trace {0}</target>
+        <target state="translated">Analisi dello stack {0}</target>
         <note>Header for numbered stack trace view tabs</note>
       </trans-unit>
       <trans-unit id="Suggestion">
@@ -1274,7 +1274,7 @@
       </trans-unit>
       <trans-unit id="Suppress_hints_when_argument_matches_parameter_name">
         <source>Suppress hints when argument matches parameter name</source>
-        <target state="new">Suppress hints when argument matches parameter name</target>
+        <target state="translated">Elimina hint quando l'argomento corrisponde al nome del parametro</target>
         <note />
       </trans-unit>
       <trans-unit id="Suppress_hints_when_parameter_name_matches_the_method_s_intent">
@@ -1619,7 +1619,7 @@
       </trans-unit>
       <trans-unit id="at_the_end_of_the_line_of_code">
         <source>at the end of the line of code</source>
-        <target state="new">at the end of the line of code</target>
+        <target state="translated">alla fine della riga di codice</target>
         <note />
       </trans-unit>
       <trans-unit id="generated_by_0_suffix">
@@ -2645,7 +2645,7 @@ Informazioni aggiuntive: {1}</target>
       </trans-unit>
       <trans-unit id="on_the_right_edge_of_the_editor_window">
         <source>on the right edge of the editor window</source>
-        <target state="new">on the right edge of the editor window</target>
+        <target state="translated">sul bordo destro della finestra dell'editor</target>
         <note />
       </trans-unit>
       <trans-unit id="with_other_members_of_the_same_kind">
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
index faee62cd5097f..2b00fdf122d0c 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
         <source>Automatically open Stack Trace Explorer on focus</source>
-        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <target state="translated">フォーカス時に スタック トレース エクスプローラーを自動的に開く</target>
         <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
       </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
@@ -204,12 +204,12 @@
       </trans-unit>
       <trans-unit id="Clear">
         <source>Clear</source>
-        <target state="new">Clear</target>
+        <target state="translated">クリア</target>
         <note>Clear content action</note>
       </trans-unit>
       <trans-unit id="Close_tab">
         <source>Close Tab</source>
-        <target state="new">Close Tab</target>
+        <target state="translated">タブを閉じる</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Style">
@@ -314,7 +314,7 @@
       </trans-unit>
       <trans-unit id="Display_diagnostics_inline_experimental">
         <source>Display diagnostics inline (experimental)</source>
-        <target state="new">Display diagnostics inline (experimental)</target>
+        <target state="translated">診断をインラインで表示する (試験的)</target>
         <note />
       </trans-unit>
       <trans-unit id="Display_inline_parameter_name_hints">
@@ -504,7 +504,7 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_experimental">
         <source>Inline Diagnostics (experimental)</source>
-        <target state="new">Inline Diagnostics (experimental)</target>
+        <target state="translated">インライン診断 (試験的)</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -534,7 +534,7 @@
       </trans-unit>
       <trans-unit id="Invalid_type_name">
         <source>Invalid type name</source>
-        <target state="new">Invalid type name</target>
+        <target state="translated">型名が無効です</target>
         <note />
       </trans-unit>
       <trans-unit id="Item_origin">
@@ -609,7 +609,7 @@
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type_colon">
         <source>Move Static Members to Another Type:</source>
-        <target state="new">Move Static Members to Another Type:</target>
+        <target state="translated">静的メンバーを別の型に移動する:</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -809,7 +809,7 @@
       </trans-unit>
       <trans-unit id="Navigate_to_external_sources">
         <source>Navigate to External Sources</source>
-        <target state="new">Navigate to External Sources</target>
+        <target state="translated">外部ソースに移動する</target>
         <note />
       </trans-unit>
       <trans-unit id="Never">
@@ -959,12 +959,12 @@
       </trans-unit>
       <trans-unit id="Paste">
         <source>Paste</source>
-        <target state="new">Paste</target>
+        <target state="translated">貼り付け</target>
         <note />
       </trans-unit>
       <trans-unit id="Paste_valid_stack_trace">
         <source>Paste a valid stack trace to view and navigate it's values</source>
-        <target state="new">Paste a valid stack trace to view and navigate it's values</target>
+        <target state="translated">有効なスタック トレースを貼り付けて、値を表示して移動します</target>
         <note>"Stack Trace" is a language term and should be kept the same. </note>
       </trans-unit>
       <trans-unit id="Paused_0_tasks_in_queue">
@@ -1029,7 +1029,7 @@
       </trans-unit>
       <trans-unit id="Prefer_tuple_swap">
         <source>Prefer tuple swap</source>
-        <target state="new">Prefer tuple swap</target>
+        <target state="translated">タプル スワップを優先する</target>
         <note />
       </trans-unit>
       <trans-unit id="Projects">
@@ -1074,7 +1074,7 @@
       </trans-unit>
       <trans-unit id="Remove_unnecessary_usings">
         <source>Remove unnecessary usings</source>
-        <target state="new">Remove unnecessary usings</target>
+        <target state="translated">不要な using の削除</target>
         <note />
       </trans-unit>
       <trans-unit id="Rename_0_to_1">
@@ -1254,17 +1254,17 @@
       </trans-unit>
       <trans-unit id="Sort_usings">
         <source>Sort usings</source>
-        <target state="new">Sort usings</target>
+        <target state="translated">using を並べ替える</target>
         <note />
       </trans-unit>
       <trans-unit id="Stack_Trace_Explorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">スタック トレース エクスプローラー</target>
         <note>"Stack Trace" is a language term and should be kept the same. This is for viewing/exploring stack traces</note>
       </trans-unit>
       <trans-unit id="Stack_trace_0">
         <source>Stack Trace {0}</source>
-        <target state="new">Stack Trace {0}</target>
+        <target state="translated">スタック トレース {0}</target>
         <note>Header for numbered stack trace view tabs</note>
       </trans-unit>
       <trans-unit id="Suggestion">
@@ -1274,7 +1274,7 @@
       </trans-unit>
       <trans-unit id="Suppress_hints_when_argument_matches_parameter_name">
         <source>Suppress hints when argument matches parameter name</source>
-        <target state="new">Suppress hints when argument matches parameter name</target>
+        <target state="translated">引数がパラメーター名と一致するとき、ヒントを抑制する</target>
         <note />
       </trans-unit>
       <trans-unit id="Suppress_hints_when_parameter_name_matches_the_method_s_intent">
@@ -1619,7 +1619,7 @@
       </trans-unit>
       <trans-unit id="at_the_end_of_the_line_of_code">
         <source>at the end of the line of code</source>
-        <target state="new">at the end of the line of code</target>
+        <target state="translated">コード行の末尾で</target>
         <note />
       </trans-unit>
       <trans-unit id="generated_by_0_suffix">
@@ -2645,7 +2645,7 @@ Additional information: {1}</source>
       </trans-unit>
       <trans-unit id="on_the_right_edge_of_the_editor_window">
         <source>on the right edge of the editor window</source>
-        <target state="new">on the right edge of the editor window</target>
+        <target state="translated">エディター ウィンドウの右端</target>
         <note />
       </trans-unit>
       <trans-unit id="with_other_members_of_the_same_kind">
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
index 06edf212428cb..2b2812a9b0524 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
         <source>Automatically open Stack Trace Explorer on focus</source>
-        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <target state="translated">포커스에서 자동으로 스택 추적 탐색기 열기</target>
         <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
       </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
@@ -204,12 +204,12 @@
       </trans-unit>
       <trans-unit id="Clear">
         <source>Clear</source>
-        <target state="new">Clear</target>
+        <target state="translated">지우기</target>
         <note>Clear content action</note>
       </trans-unit>
       <trans-unit id="Close_tab">
         <source>Close Tab</source>
-        <target state="new">Close Tab</target>
+        <target state="translated">탭 닫기</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Style">
@@ -314,7 +314,7 @@
       </trans-unit>
       <trans-unit id="Display_diagnostics_inline_experimental">
         <source>Display diagnostics inline (experimental)</source>
-        <target state="new">Display diagnostics inline (experimental)</target>
+        <target state="translated">진단 인라인 표시(실험적)</target>
         <note />
       </trans-unit>
       <trans-unit id="Display_inline_parameter_name_hints">
@@ -504,7 +504,7 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_experimental">
         <source>Inline Diagnostics (experimental)</source>
-        <target state="new">Inline Diagnostics (experimental)</target>
+        <target state="translated">인라인 진단(실험적)</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -534,7 +534,7 @@
       </trans-unit>
       <trans-unit id="Invalid_type_name">
         <source>Invalid type name</source>
-        <target state="new">Invalid type name</target>
+        <target state="translated">잘못된 형식 이름</target>
         <note />
       </trans-unit>
       <trans-unit id="Item_origin">
@@ -609,7 +609,7 @@
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type_colon">
         <source>Move Static Members to Another Type:</source>
-        <target state="new">Move Static Members to Another Type:</target>
+        <target state="translated">정적 멤버를 다른 형식으로 이동:</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -809,7 +809,7 @@
       </trans-unit>
       <trans-unit id="Navigate_to_external_sources">
         <source>Navigate to External Sources</source>
-        <target state="new">Navigate to External Sources</target>
+        <target state="translated">외부 원본으로 이동</target>
         <note />
       </trans-unit>
       <trans-unit id="Never">
@@ -959,12 +959,12 @@
       </trans-unit>
       <trans-unit id="Paste">
         <source>Paste</source>
-        <target state="new">Paste</target>
+        <target state="translated">붙여넣기</target>
         <note />
       </trans-unit>
       <trans-unit id="Paste_valid_stack_trace">
         <source>Paste a valid stack trace to view and navigate it's values</source>
-        <target state="new">Paste a valid stack trace to view and navigate it's values</target>
+        <target state="translated">유효한 스택 추적을 붙여넣어 해당 값을 보고 탐색합니다.</target>
         <note>"Stack Trace" is a language term and should be kept the same. </note>
       </trans-unit>
       <trans-unit id="Paused_0_tasks_in_queue">
@@ -1029,7 +1029,7 @@
       </trans-unit>
       <trans-unit id="Prefer_tuple_swap">
         <source>Prefer tuple swap</source>
-        <target state="new">Prefer tuple swap</target>
+        <target state="translated">튜플 교환 선호</target>
         <note />
       </trans-unit>
       <trans-unit id="Projects">
@@ -1074,7 +1074,7 @@
       </trans-unit>
       <trans-unit id="Remove_unnecessary_usings">
         <source>Remove unnecessary usings</source>
-        <target state="new">Remove unnecessary usings</target>
+        <target state="translated">불필요한 Using 제거</target>
         <note />
       </trans-unit>
       <trans-unit id="Rename_0_to_1">
@@ -1254,17 +1254,17 @@
       </trans-unit>
       <trans-unit id="Sort_usings">
         <source>Sort usings</source>
-        <target state="new">Sort usings</target>
+        <target state="translated">Using 정렬</target>
         <note />
       </trans-unit>
       <trans-unit id="Stack_Trace_Explorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">스택 추적 탐색기</target>
         <note>"Stack Trace" is a language term and should be kept the same. This is for viewing/exploring stack traces</note>
       </trans-unit>
       <trans-unit id="Stack_trace_0">
         <source>Stack Trace {0}</source>
-        <target state="new">Stack Trace {0}</target>
+        <target state="translated">스택 추적 {0}개</target>
         <note>Header for numbered stack trace view tabs</note>
       </trans-unit>
       <trans-unit id="Suggestion">
@@ -1274,7 +1274,7 @@
       </trans-unit>
       <trans-unit id="Suppress_hints_when_argument_matches_parameter_name">
         <source>Suppress hints when argument matches parameter name</source>
-        <target state="new">Suppress hints when argument matches parameter name</target>
+        <target state="translated">인수가 매개 변수 이름과 일치하는 경우 힌트 표시 안 함</target>
         <note />
       </trans-unit>
       <trans-unit id="Suppress_hints_when_parameter_name_matches_the_method_s_intent">
@@ -1619,7 +1619,7 @@
       </trans-unit>
       <trans-unit id="at_the_end_of_the_line_of_code">
         <source>at the end of the line of code</source>
-        <target state="new">at the end of the line of code</target>
+        <target state="translated">코드 줄의 끝에</target>
         <note />
       </trans-unit>
       <trans-unit id="generated_by_0_suffix">
@@ -2645,7 +2645,7 @@ Additional information: {1}</source>
       </trans-unit>
       <trans-unit id="on_the_right_edge_of_the_editor_window">
         <source>on the right edge of the editor window</source>
-        <target state="new">on the right edge of the editor window</target>
+        <target state="translated">편집기 창의 오른쪽 가장자리</target>
         <note />
       </trans-unit>
       <trans-unit id="with_other_members_of_the_same_kind">
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
index 39888b6f8488a..0b0dd74607534 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
         <source>Automatically open Stack Trace Explorer on focus</source>
-        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <target state="translated">Automatycznie otwieraj Stack Trace Explorer przy fokusie</target>
         <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
       </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
@@ -204,12 +204,12 @@
       </trans-unit>
       <trans-unit id="Clear">
         <source>Clear</source>
-        <target state="new">Clear</target>
+        <target state="translated">Wyczyść</target>
         <note>Clear content action</note>
       </trans-unit>
       <trans-unit id="Close_tab">
         <source>Close Tab</source>
-        <target state="new">Close Tab</target>
+        <target state="translated">Zamknij kartę</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Style">
@@ -314,7 +314,7 @@
       </trans-unit>
       <trans-unit id="Display_diagnostics_inline_experimental">
         <source>Display diagnostics inline (experimental)</source>
-        <target state="new">Display diagnostics inline (experimental)</target>
+        <target state="translated">Wyświetl diagnostykę w tekście (eksperymentalne)</target>
         <note />
       </trans-unit>
       <trans-unit id="Display_inline_parameter_name_hints">
@@ -504,7 +504,7 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_experimental">
         <source>Inline Diagnostics (experimental)</source>
-        <target state="new">Inline Diagnostics (experimental)</target>
+        <target state="translated">Diagnostyka w tekście (eksperymentalna)</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -534,7 +534,7 @@
       </trans-unit>
       <trans-unit id="Invalid_type_name">
         <source>Invalid type name</source>
-        <target state="new">Invalid type name</target>
+        <target state="translated">Nieprawidłowa nazwa typu</target>
         <note />
       </trans-unit>
       <trans-unit id="Item_origin">
@@ -609,7 +609,7 @@
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type_colon">
         <source>Move Static Members to Another Type:</source>
-        <target state="new">Move Static Members to Another Type:</target>
+        <target state="translated">Przenieś składowe statyczne do innego typu:</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -809,7 +809,7 @@
       </trans-unit>
       <trans-unit id="Navigate_to_external_sources">
         <source>Navigate to External Sources</source>
-        <target state="new">Navigate to External Sources</target>
+        <target state="translated">Przejdź do źródeł zewnętrznych</target>
         <note />
       </trans-unit>
       <trans-unit id="Never">
@@ -959,12 +959,12 @@
       </trans-unit>
       <trans-unit id="Paste">
         <source>Paste</source>
-        <target state="new">Paste</target>
+        <target state="translated">Wklej</target>
         <note />
       </trans-unit>
       <trans-unit id="Paste_valid_stack_trace">
         <source>Paste a valid stack trace to view and navigate it's values</source>
-        <target state="new">Paste a valid stack trace to view and navigate it's values</target>
+        <target state="translated">Wklej prawidłowy ślad stosu, aby wyświetlić jego wartościach i nawigować po nich</target>
         <note>"Stack Trace" is a language term and should be kept the same. </note>
       </trans-unit>
       <trans-unit id="Paused_0_tasks_in_queue">
@@ -1029,7 +1029,7 @@
       </trans-unit>
       <trans-unit id="Prefer_tuple_swap">
         <source>Prefer tuple swap</source>
-        <target state="new">Prefer tuple swap</target>
+        <target state="translated">Preferuj zamianę krotki</target>
         <note />
       </trans-unit>
       <trans-unit id="Projects">
@@ -1074,7 +1074,7 @@
       </trans-unit>
       <trans-unit id="Remove_unnecessary_usings">
         <source>Remove unnecessary usings</source>
-        <target state="new">Remove unnecessary usings</target>
+        <target state="translated">Usuń niepotrzebne użycia</target>
         <note />
       </trans-unit>
       <trans-unit id="Rename_0_to_1">
@@ -1254,17 +1254,17 @@
       </trans-unit>
       <trans-unit id="Sort_usings">
         <source>Sort usings</source>
-        <target state="new">Sort usings</target>
+        <target state="translated">Sortuj użycia</target>
         <note />
       </trans-unit>
       <trans-unit id="Stack_Trace_Explorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Eksplorator śladu stosu</target>
         <note>"Stack Trace" is a language term and should be kept the same. This is for viewing/exploring stack traces</note>
       </trans-unit>
       <trans-unit id="Stack_trace_0">
         <source>Stack Trace {0}</source>
-        <target state="new">Stack Trace {0}</target>
+        <target state="translated">Ślad stosu {0}</target>
         <note>Header for numbered stack trace view tabs</note>
       </trans-unit>
       <trans-unit id="Suggestion">
@@ -1274,7 +1274,7 @@
       </trans-unit>
       <trans-unit id="Suppress_hints_when_argument_matches_parameter_name">
         <source>Suppress hints when argument matches parameter name</source>
-        <target state="new">Suppress hints when argument matches parameter name</target>
+        <target state="translated">Pomiń wskazówki, gdy argument pasuje do nazwy parametru</target>
         <note />
       </trans-unit>
       <trans-unit id="Suppress_hints_when_parameter_name_matches_the_method_s_intent">
@@ -1619,7 +1619,7 @@
       </trans-unit>
       <trans-unit id="at_the_end_of_the_line_of_code">
         <source>at the end of the line of code</source>
-        <target state="new">at the end of the line of code</target>
+        <target state="translated">na końcu wiersza kodu</target>
         <note />
       </trans-unit>
       <trans-unit id="generated_by_0_suffix">
@@ -2645,7 +2645,7 @@ Dodatkowe informacje: {1}</target>
       </trans-unit>
       <trans-unit id="on_the_right_edge_of_the_editor_window">
         <source>on the right edge of the editor window</source>
-        <target state="new">on the right edge of the editor window</target>
+        <target state="translated">na prawej krawędzi okna edytora</target>
         <note />
       </trans-unit>
       <trans-unit id="with_other_members_of_the_same_kind">
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
index dd99807fd6fff..f52ec924844f0 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
         <source>Automatically open Stack Trace Explorer on focus</source>
-        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <target state="translated">Abra automaticamente o Stack Trace Explorer em foco</target>
         <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
       </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
@@ -204,12 +204,12 @@
       </trans-unit>
       <trans-unit id="Clear">
         <source>Clear</source>
-        <target state="new">Clear</target>
+        <target state="translated">Limpar</target>
         <note>Clear content action</note>
       </trans-unit>
       <trans-unit id="Close_tab">
         <source>Close Tab</source>
-        <target state="new">Close Tab</target>
+        <target state="translated">Fechar Guia</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Style">
@@ -314,7 +314,7 @@
       </trans-unit>
       <trans-unit id="Display_diagnostics_inline_experimental">
         <source>Display diagnostics inline (experimental)</source>
-        <target state="new">Display diagnostics inline (experimental)</target>
+        <target state="translated">Exibir diagnósticos em linha (experimental)</target>
         <note />
       </trans-unit>
       <trans-unit id="Display_inline_parameter_name_hints">
@@ -504,7 +504,7 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_experimental">
         <source>Inline Diagnostics (experimental)</source>
-        <target state="new">Inline Diagnostics (experimental)</target>
+        <target state="translated">Diagnóstico em linha (experimental)</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -534,7 +534,7 @@
       </trans-unit>
       <trans-unit id="Invalid_type_name">
         <source>Invalid type name</source>
-        <target state="new">Invalid type name</target>
+        <target state="translated">Nome de tipo inválido</target>
         <note />
       </trans-unit>
       <trans-unit id="Item_origin">
@@ -609,7 +609,7 @@
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type_colon">
         <source>Move Static Members to Another Type:</source>
-        <target state="new">Move Static Members to Another Type:</target>
+        <target state="translated">Mover Membros Estáticos para Outro Tipo:</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -809,7 +809,7 @@
       </trans-unit>
       <trans-unit id="Navigate_to_external_sources">
         <source>Navigate to External Sources</source>
-        <target state="new">Navigate to External Sources</target>
+        <target state="translated">Navegar para fontes externas</target>
         <note />
       </trans-unit>
       <trans-unit id="Never">
@@ -959,12 +959,12 @@
       </trans-unit>
       <trans-unit id="Paste">
         <source>Paste</source>
-        <target state="new">Paste</target>
+        <target state="translated">Colar</target>
         <note />
       </trans-unit>
       <trans-unit id="Paste_valid_stack_trace">
         <source>Paste a valid stack trace to view and navigate it's values</source>
-        <target state="new">Paste a valid stack trace to view and navigate it's values</target>
+        <target state="translated">Cole um rastreamento de pilha válido para exibir e navegar pelos valores</target>
         <note>"Stack Trace" is a language term and should be kept the same. </note>
       </trans-unit>
       <trans-unit id="Paused_0_tasks_in_queue">
@@ -1029,7 +1029,7 @@
       </trans-unit>
       <trans-unit id="Prefer_tuple_swap">
         <source>Prefer tuple swap</source>
-        <target state="new">Prefer tuple swap</target>
+        <target state="translated">Prefiro troca de tupla</target>
         <note />
       </trans-unit>
       <trans-unit id="Projects">
@@ -1074,7 +1074,7 @@
       </trans-unit>
       <trans-unit id="Remove_unnecessary_usings">
         <source>Remove unnecessary usings</source>
-        <target state="new">Remove unnecessary usings</target>
+        <target state="translated">Remover Usos Desnecessários</target>
         <note />
       </trans-unit>
       <trans-unit id="Rename_0_to_1">
@@ -1254,17 +1254,17 @@
       </trans-unit>
       <trans-unit id="Sort_usings">
         <source>Sort usings</source>
-        <target state="new">Sort usings</target>
+        <target state="translated">Classificar usos</target>
         <note />
       </trans-unit>
       <trans-unit id="Stack_Trace_Explorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Explorador de Rastreamento de Pilha</target>
         <note>"Stack Trace" is a language term and should be kept the same. This is for viewing/exploring stack traces</note>
       </trans-unit>
       <trans-unit id="Stack_trace_0">
         <source>Stack Trace {0}</source>
-        <target state="new">Stack Trace {0}</target>
+        <target state="translated">Rastreamento de Pilha{0}</target>
         <note>Header for numbered stack trace view tabs</note>
       </trans-unit>
       <trans-unit id="Suggestion">
@@ -1274,7 +1274,7 @@
       </trans-unit>
       <trans-unit id="Suppress_hints_when_argument_matches_parameter_name">
         <source>Suppress hints when argument matches parameter name</source>
-        <target state="new">Suppress hints when argument matches parameter name</target>
+        <target state="translated">Suprimir as dicas quando o argumento corresponder ao nome do parâmetro</target>
         <note />
       </trans-unit>
       <trans-unit id="Suppress_hints_when_parameter_name_matches_the_method_s_intent">
@@ -1619,7 +1619,7 @@
       </trans-unit>
       <trans-unit id="at_the_end_of_the_line_of_code">
         <source>at the end of the line of code</source>
-        <target state="new">at the end of the line of code</target>
+        <target state="translated">no final da linha de código</target>
         <note />
       </trans-unit>
       <trans-unit id="generated_by_0_suffix">
@@ -2645,7 +2645,7 @@ Informações adicionais: {1}</target>
       </trans-unit>
       <trans-unit id="on_the_right_edge_of_the_editor_window">
         <source>on the right edge of the editor window</source>
-        <target state="new">on the right edge of the editor window</target>
+        <target state="translated">na borda direita da janela do editor</target>
         <note />
       </trans-unit>
       <trans-unit id="with_other_members_of_the_same_kind">
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
index 7c068c8957bc7..91a2006438203 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
         <source>Automatically open Stack Trace Explorer on focus</source>
-        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <target state="translated">Автоматически открывать обозреватель трассировки стека при фокусировке</target>
         <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
       </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
@@ -204,12 +204,12 @@
       </trans-unit>
       <trans-unit id="Clear">
         <source>Clear</source>
-        <target state="new">Clear</target>
+        <target state="translated">Очистить</target>
         <note>Clear content action</note>
       </trans-unit>
       <trans-unit id="Close_tab">
         <source>Close Tab</source>
-        <target state="new">Close Tab</target>
+        <target state="translated">Закрыть вкладку</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Style">
@@ -314,7 +314,7 @@
       </trans-unit>
       <trans-unit id="Display_diagnostics_inline_experimental">
         <source>Display diagnostics inline (experimental)</source>
-        <target state="new">Display diagnostics inline (experimental)</target>
+        <target state="translated">Отображать встроенную диагностику (экспериментальная функция)</target>
         <note />
       </trans-unit>
       <trans-unit id="Display_inline_parameter_name_hints">
@@ -504,7 +504,7 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_experimental">
         <source>Inline Diagnostics (experimental)</source>
-        <target state="new">Inline Diagnostics (experimental)</target>
+        <target state="translated">Встроенная диагностика (экспериментальная функция)</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -534,7 +534,7 @@
       </trans-unit>
       <trans-unit id="Invalid_type_name">
         <source>Invalid type name</source>
-        <target state="new">Invalid type name</target>
+        <target state="translated">Недопустимое имя типа</target>
         <note />
       </trans-unit>
       <trans-unit id="Item_origin">
@@ -609,7 +609,7 @@
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type_colon">
         <source>Move Static Members to Another Type:</source>
-        <target state="new">Move Static Members to Another Type:</target>
+        <target state="translated">Переместить статические элементы в другой тип:</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -809,7 +809,7 @@
       </trans-unit>
       <trans-unit id="Navigate_to_external_sources">
         <source>Navigate to External Sources</source>
-        <target state="new">Navigate to External Sources</target>
+        <target state="translated">Перейти ко внешним источникам</target>
         <note />
       </trans-unit>
       <trans-unit id="Never">
@@ -959,12 +959,12 @@
       </trans-unit>
       <trans-unit id="Paste">
         <source>Paste</source>
-        <target state="new">Paste</target>
+        <target state="translated">Вставить</target>
         <note />
       </trans-unit>
       <trans-unit id="Paste_valid_stack_trace">
         <source>Paste a valid stack trace to view and navigate it's values</source>
-        <target state="new">Paste a valid stack trace to view and navigate it's values</target>
+        <target state="translated">Вставьте допустимую трассировку стека для просмотра ее значений и перехода к ним</target>
         <note>"Stack Trace" is a language term and should be kept the same. </note>
       </trans-unit>
       <trans-unit id="Paused_0_tasks_in_queue">
@@ -1029,7 +1029,7 @@
       </trans-unit>
       <trans-unit id="Prefer_tuple_swap">
         <source>Prefer tuple swap</source>
-        <target state="new">Prefer tuple swap</target>
+        <target state="translated">Предпочитать переключение кортежей</target>
         <note />
       </trans-unit>
       <trans-unit id="Projects">
@@ -1074,7 +1074,7 @@
       </trans-unit>
       <trans-unit id="Remove_unnecessary_usings">
         <source>Remove unnecessary usings</source>
-        <target state="new">Remove unnecessary usings</target>
+        <target state="translated">Удалить ненужные директивы using</target>
         <note />
       </trans-unit>
       <trans-unit id="Rename_0_to_1">
@@ -1254,17 +1254,17 @@
       </trans-unit>
       <trans-unit id="Sort_usings">
         <source>Sort usings</source>
-        <target state="new">Sort usings</target>
+        <target state="translated">Сортировать директивы using</target>
         <note />
       </trans-unit>
       <trans-unit id="Stack_Trace_Explorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Обозреватель трассировки стека</target>
         <note>"Stack Trace" is a language term and should be kept the same. This is for viewing/exploring stack traces</note>
       </trans-unit>
       <trans-unit id="Stack_trace_0">
         <source>Stack Trace {0}</source>
-        <target state="new">Stack Trace {0}</target>
+        <target state="translated">Трассировка стека {0}</target>
         <note>Header for numbered stack trace view tabs</note>
       </trans-unit>
       <trans-unit id="Suggestion">
@@ -1274,7 +1274,7 @@
       </trans-unit>
       <trans-unit id="Suppress_hints_when_argument_matches_parameter_name">
         <source>Suppress hints when argument matches parameter name</source>
-        <target state="new">Suppress hints when argument matches parameter name</target>
+        <target state="translated">Скрывать подсказки, когда аргумент соответствует имени параметра</target>
         <note />
       </trans-unit>
       <trans-unit id="Suppress_hints_when_parameter_name_matches_the_method_s_intent">
@@ -1619,7 +1619,7 @@
       </trans-unit>
       <trans-unit id="at_the_end_of_the_line_of_code">
         <source>at the end of the line of code</source>
-        <target state="new">at the end of the line of code</target>
+        <target state="translated">в конце строки кода</target>
         <note />
       </trans-unit>
       <trans-unit id="generated_by_0_suffix">
@@ -2645,7 +2645,7 @@ Additional information: {1}</source>
       </trans-unit>
       <trans-unit id="on_the_right_edge_of_the_editor_window">
         <source>on the right edge of the editor window</source>
-        <target state="new">on the right edge of the editor window</target>
+        <target state="translated">на правом краю окна редактора</target>
         <note />
       </trans-unit>
       <trans-unit id="with_other_members_of_the_same_kind">
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
index 7882300342bf9..6830da5ab9ac3 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
         <source>Automatically open Stack Trace Explorer on focus</source>
-        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <target state="translated">Odaklanmada Yığın İzleme Gezgini'ni otomatik olarak aç</target>
         <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
       </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
@@ -204,12 +204,12 @@
       </trans-unit>
       <trans-unit id="Clear">
         <source>Clear</source>
-        <target state="new">Clear</target>
+        <target state="translated">Temizle</target>
         <note>Clear content action</note>
       </trans-unit>
       <trans-unit id="Close_tab">
         <source>Close Tab</source>
-        <target state="new">Close Tab</target>
+        <target state="translated">Sekmeyi Kapat</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Style">
@@ -314,7 +314,7 @@
       </trans-unit>
       <trans-unit id="Display_diagnostics_inline_experimental">
         <source>Display diagnostics inline (experimental)</source>
-        <target state="new">Display diagnostics inline (experimental)</target>
+        <target state="translated">Tanılamayı satır içi görüntüle (deneysel)</target>
         <note />
       </trans-unit>
       <trans-unit id="Display_inline_parameter_name_hints">
@@ -504,7 +504,7 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_experimental">
         <source>Inline Diagnostics (experimental)</source>
-        <target state="new">Inline Diagnostics (experimental)</target>
+        <target state="translated">Satır İçi Tanılama (deneysel)</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -534,7 +534,7 @@
       </trans-unit>
       <trans-unit id="Invalid_type_name">
         <source>Invalid type name</source>
-        <target state="new">Invalid type name</target>
+        <target state="translated">Geçersiz tür adı</target>
         <note />
       </trans-unit>
       <trans-unit id="Item_origin">
@@ -609,7 +609,7 @@
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type_colon">
         <source>Move Static Members to Another Type:</source>
-        <target state="new">Move Static Members to Another Type:</target>
+        <target state="translated">Statik Üyeleri Başka Bir Türe Taşı:</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -809,7 +809,7 @@
       </trans-unit>
       <trans-unit id="Navigate_to_external_sources">
         <source>Navigate to External Sources</source>
-        <target state="new">Navigate to External Sources</target>
+        <target state="translated">Dış Kaynaklara Git</target>
         <note />
       </trans-unit>
       <trans-unit id="Never">
@@ -959,12 +959,12 @@
       </trans-unit>
       <trans-unit id="Paste">
         <source>Paste</source>
-        <target state="new">Paste</target>
+        <target state="translated">Yapıştır</target>
         <note />
       </trans-unit>
       <trans-unit id="Paste_valid_stack_trace">
         <source>Paste a valid stack trace to view and navigate it's values</source>
-        <target state="new">Paste a valid stack trace to view and navigate it's values</target>
+        <target state="translated">Değerlerini görüntülemek ve gezinmek için geçerli bir yığın izlemesi yapıştırın</target>
         <note>"Stack Trace" is a language term and should be kept the same. </note>
       </trans-unit>
       <trans-unit id="Paused_0_tasks_in_queue">
@@ -1029,7 +1029,7 @@
       </trans-unit>
       <trans-unit id="Prefer_tuple_swap">
         <source>Prefer tuple swap</source>
-        <target state="new">Prefer tuple swap</target>
+        <target state="translated">Demet değiştirmeyi tercih et</target>
         <note />
       </trans-unit>
       <trans-unit id="Projects">
@@ -1074,7 +1074,7 @@
       </trans-unit>
       <trans-unit id="Remove_unnecessary_usings">
         <source>Remove unnecessary usings</source>
-        <target state="new">Remove unnecessary usings</target>
+        <target state="translated">Gereksiz Kullanımları Kaldır</target>
         <note />
       </trans-unit>
       <trans-unit id="Rename_0_to_1">
@@ -1254,17 +1254,17 @@
       </trans-unit>
       <trans-unit id="Sort_usings">
         <source>Sort usings</source>
-        <target state="new">Sort usings</target>
+        <target state="translated">Using’leri sırala</target>
         <note />
       </trans-unit>
       <trans-unit id="Stack_Trace_Explorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Yığın İzlemesi Gezgini</target>
         <note>"Stack Trace" is a language term and should be kept the same. This is for viewing/exploring stack traces</note>
       </trans-unit>
       <trans-unit id="Stack_trace_0">
         <source>Stack Trace {0}</source>
-        <target state="new">Stack Trace {0}</target>
+        <target state="translated">Yığın İzleme {0}</target>
         <note>Header for numbered stack trace view tabs</note>
       </trans-unit>
       <trans-unit id="Suggestion">
@@ -1274,7 +1274,7 @@
       </trans-unit>
       <trans-unit id="Suppress_hints_when_argument_matches_parameter_name">
         <source>Suppress hints when argument matches parameter name</source>
-        <target state="new">Suppress hints when argument matches parameter name</target>
+        <target state="translated">Bağımsız değişken parametre adıyla eşleştiğinde ipuçlarını bastır</target>
         <note />
       </trans-unit>
       <trans-unit id="Suppress_hints_when_parameter_name_matches_the_method_s_intent">
@@ -1619,7 +1619,7 @@
       </trans-unit>
       <trans-unit id="at_the_end_of_the_line_of_code">
         <source>at the end of the line of code</source>
-        <target state="new">at the end of the line of code</target>
+        <target state="translated">kod satırı sonunda</target>
         <note />
       </trans-unit>
       <trans-unit id="generated_by_0_suffix">
@@ -2645,7 +2645,7 @@ Ek bilgiler: {1}</target>
       </trans-unit>
       <trans-unit id="on_the_right_edge_of_the_editor_window">
         <source>on the right edge of the editor window</source>
-        <target state="new">on the right edge of the editor window</target>
+        <target state="translated">düzenleyici penceresinin sağ kenarına</target>
         <note />
       </trans-unit>
       <trans-unit id="with_other_members_of_the_same_kind">
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
index 0951bb542085b..34c3d97eda05d 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
         <source>Automatically open Stack Trace Explorer on focus</source>
-        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <target state="translated">在焦点上自动打开“堆栈跟踪资源管理器”</target>
         <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
       </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
@@ -204,12 +204,12 @@
       </trans-unit>
       <trans-unit id="Clear">
         <source>Clear</source>
-        <target state="new">Clear</target>
+        <target state="translated">清除</target>
         <note>Clear content action</note>
       </trans-unit>
       <trans-unit id="Close_tab">
         <source>Close Tab</source>
-        <target state="new">Close Tab</target>
+        <target state="translated">关闭选项卡</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Style">
@@ -314,7 +314,7 @@
       </trans-unit>
       <trans-unit id="Display_diagnostics_inline_experimental">
         <source>Display diagnostics inline (experimental)</source>
-        <target state="new">Display diagnostics inline (experimental)</target>
+        <target state="translated">内联显示诊断(实验性)</target>
         <note />
       </trans-unit>
       <trans-unit id="Display_inline_parameter_name_hints">
@@ -504,7 +504,7 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_experimental">
         <source>Inline Diagnostics (experimental)</source>
-        <target state="new">Inline Diagnostics (experimental)</target>
+        <target state="translated">内联诊断(实验性)</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -534,7 +534,7 @@
       </trans-unit>
       <trans-unit id="Invalid_type_name">
         <source>Invalid type name</source>
-        <target state="new">Invalid type name</target>
+        <target state="translated">类型名无效</target>
         <note />
       </trans-unit>
       <trans-unit id="Item_origin">
@@ -609,7 +609,7 @@
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type_colon">
         <source>Move Static Members to Another Type:</source>
-        <target state="new">Move Static Members to Another Type:</target>
+        <target state="translated">将静态成员移动到另一类型:</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -809,7 +809,7 @@
       </trans-unit>
       <trans-unit id="Navigate_to_external_sources">
         <source>Navigate to External Sources</source>
-        <target state="new">Navigate to External Sources</target>
+        <target state="translated">导航到外部源</target>
         <note />
       </trans-unit>
       <trans-unit id="Never">
@@ -959,12 +959,12 @@
       </trans-unit>
       <trans-unit id="Paste">
         <source>Paste</source>
-        <target state="new">Paste</target>
+        <target state="translated">粘贴</target>
         <note />
       </trans-unit>
       <trans-unit id="Paste_valid_stack_trace">
         <source>Paste a valid stack trace to view and navigate it's values</source>
-        <target state="new">Paste a valid stack trace to view and navigate it's values</target>
+        <target state="translated">粘贴有效的堆栈跟踪以查看和导航其值</target>
         <note>"Stack Trace" is a language term and should be kept the same. </note>
       </trans-unit>
       <trans-unit id="Paused_0_tasks_in_queue">
@@ -1029,7 +1029,7 @@
       </trans-unit>
       <trans-unit id="Prefer_tuple_swap">
         <source>Prefer tuple swap</source>
-        <target state="new">Prefer tuple swap</target>
+        <target state="translated">首选元组交换</target>
         <note />
       </trans-unit>
       <trans-unit id="Projects">
@@ -1074,7 +1074,7 @@
       </trans-unit>
       <trans-unit id="Remove_unnecessary_usings">
         <source>Remove unnecessary usings</source>
-        <target state="new">Remove unnecessary usings</target>
+        <target state="translated">删除不必要的 Using</target>
         <note />
       </trans-unit>
       <trans-unit id="Rename_0_to_1">
@@ -1254,17 +1254,17 @@
       </trans-unit>
       <trans-unit id="Sort_usings">
         <source>Sort usings</source>
-        <target state="new">Sort usings</target>
+        <target state="translated">对 using 排序</target>
         <note />
       </trans-unit>
       <trans-unit id="Stack_Trace_Explorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">堆栈跟踪资源管理器</target>
         <note>"Stack Trace" is a language term and should be kept the same. This is for viewing/exploring stack traces</note>
       </trans-unit>
       <trans-unit id="Stack_trace_0">
         <source>Stack Trace {0}</source>
-        <target state="new">Stack Trace {0}</target>
+        <target state="translated">堆栈跟踪: {0}</target>
         <note>Header for numbered stack trace view tabs</note>
       </trans-unit>
       <trans-unit id="Suggestion">
@@ -1274,7 +1274,7 @@
       </trans-unit>
       <trans-unit id="Suppress_hints_when_argument_matches_parameter_name">
         <source>Suppress hints when argument matches parameter name</source>
-        <target state="new">Suppress hints when argument matches parameter name</target>
+        <target state="translated">当参数与参数名称匹配时抑制提示</target>
         <note />
       </trans-unit>
       <trans-unit id="Suppress_hints_when_parameter_name_matches_the_method_s_intent">
@@ -1619,7 +1619,7 @@
       </trans-unit>
       <trans-unit id="at_the_end_of_the_line_of_code">
         <source>at the end of the line of code</source>
-        <target state="new">at the end of the line of code</target>
+        <target state="translated">在代码行的末尾</target>
         <note />
       </trans-unit>
       <trans-unit id="generated_by_0_suffix">
@@ -2645,7 +2645,7 @@ Additional information: {1}</source>
       </trans-unit>
       <trans-unit id="on_the_right_edge_of_the_editor_window">
         <source>on the right edge of the editor window</source>
-        <target state="new">on the right edge of the editor window</target>
+        <target state="translated">在编辑器窗口的右边缘</target>
         <note />
       </trans-unit>
       <trans-unit id="with_other_members_of_the_same_kind">
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
index a595d1d5b8f43..5f3d5d4b33555 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
@@ -109,7 +109,7 @@
       </trans-unit>
       <trans-unit id="Automatically_open_stack_trace_explorer_on_focus">
         <source>Automatically open Stack Trace Explorer on focus</source>
-        <target state="new">Automatically open Stack Trace Explorer on focus</target>
+        <target state="translated">在焦點時會自動開啟堆疊追蹤總管</target>
         <note>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</note>
       </trans-unit>
       <trans-unit id="Avoid_expression_statements_that_implicitly_ignore_value">
@@ -204,12 +204,12 @@
       </trans-unit>
       <trans-unit id="Clear">
         <source>Clear</source>
-        <target state="new">Clear</target>
+        <target state="translated">清除</target>
         <note>Clear content action</note>
       </trans-unit>
       <trans-unit id="Close_tab">
         <source>Close Tab</source>
-        <target state="new">Close Tab</target>
+        <target state="translated">[關閉] 索引標籤</target>
         <note />
       </trans-unit>
       <trans-unit id="Code_Style">
@@ -314,7 +314,7 @@
       </trans-unit>
       <trans-unit id="Display_diagnostics_inline_experimental">
         <source>Display diagnostics inline (experimental)</source>
-        <target state="new">Display diagnostics inline (experimental)</target>
+        <target state="translated">顯示內嵌診斷 (實驗性)</target>
         <note />
       </trans-unit>
       <trans-unit id="Display_inline_parameter_name_hints">
@@ -504,7 +504,7 @@
       </trans-unit>
       <trans-unit id="Inline_Diagnostics_experimental">
         <source>Inline Diagnostics (experimental)</source>
-        <target state="new">Inline Diagnostics (experimental)</target>
+        <target state="translated">內嵌診斷 (實驗性)</target>
         <note />
       </trans-unit>
       <trans-unit id="Inline_Hints">
@@ -534,7 +534,7 @@
       </trans-unit>
       <trans-unit id="Invalid_type_name">
         <source>Invalid type name</source>
-        <target state="new">Invalid type name</target>
+        <target state="translated">無效的類別名稱</target>
         <note />
       </trans-unit>
       <trans-unit id="Item_origin">
@@ -609,7 +609,7 @@
       </trans-unit>
       <trans-unit id="Move_static_members_to_another_type_colon">
         <source>Move Static Members to Another Type:</source>
-        <target state="new">Move Static Members to Another Type:</target>
+        <target state="translated">將靜態成員移至其他類型:</target>
         <note />
       </trans-unit>
       <trans-unit id="Move_to_namespace">
@@ -809,7 +809,7 @@
       </trans-unit>
       <trans-unit id="Navigate_to_external_sources">
         <source>Navigate to External Sources</source>
-        <target state="new">Navigate to External Sources</target>
+        <target state="translated">瀏覽至外部來源</target>
         <note />
       </trans-unit>
       <trans-unit id="Never">
@@ -959,12 +959,12 @@
       </trans-unit>
       <trans-unit id="Paste">
         <source>Paste</source>
-        <target state="new">Paste</target>
+        <target state="translated">貼上</target>
         <note />
       </trans-unit>
       <trans-unit id="Paste_valid_stack_trace">
         <source>Paste a valid stack trace to view and navigate it's values</source>
-        <target state="new">Paste a valid stack trace to view and navigate it's values</target>
+        <target state="translated">貼上有效的堆疊追蹤以檢視及瀏覽其值</target>
         <note>"Stack Trace" is a language term and should be kept the same. </note>
       </trans-unit>
       <trans-unit id="Paused_0_tasks_in_queue">
@@ -1029,7 +1029,7 @@
       </trans-unit>
       <trans-unit id="Prefer_tuple_swap">
         <source>Prefer tuple swap</source>
-        <target state="new">Prefer tuple swap</target>
+        <target state="translated">偏好元組交換</target>
         <note />
       </trans-unit>
       <trans-unit id="Projects">
@@ -1074,7 +1074,7 @@
       </trans-unit>
       <trans-unit id="Remove_unnecessary_usings">
         <source>Remove unnecessary usings</source>
-        <target state="new">Remove unnecessary usings</target>
+        <target state="translated">移除不必要的 Using</target>
         <note />
       </trans-unit>
       <trans-unit id="Rename_0_to_1">
@@ -1254,17 +1254,17 @@
       </trans-unit>
       <trans-unit id="Sort_usings">
         <source>Sort usings</source>
-        <target state="new">Sort usings</target>
+        <target state="translated">排序 Using</target>
         <note />
       </trans-unit>
       <trans-unit id="Stack_Trace_Explorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">堆疊追蹤總管</target>
         <note>"Stack Trace" is a language term and should be kept the same. This is for viewing/exploring stack traces</note>
       </trans-unit>
       <trans-unit id="Stack_trace_0">
         <source>Stack Trace {0}</source>
-        <target state="new">Stack Trace {0}</target>
+        <target state="translated">堆疊追蹤 {0}</target>
         <note>Header for numbered stack trace view tabs</note>
       </trans-unit>
       <trans-unit id="Suggestion">
@@ -1274,7 +1274,7 @@
       </trans-unit>
       <trans-unit id="Suppress_hints_when_argument_matches_parameter_name">
         <source>Suppress hints when argument matches parameter name</source>
-        <target state="new">Suppress hints when argument matches parameter name</target>
+        <target state="translated">當引數符合參數名稱時抑制提示</target>
         <note />
       </trans-unit>
       <trans-unit id="Suppress_hints_when_parameter_name_matches_the_method_s_intent">
@@ -1619,7 +1619,7 @@
       </trans-unit>
       <trans-unit id="at_the_end_of_the_line_of_code">
         <source>at the end of the line of code</source>
-        <target state="new">at the end of the line of code</target>
+        <target state="translated">在程式碼結尾</target>
         <note />
       </trans-unit>
       <trans-unit id="generated_by_0_suffix">
@@ -2645,7 +2645,7 @@ Additional information: {1}</source>
       </trans-unit>
       <trans-unit id="on_the_right_edge_of_the_editor_window">
         <source>on the right edge of the editor window</source>
-        <target state="new">on the right edge of the editor window</target>
+        <target state="translated">在編輯器視窗的右邊緣</target>
         <note />
       </trans-unit>
       <trans-unit id="with_other_members_of_the_same_kind">
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/BasicVSResources.tr.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/BasicVSResources.tr.xlf
index e0e638b07f7d2..4a95a682a33e5 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/BasicVSResources.tr.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/BasicVSResources.tr.xlf
@@ -9,7 +9,7 @@
       </trans-unit>
       <trans-unit id="In_relational_binary_operators">
         <source>In relational operators:  =   &lt;&gt;   &lt;   &gt;   &lt;=   &gt;=   Like   Is</source>
-        <target state="translated">İlişkisel işleçleri içinde: = Transfeleri'nin &lt; &gt; &lt;&gt; = nasıl olduğunu =</target>
+        <target state="translated">İlişkisel işleçleri içinde: = Transfeleri'nin &lt;&gt; &lt;&gt; = nasıl olduğunu =</target>
         <note />
       </trans-unit>
       <trans-unit id="Insert_apostrophe_at_the_start_of_new_lines_when_writing_apostrophe_comments">

From 338ed4efa9ce9017281552860a2518c4346cdff4 Mon Sep 17 00:00:00 2001
From: dotnet bot <dotnet-bot@dotnetfoundation.org>
Date: Fri, 7 Jan 2022 12:13:14 -0800
Subject: [PATCH 279/444] Localized file check-in by OneLocBuild Task: Build
 definition ID 327: Build ID 1541625

---
 .../CSharp/Portable/xlf/CSharpWorkspaceResources.pl.xlf       | 2 +-
 .../Remote/Core/xlf/RemoteWorkspacesResources.cs.xlf          | 4 ++--
 .../Remote/Core/xlf/RemoteWorkspacesResources.de.xlf          | 4 ++--
 .../Remote/Core/xlf/RemoteWorkspacesResources.es.xlf          | 4 ++--
 .../Remote/Core/xlf/RemoteWorkspacesResources.fr.xlf          | 4 ++--
 .../Remote/Core/xlf/RemoteWorkspacesResources.it.xlf          | 4 ++--
 .../Remote/Core/xlf/RemoteWorkspacesResources.ja.xlf          | 4 ++--
 .../Remote/Core/xlf/RemoteWorkspacesResources.ko.xlf          | 4 ++--
 .../Remote/Core/xlf/RemoteWorkspacesResources.pl.xlf          | 4 ++--
 .../Remote/Core/xlf/RemoteWorkspacesResources.pt-BR.xlf       | 4 ++--
 .../Remote/Core/xlf/RemoteWorkspacesResources.ru.xlf          | 4 ++--
 .../Remote/Core/xlf/RemoteWorkspacesResources.tr.xlf          | 4 ++--
 .../Remote/Core/xlf/RemoteWorkspacesResources.zh-Hans.xlf     | 4 ++--
 .../Remote/Core/xlf/RemoteWorkspacesResources.zh-Hant.xlf     | 4 ++--
 14 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/src/Workspaces/CSharp/Portable/xlf/CSharpWorkspaceResources.pl.xlf b/src/Workspaces/CSharp/Portable/xlf/CSharpWorkspaceResources.pl.xlf
index f71b516b0979d..90a9eb3e3e509 100644
--- a/src/Workspaces/CSharp/Portable/xlf/CSharpWorkspaceResources.pl.xlf
+++ b/src/Workspaces/CSharp/Portable/xlf/CSharpWorkspaceResources.pl.xlf
@@ -29,7 +29,7 @@
       </trans-unit>
       <trans-unit id="Remove_and_Sort_Usings">
         <source>R&amp;emove and Sort Usings</source>
-        <target state="translated">&amp;Usuń i sortuj instrukcje using</target>
+        <target state="translated">&amp;Usuń i sortuj instrukcje Usings</target>
         <note />
       </trans-unit>
       <trans-unit id="Sort_Usings">
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.cs.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.cs.xlf
index ac955b2f7261d..f3ced1f55297a 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.cs.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.cs.xlf
@@ -19,7 +19,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_CompilationAvailable">
         <source>Project semantics availability</source>
-        <target state="new">Project semantics availability</target>
+        <target state="translated">Dostupnost sémantiky projektu</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_ConvertTupleToStructCodeRefactoring">
@@ -119,7 +119,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_StackTraceExplorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Průzkumník trasování zásobníku</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.de.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.de.xlf
index 487df947a2b1c..d89a96929b853 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.de.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.de.xlf
@@ -19,7 +19,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_CompilationAvailable">
         <source>Project semantics availability</source>
-        <target state="new">Project semantics availability</target>
+        <target state="translated">Verfügbarkeit der Projektsemantik</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_ConvertTupleToStructCodeRefactoring">
@@ -119,7 +119,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_StackTraceExplorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Stack Trace Explorer</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.es.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.es.xlf
index 7be5777a98d58..b951b8daaa421 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.es.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.es.xlf
@@ -19,7 +19,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_CompilationAvailable">
         <source>Project semantics availability</source>
-        <target state="new">Project semantics availability</target>
+        <target state="translated">Disponibilidad de semántica del proyecto</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_ConvertTupleToStructCodeRefactoring">
@@ -119,7 +119,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_StackTraceExplorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Explorador de seguimiento de pila</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.fr.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.fr.xlf
index 36cfd27dca1cc..fddf7976a13a9 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.fr.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.fr.xlf
@@ -19,7 +19,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_CompilationAvailable">
         <source>Project semantics availability</source>
-        <target state="new">Project semantics availability</target>
+        <target state="translated">Disponibilité de la sémantique du projet</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_ConvertTupleToStructCodeRefactoring">
@@ -119,7 +119,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_StackTraceExplorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Explorateur de traces de pile</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.it.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.it.xlf
index bd450c678f700..38b7df0174a61 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.it.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.it.xlf
@@ -19,7 +19,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_CompilationAvailable">
         <source>Project semantics availability</source>
-        <target state="new">Project semantics availability</target>
+        <target state="translated">Disponibilità semantica del progetto</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_ConvertTupleToStructCodeRefactoring">
@@ -119,7 +119,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_StackTraceExplorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Esplora analisi dello stack</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ja.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ja.xlf
index 9849446cea3ed..0b05a8608e5ed 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ja.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ja.xlf
@@ -19,7 +19,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_CompilationAvailable">
         <source>Project semantics availability</source>
-        <target state="new">Project semantics availability</target>
+        <target state="translated">プロジェクト セマンティクスの可用性</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_ConvertTupleToStructCodeRefactoring">
@@ -119,7 +119,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_StackTraceExplorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">スタック トレース エクスプローラー</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ko.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ko.xlf
index 3fd9514bdf002..b26e1469e8506 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ko.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ko.xlf
@@ -19,7 +19,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_CompilationAvailable">
         <source>Project semantics availability</source>
-        <target state="new">Project semantics availability</target>
+        <target state="translated">프로젝트 의미 체계 가용성</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_ConvertTupleToStructCodeRefactoring">
@@ -119,7 +119,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_StackTraceExplorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">스택 추적 탐색기</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pl.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pl.xlf
index f90d53513925b..3b1cdb66d90ba 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pl.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pl.xlf
@@ -19,7 +19,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_CompilationAvailable">
         <source>Project semantics availability</source>
-        <target state="new">Project semantics availability</target>
+        <target state="translated">Dostępność semantyki projektu</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_ConvertTupleToStructCodeRefactoring">
@@ -119,7 +119,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_StackTraceExplorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Eksplorator śladu stosu</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pt-BR.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pt-BR.xlf
index cc29c449693f8..4a633ad7571a7 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pt-BR.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.pt-BR.xlf
@@ -19,7 +19,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_CompilationAvailable">
         <source>Project semantics availability</source>
-        <target state="new">Project semantics availability</target>
+        <target state="translated">Disponibilidade da semântica do projeto</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_ConvertTupleToStructCodeRefactoring">
@@ -119,7 +119,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_StackTraceExplorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Explorador de Rastreamento de Pilha</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ru.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ru.xlf
index d003842fccfa2..512781ae9f2e7 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ru.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.ru.xlf
@@ -19,7 +19,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_CompilationAvailable">
         <source>Project semantics availability</source>
-        <target state="new">Project semantics availability</target>
+        <target state="translated">Доступность семантики проекта</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_ConvertTupleToStructCodeRefactoring">
@@ -119,7 +119,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_StackTraceExplorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Обозреватель трассировки стека</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.tr.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.tr.xlf
index ba76ab9632328..defa6cf08db4e 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.tr.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.tr.xlf
@@ -19,7 +19,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_CompilationAvailable">
         <source>Project semantics availability</source>
-        <target state="new">Project semantics availability</target>
+        <target state="translated">Proje semantiği kullanılabilirliği</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_ConvertTupleToStructCodeRefactoring">
@@ -119,7 +119,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_StackTraceExplorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">Yığın İzlemesi Gezgini</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hans.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hans.xlf
index 048d4167d327d..4180036855ba7 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hans.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hans.xlf
@@ -19,7 +19,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_CompilationAvailable">
         <source>Project semantics availability</source>
-        <target state="new">Project semantics availability</target>
+        <target state="translated">项目语义可用性</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_ConvertTupleToStructCodeRefactoring">
@@ -119,7 +119,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_StackTraceExplorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">堆栈跟踪资源管理器</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">
diff --git a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hant.xlf b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hant.xlf
index 8c4a36ea93c31..e77280eccd427 100644
--- a/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hant.xlf
+++ b/src/Workspaces/Remote/Core/xlf/RemoteWorkspacesResources.zh-Hant.xlf
@@ -19,7 +19,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_CompilationAvailable">
         <source>Project semantics availability</source>
-        <target state="new">Project semantics availability</target>
+        <target state="translated">專案語意學可用性</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_ConvertTupleToStructCodeRefactoring">
@@ -119,7 +119,7 @@
       </trans-unit>
       <trans-unit id="FeatureName_StackTraceExplorer">
         <source>Stack Trace Explorer</source>
-        <target state="new">Stack Trace Explorer</target>
+        <target state="translated">堆疊追蹤總管</target>
         <note />
       </trans-unit>
       <trans-unit id="FeatureName_SymbolFinder">

From 1f66342656f5f246ea9446cb3e7e970a81e3e439 Mon Sep 17 00:00:00 2001
From: Jason Malinowski <jason.malinowski@microsoft.com>
Date: Thu, 6 Jan 2022 18:11:56 -0800
Subject: [PATCH 280/444] Deduplicate references in
 CommandLineProject.CreateProjectInfo

This was causing source indexers that use this API to make projects
to break when they ironically tried to index Roslyn itself.
---
 .../Portable/Workspace/CommandLineProject.cs  | 19 +++++++++++++--
 .../CommandLineProjectTests.cs                | 24 +++++++++++++++++++
 2 files changed, 41 insertions(+), 2 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/CommandLineProject.cs b/src/Workspaces/Core/Portable/Workspace/CommandLineProject.cs
index 5df997ea3f272..fb07382eded07 100644
--- a/src/Workspaces/Core/Portable/Workspace/CommandLineProject.cs
+++ b/src/Workspaces/Core/Portable/Workspace/CommandLineProject.cs
@@ -49,8 +49,23 @@ public static ProjectInfo CreateProjectInfo(string projectName, string language,
             var xmlFileResolver = new XmlFileResolver(commandLineArguments.BaseDirectory);
             var strongNameProvider = new DesktopStrongNameProvider(commandLineArguments.KeyFileSearchPaths);
 
-            // resolve all metadata references.
-            var boundMetadataReferences = commandLineArguments.ResolveMetadataReferences(commandLineMetadataReferenceResolver);
+            // Resolve all metadata references.
+            //
+            // In the command line compiler, it's entirely possible that duplicate reference paths may appear in this list; in the compiler
+            // each MetadataReference object is a distinct instance, and the deduplication is ultimately performed in the ReferenceManager
+            // once the Compilation actually starts to read metadata. In this code however,  we're resolving with the IMetadataService, which
+            // has a default implementation to cache and return the same MetadataReference instance for a duplicate. This means duplicate
+            // reference path will create duplicate MetadataReference objects, which is disallowed by ProjectInfo.Create -- even though the
+            // compiler eventually would have dealt with it just fine. It's reasonable the Workspace APIs disallow duplicate reference objects
+            // since it makes the semantics of APIs like Add/RemoveMetadataReference tricky. But since we want to not break for command lines
+            // with duplicate references, we'll do a .Distinct() here, and let the Compilation do any further deduplication
+            // that isn't handled by this explicit instance check. This does mean that the Compilations produced through this API
+            // won't produce the "duplicate metadata reference" diagnostic like the real command line compiler would, but that's probably fine.
+            //
+            // Alternately, we could change the IMetadataService behavior to simply not cache, but that could theoretically break other
+            // callers that would now see references across projects not be the same, or hurt performance for users of MSBuildWorkspace. Given
+            // this is an edge case, it's not worth the larger fix here.
+            var boundMetadataReferences = commandLineArguments.ResolveMetadataReferences(commandLineMetadataReferenceResolver).Distinct().ToList();
             var unresolvedMetadataReferences = boundMetadataReferences.FirstOrDefault(r => r is UnresolvedMetadataReference);
             if (unresolvedMetadataReferences != null)
             {
diff --git a/src/Workspaces/CoreTest/CommandLineProject/CommandLineProjectTests.cs b/src/Workspaces/CoreTest/CommandLineProject/CommandLineProjectTests.cs
index 3f3703a4b7777..f3c71e7eeb39d 100644
--- a/src/Workspaces/CoreTest/CommandLineProject/CommandLineProjectTests.cs
+++ b/src/Workspaces/CoreTest/CommandLineProject/CommandLineProjectTests.cs
@@ -143,5 +143,29 @@ public void TestAnalyzerReferences()
             Assert.Equal("goo.cs", firstDoc.Name);
             Assert.Equal(pathToAssembly, analyzerRef.FullPath);
         }
+
+        [Fact]
+        public void TestDuplicateReferenceInVisualBasic()
+        {
+            var pathToAssembly = typeof(object).Assembly.Location;
+            var quotedPathToAssembly = '"' + pathToAssembly + '"';
+            var commandLine = $"goo.vb /r:{quotedPathToAssembly},{quotedPathToAssembly}";
+            var info = CommandLineProject.CreateProjectInfo("TestProject", LanguageNames.VisualBasic, commandLine, baseDirectory: @"C:\ProjectDirectory");
+
+            // The compiler may add other references automatically, so we'll only assert a single reference for the one we're interested in
+            Assert.Single(info.MetadataReferences.OfType<PortableExecutableReference>(), r => r.FilePath == pathToAssembly);
+        }
+
+        [Fact]
+        public void TestDuplicateReferenceInVisualBasicWithVbRuntimeFlag()
+        {
+            var pathToAssembly = typeof(object).Assembly.Location;
+            var quotedPathToAssembly = '"' + pathToAssembly + '"';
+            var commandLine = $"goo.vb /r:{quotedPathToAssembly} /vbruntime:{quotedPathToAssembly}";
+            var info = CommandLineProject.CreateProjectInfo("TestProject", LanguageNames.VisualBasic, commandLine, baseDirectory: @"C:\ProjectDirectory");
+
+            // The compiler may add other references automatically, so we'll only assert a single reference for the one we're interested in
+            Assert.Single(info.MetadataReferences.OfType<PortableExecutableReference>(), r => r.FilePath == pathToAssembly);
+        }
     }
 }

From 1c78d70272609c4ecf17194e65435ef41100804a Mon Sep 17 00:00:00 2001
From: Youssef Victor <youssefvictor00@gmail.com>
Date: Sat, 8 Jan 2022 03:17:28 +0200
Subject: [PATCH 281/444] Don't run CI for docs-only changes (#58723)

---
 azure-pipelines-integration-corehost.yml | 16 +++++++++++-----
 azure-pipelines-integration.yml          | 16 +++++++++++-----
 azure-pipelines.yml                      | 16 +++++++++++-----
 3 files changed, 33 insertions(+), 15 deletions(-)

diff --git a/azure-pipelines-integration-corehost.yml b/azure-pipelines-integration-corehost.yml
index 4b819e3710179..e88585d3f3fa9 100644
--- a/azure-pipelines-integration-corehost.yml
+++ b/azure-pipelines-integration-corehost.yml
@@ -12,11 +12,17 @@ trigger:
 # Automatic building of all PRs is disabled in the pipeline's trigger page.
 # See https://docs.microsoft.com/en-us/azure/devops/pipelines/repos/github?view=azure-devops&tabs=yaml#comment-triggers
 pr:
-- main
-- main-vs-deps
-- release/*
-- features/*
-- demos/*
+  branches:
+    include:
+    - main
+    - main-vs-deps
+    - release/*
+    - features/*
+    - demos/*
+  paths:
+    exclude:
+      - docs/*
+      - .github/*
 
 jobs:
 - job: VS_Integration_CoreHost_Debug
diff --git a/azure-pipelines-integration.yml b/azure-pipelines-integration.yml
index 190afc17d7a32..1c8cae1640e4e 100644
--- a/azure-pipelines-integration.yml
+++ b/azure-pipelines-integration.yml
@@ -8,11 +8,17 @@ trigger:
 
 # Branches that trigger builds on PR
 pr:
-- main
-- main-vs-deps
-- release/*
-- features/*
-- demos/*
+  branches:
+    include:
+    - main
+    - main-vs-deps
+    - release/*
+    - features/*
+    - demos/*
+  paths:
+    exclude:
+      - docs/*
+      - .github/*
 
 jobs:
 - ${{ if ne(variables['Build.Reason'], 'PullRequest') }}:
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index 86e5e62c4fc27..6e0c9a95799d7 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -8,11 +8,17 @@ trigger:
 
 # Branches that trigger builds on PR
 pr:
-- main
-- main-vs-deps
-- release/*
-- features/*
-- demos/*
+  branches:
+    include:
+    - main
+    - main-vs-deps
+    - release/*
+    - features/*
+    - demos/*
+  paths:
+    exclude:
+      - docs/*
+      - .github/*
 
 # Windows Build and Test Jobs
 jobs:

From d53ac95496e8fdc82e3f64cdb0a9c3457ab7fc11 Mon Sep 17 00:00:00 2001
From: AlekseyTs <AlekseyTs@users.noreply.github.com>
Date: Fri, 7 Jan 2022 18:48:05 -0800
Subject: [PATCH 282/444] Remove implicit conversion from string to
 `ReadOnlySpan<T>` from test source for `ReadOnlySpan<T>`. (#58724)

There is no such operator in real type. Instead `string` type declares an implicit conversion to ```ReadOnlySpan<char>```.
---
 .../CodeGenReadOnlySpanConstructionTest.cs    | 22 +++++++++----------
 .../CSharp/Test/Emit/CodeGen/ForeachTest.cs   |  8 +++----
 .../Test/Utilities/CSharp/CSharpTestBase.cs   |  2 --
 3 files changed, 15 insertions(+), 17 deletions(-)

diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenReadOnlySpanConstructionTest.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenReadOnlySpanConstructionTest.cs
index 05847e5d8610d..ccdcc9622d335 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenReadOnlySpanConstructionTest.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenReadOnlySpanConstructionTest.cs
@@ -14,11 +14,11 @@ namespace Microsoft.CodeAnalysis.CSharp.UnitTests.CodeGen
 {
     public class CodeGenReadOnlySpanConstructionTest : CSharpTestBase
     {
-        [Fact]
+        [ConditionalFact(typeof(CoreClrOnly))]
         [WorkItem(23358, "https://github.com/dotnet/roslyn/issues/23358")]
         public void EmptyOrNullStringConv()
         {
-            var comp = CreateCompilationWithMscorlibAndSpan(@"
+            var comp = CreateCompilation(@"
 using System;
 
 class Test
@@ -37,7 +37,7 @@ public static void Main()
     }
 }
 
-", TestOptions.ReleaseExe);
+", targetFramework: TargetFramework.NetCoreApp, options: TestOptions.ReleaseExe);
 
             CompileAndVerify(comp, expectedOutput: "TrueTrue", verify: Verification.Passes).VerifyIL("Test.Main", @"
 {
@@ -46,10 +46,10 @@ .maxstack  2
   .locals init (System.ReadOnlySpan<char> V_0, //s1
                 System.ReadOnlySpan<char> V_1) //s2
   IL_0000:  ldstr      """"
-  IL_0005:  call       ""System.ReadOnlySpan<char> System.ReadOnlySpan<char>.op_Implicit(string)""
+  IL_0005:  call       ""System.ReadOnlySpan<char> string.op_Implicit(string)""
   IL_000a:  stloc.0
   IL_000b:  ldstr      """"
-  IL_0010:  call       ""System.ReadOnlySpan<char> System.ReadOnlySpan<char>.op_Implicit(string)""
+  IL_0010:  call       ""System.ReadOnlySpan<char> string.op_Implicit(string)""
   IL_0015:  stloc.1
   IL_0016:  ldloca.s   V_0
   IL_0018:  call       ""int System.ReadOnlySpan<char>.Length.get""
@@ -58,10 +58,10 @@ .locals init (System.ReadOnlySpan<char> V_0, //s1
   IL_0024:  ceq
   IL_0026:  call       ""void System.Console.Write(bool)""
   IL_002b:  ldnull
-  IL_002c:  call       ""System.ReadOnlySpan<char> System.ReadOnlySpan<char>.op_Implicit(string)""
+  IL_002c:  call       ""System.ReadOnlySpan<char> string.op_Implicit(string)""
   IL_0031:  stloc.0
   IL_0032:  ldnull
-  IL_0033:  call       ""System.ReadOnlySpan<char> System.ReadOnlySpan<char>.op_Implicit(string)""
+  IL_0033:  call       ""System.ReadOnlySpan<char> string.op_Implicit(string)""
   IL_0038:  stloc.1
   IL_0039:  ldloca.s   V_0
   IL_003b:  call       ""int System.ReadOnlySpan<char>.Length.get""
@@ -492,11 +492,11 @@ .locals init (System.ReadOnlySpan<System.Color> V_0, //s1
 }");
         }
 
-        [Fact]
+        [ConditionalFact(typeof(CoreClrOnly))]
         [WorkItem(23358, "https://github.com/dotnet/roslyn/issues/23358")]
         public void ConvInMethodCall()
         {
-            var comp = CreateCompilationWithMscorlibAndSpan(@"
+            var comp = CreateCompilation(@"
 using System;
 
 class Test
@@ -513,14 +513,14 @@ public static void Test1<T, U>(ReadOnlySpan<T> arg1, ReadOnlySpan<U> arg2)
     }
 }
 
-", TestOptions.ReleaseExe);
+", targetFramework: TargetFramework.NetCoreApp, options: TestOptions.ReleaseExe);
 
             CompileAndVerify(comp, expectedOutput: "P10", verify: Verification.Fails).VerifyIL("Test.Main", @"
 {
   // Code size       28 (0x1c)
   .maxstack  3
   IL_0000:  ldstr      ""QWERTYUIOP""
-  IL_0005:  call       ""System.ReadOnlySpan<char> System.ReadOnlySpan<char>.op_Implicit(string)""
+  IL_0005:  call       ""System.ReadOnlySpan<char> string.op_Implicit(string)""
   IL_000a:  ldsflda    ""<PrivateImplementationDetails>.__StaticArrayInitTypeSize=10 <PrivateImplementationDetails>.C848E1013F9F04A9D63FA43CE7FD4AF035152C7C669A4A404B67107CEE5F2E4E""
   IL_000f:  ldc.i4.s   10
   IL_0011:  newobj     ""System.ReadOnlySpan<byte>..ctor(void*, int)""
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/ForeachTest.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/ForeachTest.cs
index de9e115e8e417..47149edb28c27 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/ForeachTest.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/ForeachTest.cs
@@ -477,10 +477,10 @@ .locals init (System.ReadOnlySpan<System.Color> V_0,
 }");
         }
 
-        [Fact]
+        [ConditionalFact(typeof(CoreClrOnly))]
         public void TestReadOnlySpanString()
         {
-            var comp = CreateCompilationWithMscorlibAndSpan(@"
+            var comp = CreateCompilation(@"
 using System;
 
 class Test
@@ -495,7 +495,7 @@ public static void Main()
     }
 }
 
-", TestOptions.ReleaseExe);
+", targetFramework: TargetFramework.NetCoreApp, options: TestOptions.ReleaseExe);
 
             CompileAndVerify(comp, expectedOutput: "hello", verify: Verification.Passes).VerifyIL("Test.Main", @"
 {
@@ -504,7 +504,7 @@ .maxstack  2
   .locals init (System.ReadOnlySpan<char> V_0,
                 int V_1)
   IL_0000:  ldstr      ""hello""
-  IL_0005:  call       ""System.ReadOnlySpan<char> System.ReadOnlySpan<char>.op_Implicit(string)""
+  IL_0005:  call       ""System.ReadOnlySpan<char> string.op_Implicit(string)""
   IL_000a:  stloc.0
   IL_000b:  ldc.i4.0
   IL_000c:  stloc.1
diff --git a/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs b/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs
index 386a40bac7e0a..ef99a145bc866 100644
--- a/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs
+++ b/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs
@@ -2224,8 +2224,6 @@ public ref readonly T Current
             }
 
             public static implicit operator ReadOnlySpan<T>(T[] array) => array == null ? default : new ReadOnlySpan<T>(array);
-
-            public static implicit operator ReadOnlySpan<T>(string stringValue) => string.IsNullOrEmpty(stringValue) ? default : new ReadOnlySpan<T>((T[])(object)stringValue.ToCharArray());
         }
 
         public readonly ref struct SpanLike<T>

From 9786f7cad18ac188bb02c0c8f91c3bff25a3894f 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: Sun, 9 Jan 2022 14:15:39 -0800
Subject: [PATCH 283/444] Minor simplification in EnC (#58728)

---
 src/Features/Core/Portable/EditAndContinue/DebuggingSession.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Features/Core/Portable/EditAndContinue/DebuggingSession.cs b/src/Features/Core/Portable/EditAndContinue/DebuggingSession.cs
index 65e45cd4e71d2..50303676177fb 100644
--- a/src/Features/Core/Portable/EditAndContinue/DebuggingSession.cs
+++ b/src/Features/Core/Portable/EditAndContinue/DebuggingSession.cs
@@ -659,7 +659,7 @@ public async ValueTask<ImmutableArray<ImmutableArray<ActiveStatementSpan>>> GetB
                         var oldDocumentActiveStatements = await baseActiveStatements.GetOldActiveStatementsAsync(analyzer, oldDocument, cancellationToken).ConfigureAwait(false);
 
                         var analysis = await analyzer.AnalyzeDocumentAsync(
-                            LastCommittedSolution.GetRequiredProject(documentId.ProjectId),
+                            oldProject,
                             EditSession.BaseActiveStatements,
                             newDocument,
                             newActiveStatementSpans: ImmutableArray<LinePositionSpan>.Empty,

From 2ea8e8ce7fedcf0656ff68524c553d0a6f72050f Mon Sep 17 00:00:00 2001
From: David Wengier <david.wengier@microsoft.com>
Date: Mon, 10 Jan 2022 10:10:58 +1100
Subject: [PATCH 284/444] Offer to generate parameterless constructor for
 structs to fix CS8983 (#58743)

---
 .../GenerateDefaultConstructorsTests.cs       | 46 +++++++++++++++++++
 ...erateDefaultConstructorsCodeFixProvider.cs |  3 +-
 ...SharpGenerateDefaultConstructorsService.cs |  2 +-
 ...enerateDefaultConstructorsService.State.cs |  8 ++++
 4 files changed, 57 insertions(+), 2 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.cs b/src/EditorFeatures/CSharpTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.cs
index f8e4adc7628a7..c10e168658969 100644
--- a/src/EditorFeatures/CSharpTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.cs
+++ b/src/EditorFeatures/CSharpTest/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.cs
@@ -1409,5 +1409,51 @@ public B(int x)
     }
 }", index: 1);
         }
+
+        [WorkItem(58593, "https://github.com/dotnet/roslyn/issues/58593")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        public async Task TestStructWithFieldInitializer()
+        {
+            var source = @"
+struct [||]{|CS8983:S|}
+{
+    object X = 1;
+}
+";
+            var fixedSource = @"
+struct S
+{
+    object X = 1;
+
+    public S()
+    {
+    }
+}
+";
+
+            await new VerifyCodeFix.Test
+            {
+                TestCode = source.Replace("[||]", ""),
+                FixedCode = fixedSource,
+                LanguageVersion = LanguageVersion.Preview,
+            }.RunAsync();
+
+            await TestRefactoringMissingAsync(source);
+        }
+
+        [WorkItem(58593, "https://github.com/dotnet/roslyn/issues/58593")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)]
+        public async Task TestMissingInStructWithoutFieldInitializer()
+        {
+            var source = @"
+struct [||]S
+{
+    object X;
+}
+";
+
+            await TestCodeFixMissingAsync(source);
+            await TestRefactoringMissingAsync(source);
+        }
     }
 }
diff --git a/src/Features/CSharp/Portable/GenerateDefaultConstructors/CSharpGenerateDefaultConstructorsCodeFixProvider.cs b/src/Features/CSharp/Portable/GenerateDefaultConstructors/CSharpGenerateDefaultConstructorsCodeFixProvider.cs
index 5bb1a6ba4d899..ed8cb0ed896a3 100644
--- a/src/Features/CSharp/Portable/GenerateDefaultConstructors/CSharpGenerateDefaultConstructorsCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/GenerateDefaultConstructors/CSharpGenerateDefaultConstructorsCodeFixProvider.cs
@@ -16,6 +16,7 @@ internal class CSharpGenerateDefaultConstructorsCodeFixProvider : AbstractGenera
     {
         private const string CS1729 = nameof(CS1729); // 'B' does not contain a constructor that takes 0 arguments CSharpConsoleApp3   C:\Users\cyrusn\source\repos\CSharpConsoleApp3\CSharpConsoleApp3\Program.cs	1	Active
         private const string CS7036 = nameof(CS7036); // There is no argument given that corresponds to the required formal parameter 's' of 'B.B(string)'
+        private const string CS8983 = nameof(CS8983); // CS8983: A 'struct' with field initializers must include an explicitly declared constructor.
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
@@ -24,6 +25,6 @@ public CSharpGenerateDefaultConstructorsCodeFixProvider()
         }
 
         public override ImmutableArray<string> FixableDiagnosticIds { get; } =
-            ImmutableArray.Create(CS1729, CS7036);
+            ImmutableArray.Create(CS1729, CS7036, CS8983);
     }
 }
diff --git a/src/Features/CSharp/Portable/GenerateDefaultConstructors/CSharpGenerateDefaultConstructorsService.cs b/src/Features/CSharp/Portable/GenerateDefaultConstructors/CSharpGenerateDefaultConstructorsService.cs
index e43ccf74d7921..4f44ba38207c4 100644
--- a/src/Features/CSharp/Portable/GenerateDefaultConstructors/CSharpGenerateDefaultConstructorsService.cs
+++ b/src/Features/CSharp/Portable/GenerateDefaultConstructors/CSharpGenerateDefaultConstructorsService.cs
@@ -40,7 +40,7 @@ protected override bool TryInitializeState(
                 helpers.IsBetweenTypeMembers(semanticDocument.Text, semanticDocument.Root, textSpan.Start, out typeDeclaration))
             {
                 classType = semanticDocument.SemanticModel.GetDeclaredSymbol(typeDeclaration, cancellationToken) as INamedTypeSymbol;
-                return classType?.TypeKind == TypeKind.Class;
+                return classType?.TypeKind is TypeKind.Class or TypeKind.Struct;
             }
 
             var syntaxTree = semanticDocument.SyntaxTree;
diff --git a/src/Features/Core/Portable/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.State.cs b/src/Features/Core/Portable/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.State.cs
index 0bd001d809b77..7af524450a859 100644
--- a/src/Features/Core/Portable/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.State.cs
+++ b/src/Features/Core/Portable/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.State.cs
@@ -102,6 +102,14 @@ private static bool FixesError(INamedTypeSymbol classType, INamedTypeSymbol base
                         // and let the code fix provider handle it instead.
                         return true;
                     }
+
+                    // If this is a struct that has initializers, but is missing a parameterless constructor then we are fixing
+                    // an error (CS8983) but since this is the only scenario where we support structs we don't need to actually
+                    // check for anything else.
+                    if (classType.TypeKind == TypeKind.Struct)
+                    {
+                        return true;
+                    }
                 }
 
                 return false;

From f6396beb9bf78bc47168c87527565e8e48b9e994 Mon Sep 17 00:00:00 2001
From: David Wengier <david.wengier@microsoft.com>
Date: Mon, 10 Jan 2022 11:38:06 +1100
Subject: [PATCH 285/444] Don't crash when default namespace isn't a valid name
 (#58704)

---
 .../CSharpMatchFolderAndNamespaceTests.cs     | 91 +++++++++++++++++++
 .../Core/Utilities/PathMetadataUtilities.cs   |  8 ++
 2 files changed, 99 insertions(+)

diff --git a/src/Analyzers/CSharp/Tests/MatchFolderAndNamespace/CSharpMatchFolderAndNamespaceTests.cs b/src/Analyzers/CSharp/Tests/MatchFolderAndNamespace/CSharpMatchFolderAndNamespaceTests.cs
index b58eb56ce825a..7f423f75ec32b 100644
--- a/src/Analyzers/CSharp/Tests/MatchFolderAndNamespace/CSharpMatchFolderAndNamespaceTests.cs
+++ b/src/Analyzers/CSharp/Tests/MatchFolderAndNamespace/CSharpMatchFolderAndNamespaceTests.cs
@@ -7,6 +7,7 @@
 using System.IO;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Roslyn.Test.Utilities;
 using Xunit;
 using VerifyCS = Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.CSharpCodeFixVerifier<
     Microsoft.CodeAnalysis.CSharp.Analyzers.MatchFolderAndNamespace.CSharpMatchFolderAndNamespaceDiagnosticAnalyzer,
@@ -886,5 +887,95 @@ class P
 
             await testState.RunAsync();
         }
+
+        [Fact]
+        [WorkItem(58372, "https://github.com/dotnet/roslyn/issues/58372")]
+        public async Task InvalidProjectName_ChangeNamespace()
+        {
+            var defaultNamespace = "Invalid-Namespace";
+            var editorConfig = @$"
+is_global=true
+build_property.ProjectDir = {Directory}
+build_property.RootNamespace = {defaultNamespace}
+";
+
+            var folder = CreateFolderPath(new[] { "B", "C" });
+            var code =
+@"
+namespace [|A.B|]
+{    
+    class Class1
+    {
+    }
+}";
+
+            // The project name is invalid so the default namespace is not prepended
+            var fixedCode =
+@$"namespace B.C
+{{
+    class Class1
+    {{
+    }}
+}}";
+
+            await RunTestAsync(
+                "Class1.cs",
+                fileContents: code,
+                fixedCode: fixedCode,
+                directory: folder,
+                editorConfig: editorConfig,
+                defaultNamespace: defaultNamespace);
+        }
+
+        [Fact]
+        public async Task InvalidProjectName_DocumentAtRoot_ChangeNamespace()
+        {
+            var defaultNamespace = "Invalid-Namespace";
+            var editorConfig = @$"
+is_global=true
+build_property.ProjectDir = {Directory}
+build_property.RootNamespace = {defaultNamespace}
+";
+
+            var folder = CreateFolderPath();
+
+            var code =
+$@"namespace Test.Code
+{{
+    class C {{ }}
+}}";
+
+            await RunTestAsync(
+                "Class1.cs",
+                fileContents: code,
+                directory: folder,
+                editorConfig: editorConfig,
+                defaultNamespace: defaultNamespace);
+        }
+
+        [Fact]
+        public async Task InvalidRootNamespace_DocumentAtRoot_ChangeNamespace()
+        {
+            var editorConfig = @$"
+is_global=true
+build_property.ProjectDir = {Directory}
+build_property.RootNamespace = Test.Code # not an editorconfig comment even though it looks like one
+";
+
+            var folder = CreateFolderPath();
+
+            var code =
+$@"namespace Test.Code
+{{
+    class C {{ }}
+}}";
+
+            await RunTestAsync(
+                "Class1.cs",
+                fileContents: code,
+                directory: folder,
+                editorConfig: editorConfig,
+                defaultNamespace: "Invalid-Namespace");
+        }
     }
 }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/PathMetadataUtilities.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/PathMetadataUtilities.cs
index 91f7ebc0d46e0..7b856f51c8961 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/PathMetadataUtilities.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/PathMetadataUtilities.cs
@@ -27,6 +27,14 @@ internal static class PathMetadataUtilities
         {
             var parts = folders.SelectMany(folder => folder.Split(NamespaceSeparatorArray)).SelectAsArray(syntaxFacts.EscapeIdentifier);
 
+            // The root namespace can come directly from the project file name and/or
+            // editor config file, so if its not valid we don't want to use it.
+            if (rootNamespace is { Length: > 0 } &&
+                !rootNamespace.Split(NamespaceSeparatorArray).All(syntaxFacts.IsValidIdentifier))
+            {
+                rootNamespace = null;
+            }
+
             if (parts.IsDefaultOrEmpty)
             {
                 return rootNamespace;

From 8bce827d15860f7afc75bfca1626d60bff90e184 Mon Sep 17 00:00:00 2001
From: Daniel Cazzulino <daniel@cazzulino.com>
Date: Sun, 9 Jan 2022 23:12:53 -0300
Subject: [PATCH 286/444] Cleanup old workaround for arcadesdk (#45105)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The mentioned PR has been merged a long time ago and we're
already using a newer version that includes that fix.

Co-authored-by: Tomáš Matoušek <tmat@users.noreply.github.com>
---
 eng/Versions.props | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/eng/Versions.props b/eng/Versions.props
index f6252f44be69c..75f3b3eb2ecd3 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -15,14 +15,6 @@
       Keep the setting conditional. The toolset sets the assembly version to 42.42.42.42 if not set explicitly.
     -->
     <AssemblyVersion Condition="'$(OfficialBuild)' == 'true' or '$(DotNetUseShippingVersions)' == 'true'">$(MajorVersion).$(MinorVersion).0.0</AssemblyVersion>
-    <!--
-      Arcade overrides our VersionPrefix when MajorVersion and MinorVersion are specified. Clear them so that
-      we can keep the PatchVersion until we are using an SDK that includes https://github.com/dotnet/arcade/pull/3601
-    -->
-    <MajorVersion>
-    </MajorVersion>
-    <MinorVersion>
-    </MinorVersion>
     <MicrosoftNetCompilersToolsetVersion>4.1.0-2.21609.7</MicrosoftNetCompilersToolsetVersion>
   </PropertyGroup>
   <PropertyGroup>

From fe53cd10f37d08fce558d4f9d463325bfe36f0b8 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: Sun, 9 Jan 2022 20:17:58 -0800
Subject: [PATCH 287/444] Remove IntelliCodeCompletionOptions (#58748)

* Remove IntelliCodeCompletionOptions

* Remove PythiaCompletionProviderBase.HideAdvancedMembersOption
---
 .../Api/IntelliCodeCompletionOptions.cs          | 16 ----------------
 .../Pythia/Api/PythiaCompletionProviderBase.cs   |  2 --
 2 files changed, 18 deletions(-)
 delete mode 100644 src/Features/Core/Portable/ExternalAccess/IntelliCode/Api/IntelliCodeCompletionOptions.cs

diff --git a/src/Features/Core/Portable/ExternalAccess/IntelliCode/Api/IntelliCodeCompletionOptions.cs b/src/Features/Core/Portable/ExternalAccess/IntelliCode/Api/IntelliCodeCompletionOptions.cs
deleted file mode 100644
index 8200398e7712e..0000000000000
--- a/src/Features/Core/Portable/ExternalAccess/IntelliCode/Api/IntelliCodeCompletionOptions.cs
+++ /dev/null
@@ -1,16 +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 Microsoft.CodeAnalysis.Completion;
-using Microsoft.CodeAnalysis.Options;
-
-namespace Microsoft.CodeAnalysis.ExternalAccess.IntelliCode.Api
-{
-    internal static class IntelliCodeCompletionOptions
-    {
-        public static PerLanguageOption<bool> TriggerOnTyping { get; } = (PerLanguageOption<bool>)CompletionOptions.Metadata.TriggerOnTyping;
-
-        public static PerLanguageOption<bool> TriggerOnTypingLetters { get; } = (PerLanguageOption<bool>)CompletionOptions.Metadata.TriggerOnTypingLetters;
-    }
-}
diff --git a/src/Features/Core/Portable/ExternalAccess/Pythia/Api/PythiaCompletionProviderBase.cs b/src/Features/Core/Portable/ExternalAccess/Pythia/Api/PythiaCompletionProviderBase.cs
index db5036b25873f..f14cb3063a358 100644
--- a/src/Features/Core/Portable/ExternalAccess/Pythia/Api/PythiaCompletionProviderBase.cs
+++ b/src/Features/Core/Portable/ExternalAccess/Pythia/Api/PythiaCompletionProviderBase.cs
@@ -16,8 +16,6 @@ namespace Microsoft.CodeAnalysis.ExternalAccess.Pythia.Api
 {
     internal abstract class PythiaCompletionProviderBase : CommonCompletionProvider, INotifyCommittingItemCompletionProvider
     {
-        public static PerLanguageOption2<bool> HideAdvancedMembersOption => CompletionOptions.Metadata.HideAdvancedMembers;
-
         public static CompletionItem CreateCommonCompletionItem(
             string displayText,
             string displayTextSuffix,

From 09af9e440f10cb1acbb7d9168a9fc4b773e25f1c Mon Sep 17 00:00:00 2001
From: Charles Stoner <10732005+cston@users.noreply.github.com>
Date: Mon, 10 Jan 2022 10:42:27 -0800
Subject: [PATCH 288/444] Synthesize delegate types for lambdas with parameter
 types or return type that are not valid type arguments (#57295)

---
 .../Portable/Binder/Binder_Expressions.cs     |  12 +-
 .../CSharp/Portable/CSharpResources.resx      |   3 +
 .../EditAndContinue/CSharpSymbolMatcher.cs    |  99 +-
 .../Emitter/EditAndContinue/EmitHelpers.cs    |  86 +-
 .../EditAndContinue/PEDeltaAssemblyBuilder.cs |  84 +-
 .../Portable/Emitter/Model/PEModuleBuilder.cs |   2 +-
 .../CSharp/Portable/Errors/ErrorCode.cs       |   1 +
 .../AnonymousTypeManager.Templates.cs         | 399 +++++---
 .../AnonymousType.DelegateTemplateSymbol.cs   | 186 ++++
 .../AnonymousType.TemplateSymbol.cs           | 320 +-----
 ...nymousType.TypeOrDelegateTemplateSymbol.cs | 321 +++++++
 .../Symbols/Synthesized/GeneratedNames.cs     |   4 +-
 .../Synthesized/SynthesizedContainer.cs       |  30 +-
 .../Synthesized/SynthesizedDelegateSymbol.cs  | 107 ---
 .../Portable/xlf/CSharpResources.cs.xlf       |   5 +
 .../Portable/xlf/CSharpResources.de.xlf       |   5 +
 .../Portable/xlf/CSharpResources.es.xlf       |   5 +
 .../Portable/xlf/CSharpResources.fr.xlf       |   5 +
 .../Portable/xlf/CSharpResources.it.xlf       |   5 +
 .../Portable/xlf/CSharpResources.ja.xlf       |   5 +
 .../Portable/xlf/CSharpResources.ko.xlf       |   5 +
 .../Portable/xlf/CSharpResources.pl.xlf       |   5 +
 .../Portable/xlf/CSharpResources.pt-BR.xlf    |   5 +
 .../Portable/xlf/CSharpResources.ru.xlf       |   5 +
 .../Portable/xlf/CSharpResources.tr.xlf       |   5 +
 .../Portable/xlf/CSharpResources.zh-Hans.xlf  |   5 +
 .../Portable/xlf/CSharpResources.zh-Hant.xlf  |   5 +
 .../EditAndContinue/EditAndContinueTests.cs   | 350 ++++++-
 .../EditAndContinue/SymbolMatcherTests.cs     | 107 ++-
 .../Semantic/Semantics/DelegateTypeTests.cs   | 907 ++++++++++++++++--
 .../Test/Semantic/Semantics/LambdaTests.cs    |  11 +-
 .../Core/Portable/Emit/AnonymousTypeKey.cs    |   7 +-
 .../EditAndContinue/DeltaMetadataWriter.cs    |   3 +-
 .../Emit/EditAndContinue/EmitBaseline.cs      |  80 +-
 .../IPEDeltaAssemblyBuilder.cs                |   3 +-
 .../Emit/EditAndContinue/SymbolMatcher.cs     |  21 +-
 .../EditAndContinue/PEDeltaAssemblyBuilder.vb |  16 +-
 37 files changed, 2487 insertions(+), 737 deletions(-)
 create mode 100644 src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.DelegateTemplateSymbol.cs
 create mode 100644 src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.TypeOrDelegateTemplateSymbol.cs

diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
index 61be80e94b9b3..a11f9e07bb228 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
@@ -8753,10 +8753,9 @@ static bool isCandidateUnique(ref MethodSymbol? method, MethodSymbol candidate)
                 return null;
             }
 
-            if (!typeArguments.All(t => isValidTypeArgument(t.Type)))
+            if (!typeArguments.All(t => t.HasType))
             {
-                // https://github.com/dotnet/roslyn/issues/55217: Support parameter
-                // and return types that are not valid generic type arguments.
+                // Invalid parameter or return type.
                 return null;
             }
 
@@ -8797,13 +8796,6 @@ static bool isCandidateUnique(ref MethodSymbol? method, MethodSymbol candidate)
             var typeDescr = new AnonymousTypeDescriptor(fieldsBuilder.ToImmutableAndFree(), location);
             return Compilation.AnonymousTypeManager.ConstructAnonymousDelegateSymbol(typeDescr);
 
-            static bool isValidTypeArgument(TypeSymbol? type)
-            {
-                return type is { } &&
-                    !type.IsPointerOrFunctionPointer() &&
-                    !type.IsRestrictedType();
-            }
-
             static bool checkConstraints(CSharpCompilation compilation, ConversionsBase conversions, NamedTypeSymbol delegateType, ImmutableArray<TypeWithAnnotations> typeArguments)
             {
                 var diagnosticsBuilder = ArrayBuilder<TypeParameterDiagnosticInfo>.GetInstance();
diff --git a/src/Compilers/CSharp/Portable/CSharpResources.resx b/src/Compilers/CSharp/Portable/CSharpResources.resx
index a76b0e21f90aa..4220added2ad8 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.resx
+++ b/src/Compilers/CSharp/Portable/CSharpResources.resx
@@ -6917,6 +6917,9 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_StructHasInitializersAndNoDeclaredConstructor" xml:space="preserve">
     <value>A 'struct' with field initializers must include an explicitly declared constructor.</value>
   </data>
+  <data name="ERR_EncUpdateFailedDelegateTypeChanged" xml:space="preserve">
+    <value>Cannot update because an inferred delegate type has changed.</value>
+  </data>
   <data name="WRN_CompileTimeCheckedOverflow" xml:space="preserve">
     <value>The operation may overflow '{0}' at runtime (use 'unchecked' syntax to override)</value>
   </data>
diff --git a/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/CSharpSymbolMatcher.cs b/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/CSharpSymbolMatcher.cs
index 0fa5603c6d141..c9f41c978e759 100644
--- a/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/CSharpSymbolMatcher.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/CSharpSymbolMatcher.cs
@@ -26,7 +26,8 @@ internal sealed class CSharpSymbolMatcher : SymbolMatcher
 
         public CSharpSymbolMatcher(
             IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> anonymousTypeMap,
-            IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> synthesizedDelegates,
+            IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> anonymousDelegates,
+            IReadOnlyDictionary<string, AnonymousTypeValue> anonymousDelegatesWithFixedTypes,
             SourceAssemblySymbol sourceAssembly,
             EmitContext sourceContext,
             SourceAssemblySymbol otherAssembly,
@@ -34,12 +35,13 @@ public CSharpSymbolMatcher(
             ImmutableDictionary<ISymbolInternal, ImmutableArray<ISymbolInternal>> otherSynthesizedMembersOpt)
         {
             _defs = new MatchDefsToSource(sourceContext, otherContext);
-            _symbols = new MatchSymbols(anonymousTypeMap, synthesizedDelegates, sourceAssembly, otherAssembly, otherSynthesizedMembersOpt, new DeepTranslator(otherAssembly.GetSpecialType(SpecialType.System_Object)));
+            _symbols = new MatchSymbols(anonymousTypeMap, anonymousDelegates, anonymousDelegatesWithFixedTypes, sourceAssembly, otherAssembly, otherSynthesizedMembersOpt, new DeepTranslator(otherAssembly.GetSpecialType(SpecialType.System_Object)));
         }
 
         public CSharpSymbolMatcher(
             IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> anonymousTypeMap,
-            IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> synthesizedDelegates,
+            IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> anonymousDelegates,
+            IReadOnlyDictionary<string, AnonymousTypeValue> anonymousDelegatesWithFixedTypes,
             SourceAssemblySymbol sourceAssembly,
             EmitContext sourceContext,
             PEAssemblySymbol otherAssembly)
@@ -48,7 +50,8 @@ public CSharpSymbolMatcher(
 
             _symbols = new MatchSymbols(
                 anonymousTypeMap,
-                synthesizedDelegates,
+                anonymousDelegates,
+                anonymousDelegatesWithFixedTypes,
                 sourceAssembly,
                 otherAssembly,
                 otherSynthesizedMembers: null,
@@ -276,7 +279,8 @@ public MatchDefsToSource(
         private sealed class MatchSymbols : CSharpSymbolVisitor<Symbol?>
         {
             private readonly IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> _anonymousTypeMap;
-            private readonly IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> _synthesizedDelegates;
+            private readonly IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> _anonymousDelegates;
+            private readonly IReadOnlyDictionary<string, AnonymousTypeValue> _anonymousDelegatesWithFixedTypes;
             private readonly SourceAssemblySymbol _sourceAssembly;
 
             // metadata or source assembly:
@@ -301,14 +305,16 @@ private sealed class MatchSymbols : CSharpSymbolVisitor<Symbol?>
 
             public MatchSymbols(
                 IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> anonymousTypeMap,
-                IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> synthesizedDelegates,
+                IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> anonymousDelegates,
+                IReadOnlyDictionary<string, AnonymousTypeValue> anonymousDelegatesWithFixedTypes,
                 SourceAssemblySymbol sourceAssembly,
                 AssemblySymbol otherAssembly,
                 ImmutableDictionary<ISymbolInternal, ImmutableArray<ISymbolInternal>>? otherSynthesizedMembers,
                 DeepTranslator? deepTranslator)
             {
                 _anonymousTypeMap = anonymousTypeMap;
-                _synthesizedDelegates = synthesizedDelegates;
+                _anonymousDelegates = anonymousDelegates;
+                _anonymousDelegatesWithFixedTypes = anonymousDelegatesWithFixedTypes;
                 _sourceAssembly = sourceAssembly;
                 _otherAssembly = otherAssembly;
                 _otherSynthesizedMembers = otherSynthesizedMembers;
@@ -528,17 +534,25 @@ public override Symbol VisitDynamicType(DynamicTypeSymbol symbol)
                 switch (otherContainer.Kind)
                 {
                     case SymbolKind.Namespace:
-                        if (sourceType is AnonymousTypeManager.AnonymousTypeTemplateSymbol template)
+                        if (sourceType is AnonymousTypeManager.AnonymousTypeTemplateSymbol typeTemplate)
                         {
                             Debug.Assert((object)otherContainer == (object)_otherAssembly.GlobalNamespace);
-                            TryFindAnonymousType(template, out var value);
+                            TryFindAnonymousType(typeTemplate, out var value);
                             return (NamedTypeSymbol?)value.Type?.GetInternalSymbol();
                         }
-                        else if (sourceType is SynthesizedDelegateSymbol delegateSymbol)
+                        else if (sourceType is AnonymousTypeManager.AnonymousDelegateTemplateSymbol delegateTemplate)
                         {
                             Debug.Assert((object)otherContainer == (object)_otherAssembly.GlobalNamespace);
-                            TryFindSynthesizedDelegate(delegateSymbol, out var value);
-                            return (NamedTypeSymbol?)value.Delegate?.GetInternalSymbol();
+                            if (delegateTemplate.HasFixedTypes)
+                            {
+                                TryFindAnonymousDelegateWithFixedType(delegateTemplate, out var value);
+                                return (NamedTypeSymbol?)value.Type?.GetInternalSymbol();
+                            }
+                            else
+                            {
+                                TryFindAnonymousDelegate(delegateTemplate, out var value);
+                                return (NamedTypeSymbol?)value.Delegate?.GetInternalSymbol();
+                            }
                         }
 
                         if (sourceType.IsAnonymousType)
@@ -662,12 +676,55 @@ internal bool TryFindAnonymousType(AnonymousTypeManager.AnonymousTypeTemplateSym
                 return _anonymousTypeMap.TryGetValue(type.GetAnonymousTypeKey(), out otherType);
             }
 
-            internal bool TryFindSynthesizedDelegate(SynthesizedDelegateSymbol delegateSymbol, out SynthesizedDelegateValue otherDelegateSymbol)
+            internal bool TryFindAnonymousDelegate(AnonymousTypeManager.AnonymousDelegateTemplateSymbol delegateSymbol, out SynthesizedDelegateValue otherDelegateSymbol)
             {
                 Debug.Assert((object)delegateSymbol.ContainingSymbol == (object)_sourceAssembly.GlobalNamespace);
 
                 var key = new SynthesizedDelegateKey(delegateSymbol.MetadataName);
-                return _synthesizedDelegates.TryGetValue(key, out otherDelegateSymbol);
+                return _anonymousDelegates.TryGetValue(key, out otherDelegateSymbol);
+            }
+
+            internal bool TryFindAnonymousDelegateWithFixedType(AnonymousTypeManager.AnonymousDelegateTemplateSymbol type, out AnonymousTypeValue otherType)
+            {
+                Debug.Assert((object)type.ContainingSymbol == (object)_sourceAssembly.GlobalNamespace);
+
+                // Anonymous delegates with fixed types are indexed by name, and the names are <>f__AnonymousDelegate0, 1, ... .
+                // Within a compilation, the index in the name is determined by source order, but the actual signature
+                // of the delegate type may change between generations. For instance, the signature of a lambda
+                // expression may have been changed explicitly, or another lambda expression may have been inserted
+                // ahead of this one in source order. Therefore, we need to verify the signatures of the delegate types
+                // are equivalent - by comparing the Invoke() method signatures.
+                if (_anonymousDelegatesWithFixedTypes.TryGetValue(type.Name, out otherType) &&
+                    otherType.Type.GetInternalSymbol() is NamedTypeSymbol otherDelegateType &&
+                    isCorrespondingAnonymousDelegate(type, otherDelegateType))
+                {
+                    return true;
+                }
+
+                otherType = default;
+                return false;
+
+                bool isCorrespondingAnonymousDelegate(NamedTypeSymbol type, NamedTypeSymbol otherType)
+                {
+                    if (type.Arity != otherType.Arity)
+                    {
+                        return false;
+                    }
+
+                    type = SubstituteTypeParameters(type);
+                    otherType = SubstituteTypeParameters(otherType);
+
+                    return type.DelegateInvokeMethod is { } invokeMethod &&
+                        otherType.DelegateInvokeMethod is { } otherInvokeMethod &&
+                        invokeMethod.Parameters.SequenceEqual(otherInvokeMethod.Parameters, (x, y) => isCorrespondingType(x.TypeWithAnnotations, y.TypeWithAnnotations)) &&
+                        isCorrespondingType(invokeMethod.ReturnTypeWithAnnotations, otherInvokeMethod.ReturnTypeWithAnnotations);
+                }
+
+                bool isCorrespondingType(TypeWithAnnotations type, TypeWithAnnotations expectedType)
+                {
+                    var otherType = type.WithTypeAndModifiers((TypeSymbol?)this.Visit(type.Type), this.VisitCustomModifiers(type.CustomModifiers));
+                    return otherType.Equals(expectedType, TypeCompareKind.CLRSignatureCompareOptions);
+                }
             }
 
             private Symbol? VisitNamedTypeMember<T>(T member, Func<T, T, bool> predicate)
@@ -768,6 +825,20 @@ private bool AreNamedTypesEqual(NamedTypeSymbol type, NamedTypeSymbol other)
                 return type.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.SequenceEqual(other.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics, AreTypesEqual);
             }
 
+            private static NamedTypeSymbol SubstituteTypeParameters(NamedTypeSymbol type)
+            {
+                Debug.Assert(type.IsDefinition);
+
+                var typeParameters = type.TypeParameters;
+                int n = typeParameters.Length;
+                if (n == 0)
+                {
+                    return type;
+                }
+
+                return type.Construct(IndexedTypeParameterSymbol.Take(n));
+            }
+
             private bool AreNamespacesEqual(NamespaceSymbol @namespace, NamespaceSymbol other)
             {
                 Debug.Assert(StringOrdinalComparer.Equals(@namespace.MetadataName, other.MetadataName));
diff --git a/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/EmitHelpers.cs b/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/EmitHelpers.cs
index d996f499c3086..acf88a850bc11 100644
--- a/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/EmitHelpers.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/EmitHelpers.cs
@@ -7,6 +7,7 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.IO;
+using System.Linq;
 using System.Reflection.Metadata;
 using System.Threading;
 using Microsoft.CodeAnalysis.CodeGen;
@@ -82,25 +83,32 @@ internal static EmitDifferenceResult EmitDifference(
                 filterOpt: s => changes.RequiresCompilation(s.GetISymbol()),
                 cancellationToken: cancellationToken))
             {
-                // Map the definitions from the previous compilation to the current compilation.
-                // This must be done after compiling above since synthesized definitions
-                // (generated when compiling method bodies) may be required.
-                var mappedBaseline = MapToCompilation(compilation, moduleBeingBuilt);
-
-                newBaseline = compilation.SerializeToDeltaStreams(
-                    moduleBeingBuilt,
-                    mappedBaseline,
-                    definitionMap,
-                    changes,
-                    metadataStream,
-                    ilStream,
-                    pdbStream,
-                    updatedMethods,
-                    changedTypes,
-                    diagnostics,
-                    testData?.SymWriterFactory,
-                    emitOptions.PdbFilePath,
-                    cancellationToken);
+                if (!ContainsPreviousAnonymousDelegates(definitionMap, baseline.AnonymousDelegatesWithFixedTypes, moduleBeingBuilt.GetAnonymousDelegatesWithFixedTypes()))
+                {
+                    diagnostics.Add(ErrorCode.ERR_EncUpdateFailedDelegateTypeChanged, Location.None);
+                }
+                else
+                {
+                    // Map the definitions from the previous compilation to the current compilation.
+                    // This must be done after compiling above since synthesized definitions
+                    // (generated when compiling method bodies) may be required.
+                    var mappedBaseline = MapToCompilation(compilation, moduleBeingBuilt);
+
+                    newBaseline = compilation.SerializeToDeltaStreams(
+                        moduleBeingBuilt,
+                        mappedBaseline,
+                        definitionMap,
+                        changes,
+                        metadataStream,
+                        ilStream,
+                        pdbStream,
+                        updatedMethods,
+                        changedTypes,
+                        diagnostics,
+                        testData?.SymWriterFactory,
+                        emitOptions.PdbFilePath,
+                        cancellationToken);
+                }
             }
 
             return new EmitDifferenceResult(
@@ -111,6 +119,37 @@ internal static EmitDifferenceResult EmitDifference(
                 changedTypes: changedTypes.ToImmutableAndFree());
         }
 
+        private static bool ContainsPreviousAnonymousDelegates(
+            CSharpDefinitionMap definitionMap,
+            IReadOnlyDictionary<string, AnonymousTypeValue> previousDictionary,
+            IReadOnlyDictionary<string, AnonymousTypeValue> currentDictionary)
+        {
+            if (previousDictionary.Count == 0)
+            {
+                return true;
+            }
+
+            if (previousDictionary.Count > currentDictionary.Count)
+            {
+                return false;
+            }
+
+            Dictionary<string, Cci.ITypeDefinition> currentTypes = getTypes(currentDictionary).ToDictionary(t => getName(t));
+            IEnumerable<Cci.ITypeDefinition> previousTypes = getTypes(previousDictionary);
+            foreach (var previousType in previousTypes)
+            {
+                if (!currentTypes.TryGetValue(getName(previousType), out var currentType) ||
+                    definitionMap.MapDefinition(currentType) is null)
+                {
+                    return false;
+                }
+            }
+            return true;
+
+            static IEnumerable<Cci.ITypeDefinition> getTypes(IReadOnlyDictionary<string, AnonymousTypeValue> dictionary) => dictionary.Values.Select(v => v.Type);
+            static string getName(Cci.ITypeDefinition type) => ((Cci.INamedEntity)type).Name!;
+        }
+
         /// <summary>
         /// Return a version of the baseline with all definitions mapped to this compilation.
         /// Definitions from the initial generation, from metadata, are not mapped since
@@ -140,14 +179,16 @@ private static EmitBaseline MapToCompilation(
 
             // Mapping from previous compilation to the current.
             var anonymousTypeMap = moduleBeingBuilt.GetAnonymousTypeMap();
-            var synthesizedDelegates = moduleBeingBuilt.GetSynthesizedDelegates();
+            var anonymousDelegates = moduleBeingBuilt.GetAnonymousDelegates();
+            var anonymousDelegatesWithFixedTypes = moduleBeingBuilt.GetAnonymousDelegatesWithFixedTypes();
             var sourceAssembly = ((CSharpCompilation)previousGeneration.Compilation).SourceAssembly;
             var sourceContext = new EmitContext((PEModuleBuilder)previousGeneration.PEModuleBuilder, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
             var otherContext = new EmitContext(moduleBeingBuilt, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
 
             var matcher = new CSharpSymbolMatcher(
                 anonymousTypeMap,
-                synthesizedDelegates,
+                anonymousDelegates,
+                anonymousDelegatesWithFixedTypes,
                 sourceAssembly,
                 sourceContext,
                 compilation.SourceAssembly,
@@ -159,7 +200,8 @@ private static EmitBaseline MapToCompilation(
             // TODO: can we reuse some data from the previous matcher?
             var matcherWithAllSynthesizedMembers = new CSharpSymbolMatcher(
                 anonymousTypeMap,
-                synthesizedDelegates,
+                anonymousDelegates,
+                anonymousDelegatesWithFixedTypes,
                 sourceAssembly,
                 sourceContext,
                 compilation.SourceAssembly,
diff --git a/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/PEDeltaAssemblyBuilder.cs b/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/PEDeltaAssemblyBuilder.cs
index f3f674f209c65..efcb150be20da 100644
--- a/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/PEDeltaAssemblyBuilder.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/PEDeltaAssemblyBuilder.cs
@@ -47,7 +47,13 @@ public PEDeltaAssemblyBuilder(
             var metadataDecoder = (MetadataDecoder)metadataSymbols.MetadataDecoder;
             var metadataAssembly = (PEAssemblySymbol)metadataDecoder.ModuleSymbol.ContainingAssembly;
 
-            var matchToMetadata = new CSharpSymbolMatcher(metadataSymbols.AnonymousTypes, metadataSymbols.SynthesizedDelegates, sourceAssembly, context, metadataAssembly);
+            var matchToMetadata = new CSharpSymbolMatcher(
+                metadataSymbols.AnonymousTypes,
+                metadataSymbols.AnonymousDelegates,
+                metadataSymbols.AnonymousDelegatesWithFixedTypes,
+                sourceAssembly,
+                context,
+                metadataAssembly);
 
             CSharpSymbolMatcher? matchToPrevious = null;
             if (previousGeneration.Ordinal > 0)
@@ -60,7 +66,8 @@ public PEDeltaAssemblyBuilder(
 
                 matchToPrevious = new CSharpSymbolMatcher(
                     previousGeneration.AnonymousTypeMap,
-                    previousGeneration.SynthesizedDelegates,
+                    previousGeneration.AnonymousDelegates,
+                    previousGeneration.AnonymousDelegatesWithFixedTypes,
                     sourceAssembly: sourceAssembly,
                     sourceContext: context,
                     otherAssembly: previousAssembly,
@@ -116,21 +123,29 @@ private static EmitBaseline.MetadataSymbols GetOrCreateMetadataSymbols(EmitBasel
             ImmutableDictionary<AssemblyIdentity, AssemblyIdentity> assemblyReferenceIdentityMap;
             var metadataAssembly = metadataCompilation.GetBoundReferenceManager().CreatePEAssemblyForAssemblyMetadata(AssemblyMetadata.Create(originalMetadata), MetadataImportOptions.All, out assemblyReferenceIdentityMap);
             var metadataDecoder = new MetadataDecoder(metadataAssembly.PrimaryModule);
-            var metadataAnonymousTypes = GetAnonymousTypeMapFromMetadata(originalMetadata.MetadataReader, metadataDecoder);
-            var metadataSynthesizedDelegates = GetSynthesizedDelegateMapFromMetadata(originalMetadata.MetadataReader, metadataDecoder);
-            var metadataSymbols = new EmitBaseline.MetadataSymbols(metadataAnonymousTypes, metadataSynthesizedDelegates, metadataDecoder, assemblyReferenceIdentityMap);
+            GetAnonymousTypeMapFromMetadata(originalMetadata.MetadataReader, metadataDecoder, out var metadataAnonymousTypes, out var metadataAnonymousDelegatesWithFixedTypes);
+            var metadataAnonymousDelegates = GetAnonymousDelegateMapFromMetadata(originalMetadata.MetadataReader, metadataDecoder);
+            var metadataSymbols = new EmitBaseline.MetadataSymbols(metadataAnonymousTypes, metadataAnonymousDelegates, metadataAnonymousDelegatesWithFixedTypes, metadataDecoder, assemblyReferenceIdentityMap);
 
             return InterlockedOperations.Initialize(ref initialBaseline.LazyMetadataSymbols, metadataSymbols);
         }
 
         // internal for testing
-        internal static IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> GetAnonymousTypeMapFromMetadata(MetadataReader reader, MetadataDecoder metadataDecoder)
+        internal static void GetAnonymousTypeMapFromMetadata(
+            MetadataReader reader,
+            MetadataDecoder metadataDecoder,
+            out IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> anonymousTypes,
+            out IReadOnlyDictionary<string, AnonymousTypeValue> anonymousDelegatesWithFixedTypes)
         {
             // In general, the anonymous type name is "<{module-id}>f__AnonymousType{index}#{submission-index}",
             // but EnC is not supported for modules nor submissions. Hence we only look for type names with no module id and no submission index.
-            const string AnonymousNameWithoutModulePrefix = "<>f__AnonymousType";
+            const string AnonymousTypeOrDelegateNamePrefix = "<>f__Anonymous";
+            const string AnonymousTypeNameWithoutModulePrefix = AnonymousTypeOrDelegateNamePrefix + "Type";
+            const string AnonymousDelegateNameWithoutModulePrefix = AnonymousTypeOrDelegateNamePrefix + "Delegate";
+
+            var types = new Dictionary<AnonymousTypeKey, AnonymousTypeValue>();
+            var delegates = new Dictionary<string, AnonymousTypeValue>();
 
-            var result = new Dictionary<AnonymousTypeKey, AnonymousTypeValue>();
             foreach (var handle in reader.TypeDefinitions)
             {
                 var def = reader.GetTypeDefinition(handle);
@@ -139,7 +154,7 @@ internal static IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> GetAno
                     continue;
                 }
 
-                if (!reader.StringComparer.StartsWith(def.Name, AnonymousNameWithoutModulePrefix))
+                if (!reader.StringComparer.StartsWith(def.Name, AnonymousTypeOrDelegateNamePrefix))
                 {
                     continue;
                 }
@@ -147,27 +162,38 @@ internal static IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> GetAno
                 var metadataName = reader.GetString(def.Name);
                 var name = MetadataHelpers.InferTypeArityAndUnmangleMetadataName(metadataName, out _);
 
-                if (name.StartsWith(AnonymousNameWithoutModulePrefix, StringComparison.Ordinal) &&
-                    int.TryParse(name.Substring(AnonymousNameWithoutModulePrefix.Length), NumberStyles.None, CultureInfo.InvariantCulture, out int index))
+                if (name.StartsWith(AnonymousTypeNameWithoutModulePrefix, StringComparison.Ordinal))
+                {
+                    if (int.TryParse(name.Substring(AnonymousTypeNameWithoutModulePrefix.Length), NumberStyles.None, CultureInfo.InvariantCulture, out int index))
+                    {
+                        var builder = ArrayBuilder<AnonymousTypeKeyField>.GetInstance();
+                        if (TryGetAnonymousTypeKey(reader, def, builder))
+                        {
+                            var type = (NamedTypeSymbol)metadataDecoder.GetTypeOfToken(handle);
+                            var key = new AnonymousTypeKey(builder.ToImmutable());
+                            var value = new AnonymousTypeValue(name, index, type.GetCciAdapter());
+                            types.Add(key, value);
+                        }
+                        builder.Free();
+                    }
+                }
+                else if (name.StartsWith(AnonymousDelegateNameWithoutModulePrefix, StringComparison.Ordinal))
                 {
-                    var builder = ArrayBuilder<AnonymousTypeKeyField>.GetInstance();
-                    if (TryGetAnonymousTypeKey(reader, def, builder))
+                    if (int.TryParse(name.Substring(AnonymousDelegateNameWithoutModulePrefix.Length), NumberStyles.None, CultureInfo.InvariantCulture, out int index))
                     {
                         var type = (NamedTypeSymbol)metadataDecoder.GetTypeOfToken(handle);
-                        var key = new AnonymousTypeKey(builder.ToImmutable());
                         var value = new AnonymousTypeValue(name, index, type.GetCciAdapter());
-                        result.Add(key, value);
+                        delegates.Add(name, value);
                     }
-
-                    builder.Free();
                 }
             }
 
-            return result;
+            anonymousTypes = types;
+            anonymousDelegatesWithFixedTypes = delegates;
         }
 
         // internal for testing
-        internal static IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> GetSynthesizedDelegateMapFromMetadata(MetadataReader reader, MetadataDecoder metadataDecoder)
+        internal static IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> GetAnonymousDelegateMapFromMetadata(MetadataReader reader, MetadataDecoder metadataDecoder)
         {
             var result = new Dictionary<SynthesizedDelegateKey, SynthesizedDelegateValue>();
             foreach (var handle in reader.TypeDefinitions)
@@ -238,12 +264,20 @@ public IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> GetAnonymousTyp
             return anonymousTypes;
         }
 
-        public IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> GetSynthesizedDelegates()
+        public IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> GetAnonymousDelegates()
+        {
+            var anonymousDelegates = this.Compilation.AnonymousTypeManager.GetAnonymousDelegates();
+            // Should contain all entries in previous generation.
+            Debug.Assert(_previousGeneration.AnonymousDelegates.All(p => anonymousDelegates.ContainsKey(p.Key)));
+            return anonymousDelegates;
+        }
+
+        public IReadOnlyDictionary<string, AnonymousTypeValue> GetAnonymousDelegatesWithFixedTypes()
         {
-            var synthesizedDelegates = this.Compilation.AnonymousTypeManager.GetSynthesizedDelegates();
+            var anonymousDelegates = this.Compilation.AnonymousTypeManager.GetAnonymousDelegatesWithFixedTypes();
             // Should contain all entries in previous generation.
-            Debug.Assert(_previousGeneration.SynthesizedDelegates.All(p => synthesizedDelegates.ContainsKey(p.Key)));
-            return synthesizedDelegates;
+            Debug.Assert(_previousGeneration.AnonymousDelegatesWithFixedTypes.All(p => anonymousDelegates.ContainsKey(p.Key)));
+            return anonymousDelegates;
         }
 
         public override IEnumerable<Cci.INamespaceTypeDefinition> GetTopLevelTypeDefinitions(EmitContext context)
@@ -274,9 +308,9 @@ internal override ImmutableArray<AnonymousTypeKey> GetPreviousAnonymousTypes()
             return ImmutableArray.CreateRange(_previousGeneration.AnonymousTypeMap.Keys);
         }
 
-        internal override ImmutableArray<SynthesizedDelegateKey> GetPreviousSynthesizedDelegates()
+        internal override ImmutableArray<SynthesizedDelegateKey> GetPreviousAnonymousDelegates()
         {
-            return ImmutableArray.CreateRange(_previousGeneration.SynthesizedDelegates.Keys);
+            return ImmutableArray.CreateRange(_previousGeneration.AnonymousDelegates.Keys);
         }
 
         internal override int GetNextAnonymousTypeIndex()
diff --git a/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs b/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs
index b64be1556d300..e7344972930ab 100644
--- a/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs
@@ -497,7 +497,7 @@ internal virtual ImmutableArray<AnonymousTypeKey> GetPreviousAnonymousTypes()
             return ImmutableArray<AnonymousTypeKey>.Empty;
         }
 
-        internal virtual ImmutableArray<SynthesizedDelegateKey> GetPreviousSynthesizedDelegates()
+        internal virtual ImmutableArray<SynthesizedDelegateKey> GetPreviousAnonymousDelegates()
         {
             return ImmutableArray<SynthesizedDelegateKey>.Empty;
         }
diff --git a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
index c6ac42c8d647c..331a67db4e803 100644
--- a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
+++ b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
@@ -2018,6 +2018,7 @@ internal enum ErrorCode
         WRN_LowerCaseTypeName = 8981,
         ERR_RecordStructConstructorCallsDefaultConstructor = 8982,
         ERR_StructHasInitializersAndNoDeclaredConstructor = 8983,
+        ERR_EncUpdateFailedDelegateTypeChanged = 8984,
 
         ERR_IncorrectNullCheckSyntax = 8990,
         ERR_MustNullCheckInImplementation = 8991,
diff --git a/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/AnonymousTypeManager.Templates.cs b/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/AnonymousTypeManager.Templates.cs
index d351d8a1ffb3b..777fac21badf9 100644
--- a/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/AnonymousTypeManager.Templates.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/AnonymousTypeManager.Templates.cs
@@ -12,6 +12,7 @@
 using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Emit;
+using Microsoft.CodeAnalysis.Emit;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
 
@@ -33,26 +34,26 @@ internal sealed partial class AnonymousTypeManager
         /// Maps delegate signature shape (number of parameters and their ref-ness) to a synthesized generic delegate symbol.
         /// Currently used for dynamic call-sites and inferred delegate types whose signature doesn't match any of the well-known Func or Action types.
         /// </summary>
-        private ConcurrentDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> _lazySynthesizedDelegates;
+        private ConcurrentDictionary<SynthesizedDelegateKey, AnonymousDelegateTemplateSymbol> _lazyAnonymousDelegates;
 
-        private struct SynthesizedDelegateKey : IEquatable<SynthesizedDelegateKey>
+        private readonly struct SynthesizedDelegateKey : IEquatable<SynthesizedDelegateKey>
         {
-            private readonly RefKindVector _byRefs;
-            private readonly ushort _parameterCount;
-            private readonly bool _returnsVoid;
-            private readonly int _generation;
+            internal readonly string Name;
+            internal readonly int ParameterCount;
+            internal readonly AnonymousTypeDescriptor TypeDescriptor;
 
             public SynthesizedDelegateKey(int parameterCount, RefKindVector byRefs, bool returnsVoid, int generation)
             {
-                _parameterCount = (ushort)parameterCount;
-                _returnsVoid = returnsVoid;
-                _generation = generation;
-                _byRefs = byRefs;
+                Name = GeneratedNames.MakeSynthesizedDelegateName(byRefs, returnsVoid, generation);
+                ParameterCount = parameterCount;
+                TypeDescriptor = default;
             }
 
-            public string MakeTypeName()
+            public SynthesizedDelegateKey(AnonymousTypeDescriptor typeDescr)
             {
-                return GeneratedNames.MakeSynthesizedDelegateName(_byRefs, _returnsVoid, _generation);
+                Name = null;
+                ParameterCount = -1;
+                TypeDescriptor = typeDescr;
             }
 
             public override bool Equals(object obj)
@@ -62,32 +63,24 @@ public override bool Equals(object obj)
 
             public bool Equals(SynthesizedDelegateKey other)
             {
-                return _parameterCount == other._parameterCount
-                    && _returnsVoid == other._returnsVoid
-                    && _generation == other._generation
-                    && _byRefs.Equals(other._byRefs);
+                if (!string.Equals(Name, other.Name))
+                {
+                    return false;
+                }
+                if (Name is null)
+                {
+                    return TypeDescriptor.Equals(other.TypeDescriptor);
+                }
+                return ParameterCount == other.ParameterCount;
             }
 
             public override int GetHashCode()
             {
-                return Hash.Combine(
-                    Hash.Combine((int)_parameterCount, _generation),
-                    Hash.Combine(_returnsVoid.GetHashCode(), _byRefs.GetHashCode()));
-            }
-        }
-
-        private struct SynthesizedDelegateValue
-        {
-            public readonly SynthesizedDelegateSymbol Delegate;
-
-            // the manager that created this delegate:
-            public readonly AnonymousTypeManager Manager;
-
-            public SynthesizedDelegateValue(AnonymousTypeManager manager, SynthesizedDelegateSymbol @delegate)
-            {
-                Debug.Assert(manager != null && (object)@delegate != null);
-                this.Manager = manager;
-                this.Delegate = @delegate;
+                if (Name is null)
+                {
+                    return TypeDescriptor.GetHashCode();
+                }
+                return Hash.Combine((int)ParameterCount, Name.GetHashCode());
             }
         }
 
@@ -140,52 +133,52 @@ private ConcurrentDictionary<string, AnonymousTypeTemplateSymbol> AnonymousTypeT
             }
         }
 
-        private ConcurrentDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> SynthesizedDelegates
+        private ConcurrentDictionary<SynthesizedDelegateKey, AnonymousDelegateTemplateSymbol> AnonymousDelegates
         {
             get
             {
-                if (_lazySynthesizedDelegates == null)
+                if (_lazyAnonymousDelegates == null)
                 {
                     CSharpCompilation previousSubmission = this.Compilation.PreviousSubmission;
 
                     // TODO (tomat): avoid recursion
-                    var previousCache = (previousSubmission == null) ? null : previousSubmission.AnonymousTypeManager._lazySynthesizedDelegates;
+                    var previousCache = (previousSubmission == null) ? null : previousSubmission.AnonymousTypeManager._lazyAnonymousDelegates;
 
-                    Interlocked.CompareExchange(ref _lazySynthesizedDelegates,
+                    Interlocked.CompareExchange(ref _lazyAnonymousDelegates,
                                                 previousCache == null
-                                                    ? new ConcurrentDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue>()
-                                                    : new ConcurrentDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue>(previousCache),
+                                                    ? new ConcurrentDictionary<SynthesizedDelegateKey, AnonymousDelegateTemplateSymbol>()
+                                                    : new ConcurrentDictionary<SynthesizedDelegateKey, AnonymousDelegateTemplateSymbol>(previousCache),
                                                 null);
                 }
 
-                return _lazySynthesizedDelegates;
+                return _lazyAnonymousDelegates;
             }
         }
 
 #nullable enable
-        internal SynthesizedDelegateSymbol SynthesizeDelegate(int parameterCount, RefKindVector refKinds, bool returnsVoid, int generation)
+        internal AnonymousDelegateTemplateSymbol SynthesizeDelegate(int parameterCount, RefKindVector refKinds, bool returnsVoid, int generation)
         {
             // parameterCount doesn't include return type
             Debug.Assert(refKinds.IsNull || parameterCount == refKinds.Capacity - (returnsVoid ? 0 : 1));
 
             var key = new SynthesizedDelegateKey(parameterCount, refKinds, returnsVoid, generation);
 
-            SynthesizedDelegateValue result;
-            if (this.SynthesizedDelegates.TryGetValue(key, out result))
+            AnonymousDelegateTemplateSymbol? synthesizedDelegate;
+            if (this.AnonymousDelegates.TryGetValue(key, out synthesizedDelegate))
             {
-                return result.Delegate;
+                return synthesizedDelegate;
             }
 
             // NOTE: the newly created template may be thrown away if another thread wins
-            var synthesizedDelegate = new SynthesizedDelegateSymbol(
-                this.Compilation.Assembly.GlobalNamespace,
-                key.MakeTypeName(),
+            synthesizedDelegate = new AnonymousDelegateTemplateSymbol(
+                this,
+                key.Name,
                 this.System_Object,
                 Compilation.GetSpecialType(SpecialType.System_IntPtr),
                 returnsVoid ? Compilation.GetSpecialType(SpecialType.System_Void) : null,
                 parameterCount,
                 refKinds);
-            return this.SynthesizedDelegates.GetOrAdd(key, new SynthesizedDelegateValue(this, synthesizedDelegate)).Delegate;
+            return this.AnonymousDelegates.GetOrAdd(key, synthesizedDelegate);
         }
 
         private NamedTypeSymbol ConstructAnonymousDelegateImplementationSymbol(AnonymousDelegatePublicSymbol anonymous, int generation)
@@ -193,30 +186,160 @@ private NamedTypeSymbol ConstructAnonymousDelegateImplementationSymbol(Anonymous
             var typeDescr = anonymous.TypeDescriptor;
             Debug.Assert(typeDescr.Location.IsInSource); // AnonymousDelegateTemplateSymbol requires a location in source for ordering.
 
-            var fields = typeDescr.Fields;
-            bool returnsVoid = fields.Last().Type.IsVoidType();
-            int nTypeArguments = fields.Length - (returnsVoid ? 1 : 0);
-            var refKinds = default(RefKindVector);
-            if (fields.Any(f => f.RefKind != RefKind.None))
+            // If all parameter types and return type are valid type arguments, construct
+            // the delegate type from a generic template. Otherwise, use a non-generic template.
+            if (allValidTypeArguments(typeDescr))
             {
-                refKinds = RefKindVector.Create(nTypeArguments);
+                var fields = typeDescr.Fields;
+                bool returnsVoid = fields.Last().Type.IsVoidType();
+                int nTypeArguments = fields.Length - (returnsVoid ? 1 : 0);
+                var refKinds = default(RefKindVector);
+                if (fields.Any(f => f.RefKind != RefKind.None))
+                {
+                    refKinds = RefKindVector.Create(nTypeArguments);
+                    for (int i = 0; i < nTypeArguments; i++)
+                    {
+                        refKinds[i] = fields[i].RefKind;
+                    }
+                }
+                var typeArgumentsBuilder = ArrayBuilder<TypeWithAnnotations>.GetInstance(nTypeArguments);
                 for (int i = 0; i < nTypeArguments; i++)
                 {
-                    refKinds[i] = fields[i].RefKind;
+                    typeArgumentsBuilder.Add(fields[i].TypeWithAnnotations);
+                }
+                var typeArguments = typeArgumentsBuilder.ToImmutableAndFree();
+                var template = SynthesizeDelegate(parameterCount: fields.Length - 1, refKinds, returnsVoid, generation);
+
+                Debug.Assert(typeArguments.Length == template.TypeParameters.Length);
+                return typeArguments.Length == 0 ?
+                    template :
+                    template.Construct(typeArguments);
+            }
+            else
+            {
+                var typeParameters = GetReferencedTypeParameters(typeDescr);
+                var key = getTemplateKey(typeDescr, typeParameters);
+
+                // Get anonymous delegate template
+                AnonymousDelegateTemplateSymbol? template;
+                if (!this.AnonymousDelegates.TryGetValue(key, out template))
+                {
+                    template = this.AnonymousDelegates.GetOrAdd(key, new AnonymousDelegateTemplateSymbol(this, typeDescr, typeParameters));
+                }
+
+                // Adjust template location if the template is owned by this manager
+                if (ReferenceEquals(template.Manager, this))
+                {
+                    template.AdjustLocation(typeDescr.Location);
                 }
+
+                Debug.Assert(typeParameters.Length == template.TypeParameters.Length);
+                return typeParameters.Length == 0 ?
+                    template :
+                    template.Construct(typeParameters);
+            }
+
+            static bool allValidTypeArguments(AnonymousTypeDescriptor typeDescr)
+            {
+                var fields = typeDescr.Fields;
+                int n = fields.Length;
+                for (int i = 0; i < n - 1; i++)
+                {
+                    if (!isValidTypeArgument(fields[i]))
+                    {
+                        return false;
+                    }
+                }
+                var returnParameter = fields[n - 1];
+                return returnParameter.Type.IsVoidType() || isValidTypeArgument(returnParameter);
+            }
+
+            static bool isValidTypeArgument(AnonymousTypeField field)
+            {
+                return field.Type is { } type &&
+                    !type.IsPointerOrFunctionPointer() &&
+                    !type.IsRestrictedType();
+            }
+
+            static SynthesizedDelegateKey getTemplateKey(AnonymousTypeDescriptor typeDescr, ImmutableArray<TypeParameterSymbol> typeParameters)
+            {
+                if (typeParameters.Length > 0)
+                {
+                    var typeMap = new TypeMap(typeParameters, IndexedTypeParameterSymbol.Take(typeParameters.Length), allowAlpha: true);
+                    typeDescr = typeDescr.SubstituteTypes(typeMap, out bool changed);
+                    Debug.Assert(changed);
+                }
+                return new SynthesizedDelegateKey(typeDescr);
+            }
+        }
+
+        private static ImmutableArray<TypeParameterSymbol> GetReferencedTypeParameters(AnonymousTypeDescriptor typeDescr)
+        {
+            var referenced = PooledHashSet<TypeParameterSymbol>.GetInstance();
+            foreach (var field in typeDescr.Fields)
+            {
+                field.TypeWithAnnotations.VisitType(
+                    type: null,
+                    typeWithAnnotationsPredicate: null,
+                    typePredicate: static (type, referenced, _) =>
+                    {
+                        if (type is TypeParameterSymbol typeParameter)
+                        {
+                            referenced.Add(typeParameter);
+                        }
+                        return false;
+                    },
+                    arg: referenced,
+                    visitCustomModifiers: true);
+            }
+
+            ImmutableArray<TypeParameterSymbol> typeParameters;
+            if (referenced.Count == 0)
+            {
+                typeParameters = ImmutableArray<TypeParameterSymbol>.Empty;
+            }
+            else
+            {
+                var builder = ArrayBuilder<TypeParameterSymbol>.GetInstance();
+                builder.AddRange(referenced);
+                builder.Sort((x, y) => compareTypeParameters(x, y));
+                typeParameters = builder.ToImmutableAndFree();
             }
-            var typeArgumentsBuilder = ArrayBuilder<TypeWithAnnotations>.GetInstance(nTypeArguments);
-            for (int i = 0; i < nTypeArguments; i++)
+            referenced.Free();
+            return typeParameters;
+
+            static int compareTypeParameters(TypeParameterSymbol x, TypeParameterSymbol y)
             {
-                typeArgumentsBuilder.Add(fields[i].TypeWithAnnotations);
+                var xOwner = x.ContainingSymbol;
+                var yOwner = y.ContainingSymbol;
+                if (xOwner.Equals(yOwner))
+                {
+                    return x.Ordinal - y.Ordinal;
+                }
+                else if (isContainedIn(xOwner, yOwner))
+                {
+                    return 1;
+                }
+                else
+                {
+                    Debug.Assert(isContainedIn(yOwner, xOwner));
+                    return -1;
+                }
             }
-            var typeArguments = typeArgumentsBuilder.ToImmutableAndFree();
-            var template = SynthesizeDelegate(parameterCount: fields.Length - 1, refKinds, returnsVoid, generation);
 
-            Debug.Assert(typeArguments.Length == template.TypeParameters.Length);
-            return typeArguments.Length == 0 ?
-                template :
-                template.Construct(typeArguments);
+            static bool isContainedIn(Symbol symbol, Symbol container)
+            {
+                var other = symbol.ContainingSymbol;
+                while (other is { })
+                {
+                    if (other.Equals(container))
+                    {
+                        return true;
+                    }
+                    other = other.ContainingSymbol;
+                }
+                return false;
+            }
         }
 
         /// <summary>
@@ -267,17 +390,16 @@ private AnonymousTypeTemplateSymbol CreatePlaceholderTemplate(Microsoft.CodeAnal
             return new AnonymousTypeTemplateSymbol(this, typeDescr);
         }
 
-        private SynthesizedDelegateValue CreatePlaceholderSynthesizedDelegateValue(string name, RefKindVector refKinds, bool returnsVoid, int parameterCount)
+        private AnonymousDelegateTemplateSymbol CreatePlaceholderSynthesizedDelegateValue(string name, RefKindVector refKinds, bool returnsVoid, int parameterCount)
         {
-            var symbol = new SynthesizedDelegateSymbol(
-               this.Compilation.Assembly.GlobalNamespace,
+            return new AnonymousDelegateTemplateSymbol(
+                this,
                MetadataHelpers.InferTypeArityAndUnmangleMetadataName(name, out _),
                this.System_Object,
                Compilation.GetSpecialType(SpecialType.System_IntPtr),
                returnsVoid ? Compilation.GetSpecialType(SpecialType.System_Void) : null,
                parameterCount,
                refKinds);
-            return new SynthesizedDelegateValue(this, symbol);
         }
 
         /// <summary>
@@ -290,13 +412,16 @@ public void AssignTemplatesNamesAndCompile(MethodCompiler compiler, PEModuleBuil
             // types are available for subsequent edit and continue generations.
             foreach (var key in moduleBeingBuilt.GetPreviousAnonymousTypes())
             {
+                Debug.Assert(!key.IsDelegate);
                 var templateKey = AnonymousTypeDescriptor.ComputeKey(key.Fields, f => f.Name);
                 this.AnonymousTypeTemplates.GetOrAdd(templateKey, k => this.CreatePlaceholderTemplate(key));
             }
 
             // Get all anonymous types owned by this manager
-            var builder = ArrayBuilder<AnonymousTypeTemplateSymbol>.GetInstance();
-            GetCreatedAnonymousTypeTemplates(builder);
+            var anonymousTypes = ArrayBuilder<AnonymousTypeTemplateSymbol>.GetInstance();
+            var anonymousDelegatesWithFixedTypes = ArrayBuilder<AnonymousDelegateTemplateSymbol>.GetInstance();
+            GetCreatedAnonymousTypeTemplates(anonymousTypes);
+            GetCreatedAnonymousDelegatesWithFixedTypes(anonymousDelegatesWithFixedTypes);
 
             // If the collection is not sealed yet we should assign 
             // new indexes to the created anonymous type templates
@@ -324,15 +449,17 @@ public void AssignTemplatesNamesAndCompile(MethodCompiler compiler, PEModuleBuil
                     moduleId = string.Empty;
                 }
 
-                int nextIndex = moduleBeingBuilt.GetNextAnonymousTypeIndex();
-                foreach (var template in builder)
+                int submissionSlotIndex = this.Compilation.GetSubmissionSlotIndex();
+
+                int typeIndex = moduleBeingBuilt.GetNextAnonymousTypeIndex();
+                foreach (var template in anonymousTypes)
                 {
                     string name;
                     int index;
                     if (!moduleBeingBuilt.TryGetAnonymousTypeName(template, out name, out index))
                     {
-                        index = nextIndex++;
-                        name = GeneratedNames.MakeAnonymousTypeTemplateName(index, this.Compilation.GetSubmissionSlotIndex(), moduleId);
+                        index = typeIndex++;
+                        name = GeneratedNames.MakeAnonymousTypeOrDelegateTemplateName(index, submissionSlotIndex, moduleId, isDelegate: false);
                     }
                     // normally it should only happen once, but in case there is a race
                     // NameAndIndex.set has an assert which guarantees that the
@@ -340,47 +467,60 @@ public void AssignTemplatesNamesAndCompile(MethodCompiler compiler, PEModuleBuil
                     template.NameAndIndex = new NameAndIndex(name, index);
                 }
 
+                int delegateIndex = 0;
+                foreach (var template in anonymousDelegatesWithFixedTypes)
+                {
+                    int index = delegateIndex++;
+                    string name = GeneratedNames.MakeAnonymousTypeOrDelegateTemplateName(index, submissionSlotIndex, moduleId, isDelegate: true);
+                    template.NameAndIndex = new NameAndIndex(name, index);
+                }
+
                 this.SealTemplates();
             }
 
-            if (builder.Count > 0 && !ReportMissingOrErroneousSymbols(diagnostics))
+            if (anonymousTypes.Count > 0 && !ReportMissingOrErroneousSymbols(diagnostics))
             {
                 // Process all the templates
-                foreach (var template in builder)
+                foreach (var template in anonymousTypes)
                 {
                     foreach (var method in template.SpecialMembers)
                     {
                         moduleBeingBuilt.AddSynthesizedDefinition(template, method.GetCciAdapter());
                     }
-
                     compiler.Visit(template, null);
                 }
             }
 
-            builder.Free();
+            anonymousTypes.Free();
 
             // Ensure all previous synthesized delegates are included so the
             // types are available for subsequent edit and continue generations.
-            foreach (var key in moduleBeingBuilt.GetPreviousSynthesizedDelegates())
+            foreach (var key in moduleBeingBuilt.GetPreviousAnonymousDelegates())
             {
                 if (GeneratedNames.TryParseSynthesizedDelegateName(key.Name, out var refKinds, out var returnsVoid, out var generation, out var parameterCount))
                 {
                     var delegateKey = new SynthesizedDelegateKey(parameterCount, refKinds, returnsVoid, generation);
-                    this.SynthesizedDelegates.GetOrAdd(delegateKey, (k, args) => CreatePlaceholderSynthesizedDelegateValue(key.Name, args.refKinds, args.returnsVoid, args.parameterCount), (refKinds, returnsVoid, parameterCount));
+                    this.AnonymousDelegates.GetOrAdd(delegateKey, (k, args) => CreatePlaceholderSynthesizedDelegateValue(key.Name, args.refKinds, args.returnsVoid, args.parameterCount), (refKinds, returnsVoid, parameterCount));
                 }
             }
 
-            var synthesizedDelegates = ArrayBuilder<SynthesizedDelegateSymbol>.GetInstance();
-            GetCreatedSynthesizedDelegates(synthesizedDelegates);
-            if (synthesizedDelegates.Count > 0)
+            var anonymousDelegates = ArrayBuilder<AnonymousDelegateTemplateSymbol>.GetInstance();
+            GetCreatedAnonymousDelegates(anonymousDelegates);
+            if (anonymousDelegatesWithFixedTypes.Count > 0 || anonymousDelegates.Count > 0)
             {
                 ReportMissingOrErroneousSymbolsForDelegates(diagnostics);
-                foreach (var synthesizedDelegate in synthesizedDelegates)
+                foreach (var anonymousDelegate in anonymousDelegatesWithFixedTypes)
                 {
-                    compiler.Visit(synthesizedDelegate, null);
+                    compiler.Visit(anonymousDelegate, null);
+                }
+                foreach (var anonymousDelegate in anonymousDelegates)
+                {
+                    compiler.Visit(anonymousDelegate, null);
                 }
             }
-            synthesizedDelegates.Free();
+            anonymousDelegates.Free();
+
+            anonymousDelegatesWithFixedTypes.Free();
         }
 
         /// <summary>
@@ -401,7 +541,25 @@ private void GetCreatedAnonymousTypeTemplates(ArrayBuilder<AnonymousTypeTemplate
                     }
                 }
                 // Sort types and delegates using smallest location
-                builder.Sort(new AnonymousTypeComparer(this.Compilation));
+                builder.Sort(new AnonymousTypeOrDelegateComparer(this.Compilation));
+            }
+        }
+
+        private void GetCreatedAnonymousDelegatesWithFixedTypes(ArrayBuilder<AnonymousDelegateTemplateSymbol> builder)
+        {
+            Debug.Assert(!builder.Any());
+            var anonymousDelegates = _lazyAnonymousDelegates;
+            if (anonymousDelegates != null)
+            {
+                foreach (var template in anonymousDelegates.Values)
+                {
+                    if (ReferenceEquals(template.Manager, this) && template.HasFixedTypes)
+                    {
+                        builder.Add(template);
+                    }
+                }
+                // Sort types and delegates using smallest location
+                builder.Sort(new AnonymousTypeOrDelegateComparer(this.Compilation));
             }
         }
 
@@ -409,45 +567,45 @@ private void GetCreatedAnonymousTypeTemplates(ArrayBuilder<AnonymousTypeTemplate
         /// The set of synthesized delegates created by
         /// this AnonymousTypeManager.
         /// </summary>
-        private void GetCreatedSynthesizedDelegates(ArrayBuilder<SynthesizedDelegateSymbol> builder)
+        private void GetCreatedAnonymousDelegates(ArrayBuilder<AnonymousDelegateTemplateSymbol> builder)
         {
             Debug.Assert(!builder.Any());
-            var delegates = _lazySynthesizedDelegates;
+            var delegates = _lazyAnonymousDelegates;
             if (delegates != null)
             {
                 foreach (var template in delegates.Values)
                 {
-                    if (ReferenceEquals(template.Manager, this))
+                    if (ReferenceEquals(template.Manager, this) && !template.HasFixedTypes)
                     {
-                        builder.Add(template.Delegate);
+                        builder.Add(template);
                     }
                 }
                 builder.Sort(SynthesizedDelegateSymbolComparer.Instance);
             }
         }
 
-        private class SynthesizedDelegateSymbolComparer : IComparer<SynthesizedDelegateSymbol>
+        private class SynthesizedDelegateSymbolComparer : IComparer<AnonymousDelegateTemplateSymbol>
         {
             public static readonly SynthesizedDelegateSymbolComparer Instance = new SynthesizedDelegateSymbolComparer();
 
-            public int Compare(SynthesizedDelegateSymbol x, SynthesizedDelegateSymbol y)
+            public int Compare(AnonymousDelegateTemplateSymbol x, AnonymousDelegateTemplateSymbol y)
             {
                 return x.MetadataName.CompareTo(y.MetadataName);
             }
         }
 
-        internal IReadOnlyDictionary<CodeAnalysis.Emit.SynthesizedDelegateKey, CodeAnalysis.Emit.SynthesizedDelegateValue> GetSynthesizedDelegates()
+        internal IReadOnlyDictionary<CodeAnalysis.Emit.SynthesizedDelegateKey, CodeAnalysis.Emit.SynthesizedDelegateValue> GetAnonymousDelegates()
         {
             var result = new Dictionary<CodeAnalysis.Emit.SynthesizedDelegateKey, CodeAnalysis.Emit.SynthesizedDelegateValue>();
-            var synthesizedDelegates = ArrayBuilder<SynthesizedDelegateSymbol>.GetInstance();
-            GetCreatedSynthesizedDelegates(synthesizedDelegates);
-            foreach (var delegateSymbol in synthesizedDelegates)
+            var anonymousDelegates = ArrayBuilder<AnonymousDelegateTemplateSymbol>.GetInstance();
+            GetCreatedAnonymousDelegates(anonymousDelegates);
+            foreach (var delegateSymbol in anonymousDelegates)
             {
                 var key = new CodeAnalysis.Emit.SynthesizedDelegateKey(delegateSymbol.MetadataName);
                 var value = new CodeAnalysis.Emit.SynthesizedDelegateValue(delegateSymbol.GetCciAdapter());
                 result.Add(key, value);
             }
-            synthesizedDelegates.Free();
+            anonymousDelegates.Free();
             return result;
         }
 
@@ -455,9 +613,7 @@ public int Compare(SynthesizedDelegateSymbol x, SynthesizedDelegateSymbol y)
         {
             var result = new Dictionary<Microsoft.CodeAnalysis.Emit.AnonymousTypeKey, Microsoft.CodeAnalysis.Emit.AnonymousTypeValue>();
             var templates = ArrayBuilder<AnonymousTypeTemplateSymbol>.GetInstance();
-            // Get anonymous types but not synthesized delegates. (Delegate types are
-            // not reused across generations since reuse would add complexity (such
-            // as parsing delegate type names from metadata) without a clear benefit.)
+            // Get anonymous types.
             GetCreatedAnonymousTypeTemplates(templates);
             foreach (AnonymousTypeTemplateSymbol template in templates)
             {
@@ -470,6 +626,24 @@ public int Compare(SynthesizedDelegateSymbol x, SynthesizedDelegateSymbol y)
             return result;
         }
 
+        internal IReadOnlyDictionary<string, AnonymousTypeValue> GetAnonymousDelegatesWithFixedTypes()
+        {
+            var result = new Dictionary<string, AnonymousTypeValue>();
+            var templates = ArrayBuilder<AnonymousDelegateTemplateSymbol>.GetInstance();
+            // Get anonymous delegates with fixed types (distinct from
+            // anonymous delegates from GetAnonymousDelegates() above).
+            GetCreatedAnonymousDelegatesWithFixedTypes(templates);
+            foreach (var template in templates)
+            {
+                var nameAndIndex = template.NameAndIndex;
+                var name = nameAndIndex.Name;
+                var value = new AnonymousTypeValue(name, nameAndIndex.Index, template.GetCciAdapter());
+                result.Add(name, value);
+            }
+            templates.Free();
+            return result;
+        }
+
         /// <summary>
         /// Returns all templates owned by this type manager
         /// </summary>
@@ -484,10 +658,15 @@ internal ImmutableArray<NamedTypeSymbol> GetAllCreatedTemplates()
             builder.AddRange(anonymousTypes);
             anonymousTypes.Free();
 
-            var synthesizedDelegates = ArrayBuilder<SynthesizedDelegateSymbol>.GetInstance();
-            GetCreatedSynthesizedDelegates(synthesizedDelegates);
-            builder.AddRange(synthesizedDelegates);
-            synthesizedDelegates.Free();
+            var anonymousDelegatesWithFixedTypes = ArrayBuilder<AnonymousDelegateTemplateSymbol>.GetInstance();
+            GetCreatedAnonymousDelegatesWithFixedTypes(anonymousDelegatesWithFixedTypes);
+            builder.AddRange(anonymousDelegatesWithFixedTypes);
+            anonymousDelegatesWithFixedTypes.Free();
+
+            var anonymousDelegates = ArrayBuilder<AnonymousDelegateTemplateSymbol>.GetInstance();
+            GetCreatedAnonymousDelegates(anonymousDelegates);
+            builder.AddRange(anonymousDelegates);
+            anonymousDelegates.Free();
 
             return builder.ToImmutableAndFree();
         }
@@ -542,18 +721,18 @@ internal static MethodSymbol TranslateAnonymousTypeMethodSymbol(MethodSymbol met
         }
 
         /// <summary> 
-        /// Comparator being used for stable ordering in anonymous type indices.
+        /// Comparator being used for stable ordering in anonymous type or delegate indices.
         /// </summary>
-        private sealed class AnonymousTypeComparer : IComparer<AnonymousTypeTemplateSymbol>
+        private sealed class AnonymousTypeOrDelegateComparer : IComparer<AnonymousTypeOrDelegateTemplateSymbol>
         {
             private readonly CSharpCompilation _compilation;
 
-            public AnonymousTypeComparer(CSharpCompilation compilation)
+            public AnonymousTypeOrDelegateComparer(CSharpCompilation compilation)
             {
                 _compilation = compilation;
             }
 
-            public int Compare(AnonymousTypeTemplateSymbol x, AnonymousTypeTemplateSymbol y)
+            public int Compare(AnonymousTypeOrDelegateTemplateSymbol x, AnonymousTypeOrDelegateTemplateSymbol y)
             {
                 if ((object)x == (object)y)
                 {
diff --git a/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.DelegateTemplateSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.DelegateTemplateSymbol.cs
new file mode 100644
index 0000000000000..1c2afa6b1e8a7
--- /dev/null
+++ b/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.DelegateTemplateSymbol.cs
@@ -0,0 +1,186 @@
+// 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 System.Collections.Immutable;
+using System.Diagnostics;
+using Microsoft.CodeAnalysis.CSharp.Emit;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.CSharp.Symbols
+{
+    internal sealed partial class AnonymousTypeManager
+    {
+        internal sealed class AnonymousDelegateTemplateSymbol : AnonymousTypeOrDelegateTemplateSymbol
+        {
+            private readonly ImmutableArray<Symbol> _members;
+
+            /// <summary>
+            /// True if any of the delegate parameter types or return type are
+            /// fixed types rather than type parameters.
+            /// </summary>
+            internal readonly bool HasFixedTypes;
+
+            /// <summary>
+            /// A delegate type where the parameter types and return type
+            /// of the delegate signature are type parameters.
+            /// </summary>
+            internal AnonymousDelegateTemplateSymbol(
+                AnonymousTypeManager manager,
+                string name,
+                TypeSymbol objectType,
+                TypeSymbol intPtrType,
+                TypeSymbol? voidReturnTypeOpt,
+                int parameterCount,
+                RefKindVector refKinds)
+                : base(manager, Location.None) // Location is not needed since NameAndIndex is set explicitly below.
+            {
+                Debug.Assert(refKinds.IsNull || parameterCount == refKinds.Capacity - (voidReturnTypeOpt is { } ? 0 : 1));
+
+                HasFixedTypes = false;
+                TypeParameters = createTypeParameters(this, parameterCount, returnsVoid: voidReturnTypeOpt is { });
+                NameAndIndex = new NameAndIndex(name, index: 0);
+
+                var constructor = new SynthesizedDelegateConstructor(this, objectType, intPtrType);
+                // https://github.com/dotnet/roslyn/issues/56808: Synthesized delegates should include BeginInvoke() and EndInvoke().
+                var invokeMethod = createInvokeMethod(this, refKinds, voidReturnTypeOpt);
+                _members = ImmutableArray.Create<Symbol>(constructor, invokeMethod);
+
+                static SynthesizedDelegateInvokeMethod createInvokeMethod(AnonymousDelegateTemplateSymbol containingType, RefKindVector refKinds, TypeSymbol? voidReturnTypeOpt)
+                {
+                    var typeParams = containingType.TypeParameters;
+
+                    int parameterCount = typeParams.Length - (voidReturnTypeOpt is null ? 1 : 0);
+                    var parameterTypes = ArrayBuilder<TypeWithAnnotations>.GetInstance(parameterCount);
+                    var parameterRefKinds = ArrayBuilder<RefKind>.GetInstance(parameterCount);
+                    for (int i = 0; i < parameterCount; i++)
+                    {
+                        parameterTypes.Add(TypeWithAnnotations.Create(typeParams[i]));
+                        parameterRefKinds.Add(refKinds.IsNull ? RefKind.None : refKinds[i]);
+                    }
+
+                    // if we are given Void type the method returns Void, otherwise its return type is the last type parameter of the delegate:
+                    var returnType = TypeWithAnnotations.Create(voidReturnTypeOpt ?? typeParams[parameterCount]);
+                    var returnRefKind = (refKinds.IsNull || voidReturnTypeOpt is { }) ? RefKind.None : refKinds[parameterCount];
+
+                    var method = new SynthesizedDelegateInvokeMethod(containingType, parameterTypes, parameterRefKinds, returnType, returnRefKind);
+                    parameterRefKinds.Free();
+                    parameterTypes.Free();
+                    return method;
+                }
+
+                static ImmutableArray<TypeParameterSymbol> createTypeParameters(AnonymousDelegateTemplateSymbol containingType, int parameterCount, bool returnsVoid)
+                {
+                    var typeParameters = ArrayBuilder<TypeParameterSymbol>.GetInstance(parameterCount + (returnsVoid ? 0 : 1));
+                    for (int i = 0; i < parameterCount; i++)
+                    {
+                        typeParameters.Add(new AnonymousTypeManager.AnonymousTypeParameterSymbol(containingType, i, "T" + (i + 1)));
+                    }
+
+                    if (!returnsVoid)
+                    {
+                        typeParameters.Add(new AnonymousTypeManager.AnonymousTypeParameterSymbol(containingType, parameterCount, "TResult"));
+                    }
+
+                    return typeParameters.ToImmutableAndFree();
+                }
+            }
+
+            /// <summary>
+            /// A delegate type where at least one of the parameter types or return type
+            /// of the delegate signature is a fixed type not a type parameter.
+            /// </summary>
+            internal AnonymousDelegateTemplateSymbol(AnonymousTypeManager manager, AnonymousTypeDescriptor typeDescr, ImmutableArray<TypeParameterSymbol> typeParametersToSubstitute)
+                : base(manager, typeDescr.Location)
+            {
+                // AnonymousTypeOrDelegateComparer requires an actual location.
+                Debug.Assert(SmallestLocation != null);
+                Debug.Assert(SmallestLocation != Location.None);
+
+                HasFixedTypes = true;
+
+                TypeMap typeMap;
+                int typeParameterCount = typeParametersToSubstitute.Length;
+                if (typeParameterCount == 0)
+                {
+                    TypeParameters = ImmutableArray<TypeParameterSymbol>.Empty;
+                    typeMap = TypeMap.Empty;
+                }
+                else
+                {
+                    var typeParameters = ArrayBuilder<TypeParameterSymbol>.GetInstance(typeParameterCount);
+                    for (int i = 0; i < typeParameterCount; i++)
+                    {
+                        typeParameters.Add(new AnonymousTypeParameterSymbol(this, i, "T" + (i + 1)));
+                    }
+                    TypeParameters = typeParameters.ToImmutableAndFree();
+                    typeMap = new TypeMap(typeParametersToSubstitute, TypeParameters, allowAlpha: true);
+                }
+
+                var constructor = new SynthesizedDelegateConstructor(this, manager.System_Object, manager.System_IntPtr);
+                // https://github.com/dotnet/roslyn/issues/56808: Synthesized delegates should include BeginInvoke() and EndInvoke().
+                var invokeMethod = createInvokeMethod(this, typeDescr.Fields, typeMap);
+                _members = ImmutableArray.Create<Symbol>(constructor, invokeMethod);
+
+                static SynthesizedDelegateInvokeMethod createInvokeMethod(
+                    AnonymousDelegateTemplateSymbol containingType,
+                    ImmutableArray<AnonymousTypeField> fields,
+                    TypeMap typeMap)
+                {
+                    var parameterCount = fields.Length - 1;
+                    var parameterTypes = ArrayBuilder<TypeWithAnnotations>.GetInstance(parameterCount);
+                    var parameterRefKinds = ArrayBuilder<RefKind>.GetInstance(parameterCount);
+                    for (int i = 0; i < parameterCount; i++)
+                    {
+                        var parameter = fields[i];
+                        parameterTypes.Add(typeMap.SubstituteType(parameter.Type));
+                        parameterRefKinds.Add(parameter.RefKind);
+                    }
+
+                    var returnParameter = fields[^1];
+                    var returnType = typeMap.SubstituteType(returnParameter.Type);
+                    var returnRefKind = returnParameter.RefKind;
+
+                    var method = new SynthesizedDelegateInvokeMethod(containingType, parameterTypes, parameterRefKinds, returnType, returnRefKind);
+                    parameterRefKinds.Free();
+                    parameterTypes.Free();
+                    return method;
+                }
+            }
+
+            // AnonymousTypeOrDelegateComparer should not be calling this property for delegate
+            // types since AnonymousTypeOrDelegateComparer is only used during emit and we
+            // should only be emitting delegate types inferred from distinct locations in source.
+            internal override string TypeDescriptorKey => throw new System.NotImplementedException();
+
+            public override TypeKind TypeKind => TypeKind.Delegate;
+
+            public override IEnumerable<string> MemberNames => GetMembers().SelectAsArray(member => member.Name);
+
+            public override ImmutableArray<Symbol> GetMembers() => _members;
+
+            public override ImmutableArray<Symbol> GetMembers(string name) => GetMembers().WhereAsArray((member, name) => member.Name == name, name);
+
+            internal override IEnumerable<FieldSymbol> GetFieldsToEmit() => SpecializedCollections.EmptyEnumerable<FieldSymbol>();
+
+            internal override ImmutableArray<NamedTypeSymbol> GetInterfacesToEmit() => ImmutableArray<NamedTypeSymbol>.Empty;
+
+            internal override ImmutableArray<NamedTypeSymbol> InterfacesNoUseSiteDiagnostics(ConsList<TypeSymbol>? basesBeingResolved = null) => ImmutableArray<NamedTypeSymbol>.Empty;
+
+            internal override NamedTypeSymbol BaseTypeNoUseSiteDiagnostics => Manager.System_MulticastDelegate;
+
+            public override ImmutableArray<TypeParameterSymbol> TypeParameters { get; }
+
+            internal override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<SynthesizedAttributeData> attributes)
+            {
+                base.AddSynthesizedAttributes(moduleBuilder, ref attributes);
+
+                var compilation = ContainingSymbol.DeclaringCompilation;
+                AddSynthesizedAttribute(ref attributes,
+                    compilation.TrySynthesizeAttribute(WellKnownMember.System_Runtime_CompilerServices_CompilerGeneratedAttribute__ctor));
+            }
+        }
+    }
+}
diff --git a/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.TemplateSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.TemplateSymbol.cs
index 328d7f9663bcb..3ff50c6ba3fa6 100644
--- a/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.TemplateSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.TemplateSymbol.cs
@@ -8,8 +8,6 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
-using System.Runtime.InteropServices;
-using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Emit;
 using Microsoft.CodeAnalysis.Emit;
 using Microsoft.CodeAnalysis.PooledObjects;
@@ -19,27 +17,12 @@ namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
     internal sealed partial class AnonymousTypeManager
     {
-        internal sealed class NameAndIndex
-        {
-            public NameAndIndex(string name, int index)
-            {
-                this.Name = name;
-                this.Index = index;
-            }
-
-            public readonly string Name;
-            public readonly int Index;
-        }
-
         /// <summary>
         /// Represents an anonymous type 'template' which is a generic type to be used for all 
-        /// anonymous type having the same structure, i.e. the same number of fields and field names.
+        /// anonymous types having the same structure, i.e. the same number of fields and field names.
         /// </summary>
-        internal sealed class AnonymousTypeTemplateSymbol : NamedTypeSymbol
+        internal sealed class AnonymousTypeTemplateSymbol : AnonymousTypeOrDelegateTemplateSymbol
         {
-            /// <summary> Name to be used as metadata name during emit </summary>
-            private NameAndIndex _nameAndIndex;
-
             private readonly ImmutableArray<TypeParameterSymbol> _typeParameters;
             private readonly ImmutableArray<Symbol> _members;
 
@@ -53,26 +36,10 @@ internal sealed class AnonymousTypeTemplateSymbol : NamedTypeSymbol
             /// <summary> Maps member names to symbol(s) </summary>
             private readonly MultiDictionary<string, Symbol> _nameToSymbols = new MultiDictionary<string, Symbol>();
 
-            /// <summary> Anonymous type manager owning this template </summary>
-            internal readonly AnonymousTypeManager Manager;
-
-            /// <summary> Smallest location of the template, actually contains the smallest location 
-            /// of all the anonymous type instances created using this template during EMIT </summary>
-            private Location _smallestLocation;
-
-            /// <summary> Key pf the anonymous type descriptor </summary>
-            internal readonly string TypeDescriptorKey;
-
-            internal AnonymousTypeTemplateSymbol(AnonymousTypeManager manager, AnonymousTypeDescriptor typeDescr)
+            internal AnonymousTypeTemplateSymbol(AnonymousTypeManager manager, AnonymousTypeDescriptor typeDescr) :
+                base(manager, typeDescr.Location)
             {
-                this.Manager = manager;
                 this.TypeDescriptorKey = typeDescr.Key;
-                _smallestLocation = typeDescr.Location;
-
-                // Will be set when the type's metadata is ready to be emitted, 
-                // <anonymous-type>.Name will throw exception if requested
-                // before that moment.
-                _nameAndIndex = null;
 
                 int fieldsCount = typeDescr.Fields.Length;
                 int membersCount = fieldsCount * 3 + 1;
@@ -123,70 +90,17 @@ internal AnonymousTypeTemplateSymbol(AnonymousTypeManager manager, AnonymousType
                     new AnonymousTypeToStringMethodSymbol(this));
             }
 
-            protected override NamedTypeSymbol WithTupleDataCore(TupleExtraData newData)
-                => throw ExceptionUtilities.Unreachable;
-
             internal AnonymousTypeKey GetAnonymousTypeKey()
             {
                 var properties = Properties.SelectAsArray(p => new AnonymousTypeKeyField(p.Name, isKey: false, ignoreCase: false));
                 return new AnonymousTypeKey(properties);
             }
 
-            /// <summary>
-            /// Smallest location of the template, actually contains the smallest location 
-            /// of all the anonymous type instances created using this template during EMIT;
-            /// 
-            /// NOTE: if this property is queried, smallest location must not be null.
-            /// </summary>
-            internal Location SmallestLocation
-            {
-                get
-                {
-                    Debug.Assert(_smallestLocation != null);
-                    return _smallestLocation;
-                }
-            }
+            internal override string TypeDescriptorKey { get; }
 
-            internal NameAndIndex NameAndIndex
-            {
-                get
-                {
-                    return _nameAndIndex;
-                }
-                set
-                {
-                    var oldValue = Interlocked.CompareExchange(ref _nameAndIndex, value, null);
-                    Debug.Assert(oldValue == null ||
-                        ((oldValue.Name == value.Name) && (oldValue.Index == value.Index)));
-                }
-            }
-
-            /// <summary>
-            /// In emit phase every time a created anonymous type is referenced we try to store the lowest 
-            /// location of the template. It will be used for ordering templates and assigning emitted type names.
-            /// </summary>
-            internal void AdjustLocation(Location location)
+            public override TypeKind TypeKind
             {
-                Debug.Assert(location.IsInSource);
-
-                while (true)
-                {
-                    // Loop until we managed to set location OR we detected that we don't need to set it 
-                    // in case 'location' in type descriptor is bigger that the one in smallestLocation
-
-                    Location currentSmallestLocation = _smallestLocation;
-                    if (currentSmallestLocation != null && this.Manager.Compilation.CompareSourceLocations(currentSmallestLocation, location) < 0)
-                    {
-                        // The template's smallest location do not need to be changed
-                        return;
-                    }
-
-                    if (ReferenceEquals(Interlocked.CompareExchange(ref _smallestLocation, location, currentSmallestLocation), currentSmallestLocation))
-                    {
-                        // Changed successfully, proceed to updating the fields
-                        return;
-                    }
-                }
+                get { return TypeKind.Class; }
             }
 
             public override ImmutableArray<Symbol> GetMembers()
@@ -207,15 +121,6 @@ internal override IEnumerable<FieldSymbol> GetFieldsToEmit()
                 }
             }
 
-            internal override bool HasCodeAnalysisEmbeddedAttribute => false;
-
-            internal override bool IsInterpolatedStringHandlerType => false;
-
-            internal override ImmutableArray<TypeWithAnnotations> TypeArgumentsWithAnnotationsNoUseSiteDiagnostics
-            {
-                get { return GetTypeParametersAsTypeArguments(); }
-            }
-
             public override ImmutableArray<Symbol> GetMembers(string name)
             {
                 var symbols = _nameToSymbols[name];
@@ -228,106 +133,6 @@ public override ImmutableArray<Symbol> GetMembers(string name)
                 return builder.ToImmutableAndFree();
             }
 
-            internal override ImmutableArray<Symbol> GetEarlyAttributeDecodingMembers()
-            {
-                return this.GetMembersUnordered();
-            }
-
-            internal override ImmutableArray<Symbol> GetEarlyAttributeDecodingMembers(string name)
-            {
-                return this.GetMembers(name);
-            }
-
-            public override IEnumerable<string> MemberNames
-            {
-                get { return _nameToSymbols.Keys; }
-            }
-
-            public override Symbol ContainingSymbol
-            {
-                get { return this.Manager.Compilation.SourceModule.GlobalNamespace; }
-            }
-
-            public override string Name
-            {
-                get { return _nameAndIndex.Name; }
-            }
-
-            internal override bool HasSpecialName
-            {
-                get { return false; }
-            }
-
-            internal override bool MangleName
-            {
-                get { return this.Arity > 0; }
-            }
-
-            public override int Arity
-            {
-                get { return _typeParameters.Length; }
-            }
-
-            public override bool IsImplicitlyDeclared
-            {
-                get { return true; }
-            }
-
-            public override ImmutableArray<TypeParameterSymbol> TypeParameters
-            {
-                get { return _typeParameters; }
-            }
-
-            public override bool IsAbstract
-            {
-                get { return false; }
-            }
-
-            public sealed override bool IsRefLikeType
-            {
-                get { return false; }
-            }
-
-            public sealed override bool IsReadOnly
-            {
-                get { return false; }
-            }
-
-            public override bool IsSealed
-            {
-                get { return true; }
-            }
-
-            public override bool MightContainExtensionMethods
-            {
-                get { return false; }
-            }
-
-            public sealed override bool AreLocalsZeroed
-            {
-                get { return ContainingModule.AreLocalsZeroed; }
-            }
-
-            public override ImmutableArray<NamedTypeSymbol> GetTypeMembers()
-            {
-                return ImmutableArray<NamedTypeSymbol>.Empty;
-            }
-
-            public override ImmutableArray<NamedTypeSymbol> GetTypeMembers(string name)
-            {
-                return ImmutableArray<NamedTypeSymbol>.Empty;
-            }
-
-            public override ImmutableArray<NamedTypeSymbol> GetTypeMembers(string name, int arity)
-            {
-                return ImmutableArray<NamedTypeSymbol>.Empty;
-            }
-
-            public override Accessibility DeclaredAccessibility
-            {
-                get { return Accessibility.Internal; }
-            }
-
             internal override ImmutableArray<NamedTypeSymbol> InterfacesNoUseSiteDiagnostics(ConsList<TypeSymbol> basesBeingResolved)
             {
                 return ImmutableArray<NamedTypeSymbol>.Empty;
@@ -340,112 +145,16 @@ internal override ImmutableArray<NamedTypeSymbol> GetInterfacesToEmit()
 
             internal override NamedTypeSymbol BaseTypeNoUseSiteDiagnostics => this.Manager.System_Object;
 
-            public override TypeKind TypeKind
-            {
-                get { return TypeKind.Class; }
-            }
-
-            internal override bool IsInterface
-            {
-                get { return false; }
-            }
-
-            public override ImmutableArray<Location> Locations
-            {
-                get { return ImmutableArray<Location>.Empty; }
-            }
-
-            public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences
-            {
-                get
-                {
-                    return ImmutableArray<SyntaxReference>.Empty;
-                }
-            }
-
-            public override bool IsStatic
-            {
-                get { return false; }
-            }
-
-            public override NamedTypeSymbol ConstructedFrom
-            {
-                get { return this; }
-            }
-
-            internal override NamedTypeSymbol GetDeclaredBaseType(ConsList<TypeSymbol> basesBeingResolved)
-            {
-                return this.Manager.System_Object;
-            }
-
-            internal override ImmutableArray<NamedTypeSymbol> GetDeclaredInterfaces(ConsList<TypeSymbol> basesBeingResolved)
-            {
-                return ImmutableArray<NamedTypeSymbol>.Empty;
-            }
-
-            internal override bool ShouldAddWinRTMembers
-            {
-                get { return false; }
-            }
-
-            internal override bool IsWindowsRuntimeImport
-            {
-                get { return false; }
-            }
-
-            internal override bool IsComImport
-            {
-                get { return false; }
-            }
-
-            internal sealed override ObsoleteAttributeData ObsoleteAttributeData
-            {
-                get { return null; }
-            }
-
-            internal override TypeLayout Layout
-            {
-                get { return default(TypeLayout); }
-            }
-
-            internal override CharSet MarshallingCharSet
-            {
-                get { return DefaultMarshallingCharSet; }
-            }
-
-            public override bool IsSerializable
-            {
-                get { return false; }
-            }
-
-            internal override bool HasDeclarativeSecurity
-            {
-                get { return false; }
-            }
-
-            internal override IEnumerable<Microsoft.Cci.SecurityAttribute> GetSecurityInformation()
-            {
-                throw ExceptionUtilities.Unreachable;
-            }
-
-            internal override ImmutableArray<string> GetAppliedConditionalSymbols()
+            public override ImmutableArray<TypeParameterSymbol> TypeParameters
             {
-                return ImmutableArray<string>.Empty;
+                get { return _typeParameters; }
             }
 
-            internal override AttributeUsageInfo GetAttributeUsageInfo()
+            public override IEnumerable<string> MemberNames
             {
-                return AttributeUsageInfo.Null;
+                get { return _nameToSymbols.Keys; }
             }
 
-            internal sealed override NamedTypeSymbol AsNativeInteger() => throw ExceptionUtilities.Unreachable;
-
-            internal sealed override NamedTypeSymbol NativeIntegerUnderlyingType => null;
-
-            internal override bool IsRecord => false;
-
-            internal override bool IsRecordStruct => false;
-
             internal override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<SynthesizedAttributeData> attributes)
             {
                 base.AddSynthesizedAttributes(moduleBuilder, ref attributes);
@@ -511,13 +220,6 @@ private SynthesizedAttributeData TrySynthesizeDebuggerDisplayAttribute()
                                         WellKnownMember.System_Diagnostics_DebuggerDisplayAttribute__Type,
                                         new TypedConstant(Manager.System_String, TypedConstantKind.Primitive, "<Anonymous Type>"))));
             }
-
-            internal override bool HasPossibleWellKnownCloneMethod() => false;
-
-            internal override IEnumerable<(MethodSymbol Body, MethodSymbol Implemented)> SynthesizedInterfaceMethodImpls()
-            {
-                return SpecializedCollections.EmptyEnumerable<(MethodSymbol Body, MethodSymbol Implemented)>();
-            }
         }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.TypeOrDelegateTemplateSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.TypeOrDelegateTemplateSymbol.cs
new file mode 100644
index 0000000000000..7f335aea333b8
--- /dev/null
+++ b/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.TypeOrDelegateTemplateSymbol.cs
@@ -0,0 +1,321 @@
+// 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 System.Collections.Immutable;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Threading;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.CSharp.Symbols
+{
+    internal sealed partial class AnonymousTypeManager
+    {
+        internal sealed class NameAndIndex
+        {
+            public NameAndIndex(string name, int index)
+            {
+                this.Name = name;
+                this.Index = index;
+            }
+
+            public readonly string Name;
+            public readonly int Index;
+        }
+
+        internal abstract class AnonymousTypeOrDelegateTemplateSymbol : NamedTypeSymbol
+        {
+            /// <summary> Name to be used as metadata name during emit </summary>
+            private NameAndIndex? _nameAndIndex;
+
+            /// <summary> Smallest location of the template, actually contains the smallest location 
+            /// of all the anonymous type instances created using this template during EMIT </summary>
+            private Location _smallestLocation;
+
+            /// <summary> Anonymous type manager owning this template </summary>
+            internal readonly AnonymousTypeManager Manager;
+
+            internal AnonymousTypeOrDelegateTemplateSymbol(AnonymousTypeManager manager, Location location)
+            {
+                this.Manager = manager;
+                _smallestLocation = location;
+
+                // Will be set when the type's metadata is ready to be emitted, 
+                // <anonymous-type>.Name will throw exception if requested
+                // before that moment.
+                _nameAndIndex = null;
+            }
+
+            internal abstract string TypeDescriptorKey { get; }
+
+            protected sealed override NamedTypeSymbol WithTupleDataCore(TupleExtraData newData)
+                => throw ExceptionUtilities.Unreachable;
+
+            /// <summary>
+            /// Smallest location of the template, actually contains the smallest location 
+            /// of all the anonymous type instances created using this template during EMIT;
+            /// 
+            /// NOTE: if this property is queried, smallest location must not be null.
+            /// </summary>
+            internal Location SmallestLocation
+            {
+                get
+                {
+                    Debug.Assert(_smallestLocation != null);
+                    return _smallestLocation;
+                }
+            }
+
+            internal NameAndIndex? NameAndIndex
+            {
+                get
+                {
+                    return _nameAndIndex;
+                }
+                set
+                {
+                    Debug.Assert(value != null);
+                    var oldValue = Interlocked.CompareExchange(ref _nameAndIndex, value, null);
+                    Debug.Assert(oldValue == null ||
+                        ((oldValue.Name == value.Name) && (oldValue.Index == value.Index)));
+                }
+            }
+
+            /// <summary>
+            /// In emit phase every time a created anonymous type is referenced we try to store the lowest 
+            /// location of the template. It will be used for ordering templates and assigning emitted type names.
+            /// </summary>
+            internal void AdjustLocation(Location location)
+            {
+                Debug.Assert(location.IsInSource);
+
+                while (true)
+                {
+                    // Loop until we managed to set location OR we detected that we don't need to set it 
+                    // in case 'location' in type descriptor is bigger that the one in smallestLocation
+
+                    Location currentSmallestLocation = _smallestLocation;
+                    if (currentSmallestLocation != null && this.Manager.Compilation.CompareSourceLocations(currentSmallestLocation, location) < 0)
+                    {
+                        // The template's smallest location do not need to be changed
+                        return;
+                    }
+
+                    if (ReferenceEquals(Interlocked.CompareExchange(ref _smallestLocation, location, currentSmallestLocation), currentSmallestLocation))
+                    {
+                        // Changed successfully, proceed to updating the fields
+                        return;
+                    }
+                }
+            }
+
+            internal sealed override bool HasCodeAnalysisEmbeddedAttribute => false;
+
+            internal sealed override bool IsInterpolatedStringHandlerType => false;
+
+            internal sealed override ImmutableArray<Symbol> GetEarlyAttributeDecodingMembers()
+            {
+                return this.GetMembersUnordered();
+            }
+
+            internal sealed override ImmutableArray<Symbol> GetEarlyAttributeDecodingMembers(string name)
+            {
+                return this.GetMembers(name);
+            }
+
+            public sealed override Symbol ContainingSymbol
+            {
+                get { return this.Manager.Compilation.SourceModule.GlobalNamespace; }
+            }
+
+            public sealed override string Name
+            {
+                get { return _nameAndIndex!.Name; }
+            }
+
+            internal sealed override bool HasSpecialName
+            {
+                get { return false; }
+            }
+
+            public sealed override bool IsImplicitlyDeclared
+            {
+                get { return true; }
+            }
+
+            public sealed override bool IsAbstract
+            {
+                get { return false; }
+            }
+
+            public sealed override bool IsRefLikeType
+            {
+                get { return false; }
+            }
+
+            public sealed override bool IsReadOnly
+            {
+                get { return false; }
+            }
+
+            public sealed override bool IsSealed
+            {
+                get { return true; }
+            }
+
+            public sealed override bool MightContainExtensionMethods
+            {
+                get { return false; }
+            }
+
+            public sealed override bool AreLocalsZeroed
+            {
+                get { return ContainingModule.AreLocalsZeroed; }
+            }
+
+            public sealed override ImmutableArray<NamedTypeSymbol> GetTypeMembers()
+            {
+                return ImmutableArray<NamedTypeSymbol>.Empty;
+            }
+
+            public sealed override ImmutableArray<NamedTypeSymbol> GetTypeMembers(string name)
+            {
+                return ImmutableArray<NamedTypeSymbol>.Empty;
+            }
+
+            public sealed override ImmutableArray<NamedTypeSymbol> GetTypeMembers(string name, int arity)
+            {
+                return ImmutableArray<NamedTypeSymbol>.Empty;
+            }
+
+            public sealed override Accessibility DeclaredAccessibility
+            {
+                get { return Accessibility.Internal; }
+            }
+
+            internal sealed override bool IsInterface
+            {
+                get { return false; }
+            }
+
+            public sealed override ImmutableArray<Location> Locations
+            {
+                get { return ImmutableArray<Location>.Empty; }
+            }
+
+            public sealed override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences
+            {
+                get { return ImmutableArray<SyntaxReference>.Empty; }
+            }
+
+            public sealed override bool IsStatic
+            {
+                get { return false; }
+            }
+
+            public sealed override NamedTypeSymbol ConstructedFrom
+            {
+                get { return this; }
+            }
+
+            internal abstract override NamedTypeSymbol BaseTypeNoUseSiteDiagnostics { get; }
+
+            internal sealed override NamedTypeSymbol GetDeclaredBaseType(ConsList<TypeSymbol> basesBeingResolved)
+            {
+                return this.Manager.System_Object;
+            }
+
+            internal sealed override ImmutableArray<NamedTypeSymbol> GetDeclaredInterfaces(ConsList<TypeSymbol> basesBeingResolved)
+            {
+                return ImmutableArray<NamedTypeSymbol>.Empty;
+            }
+
+            internal sealed override bool MangleName
+            {
+                get { return this.Arity > 0; }
+            }
+
+            internal sealed override ImmutableArray<TypeWithAnnotations> TypeArgumentsWithAnnotationsNoUseSiteDiagnostics
+            {
+                get { return GetTypeParametersAsTypeArguments(); }
+            }
+
+            public sealed override int Arity
+            {
+                get { return TypeParameters.Length; }
+            }
+
+            internal sealed override bool ShouldAddWinRTMembers
+            {
+                get { return false; }
+            }
+
+            internal sealed override bool IsWindowsRuntimeImport
+            {
+                get { return false; }
+            }
+
+            internal sealed override bool IsComImport
+            {
+                get { return false; }
+            }
+
+            internal sealed override ObsoleteAttributeData? ObsoleteAttributeData
+            {
+                get { return null; }
+            }
+
+            internal sealed override TypeLayout Layout
+            {
+                get { return default(TypeLayout); }
+            }
+
+            internal sealed override CharSet MarshallingCharSet
+            {
+                get { return DefaultMarshallingCharSet; }
+            }
+
+            public sealed override bool IsSerializable
+            {
+                get { return false; }
+            }
+
+            internal sealed override bool HasDeclarativeSecurity
+            {
+                get { return false; }
+            }
+
+            internal sealed override IEnumerable<Microsoft.Cci.SecurityAttribute> GetSecurityInformation()
+            {
+                throw ExceptionUtilities.Unreachable;
+            }
+
+            internal sealed override ImmutableArray<string> GetAppliedConditionalSymbols()
+            {
+                return ImmutableArray<string>.Empty;
+            }
+
+            internal sealed override AttributeUsageInfo GetAttributeUsageInfo()
+            {
+                return AttributeUsageInfo.Null;
+            }
+
+            internal sealed override NamedTypeSymbol AsNativeInteger() => throw ExceptionUtilities.Unreachable;
+
+            internal sealed override NamedTypeSymbol? NativeIntegerUnderlyingType => null;
+
+            internal sealed override bool IsRecord => false;
+
+            internal sealed override bool IsRecordStruct => false;
+
+            internal sealed override bool HasPossibleWellKnownCloneMethod() => false;
+
+            internal sealed override IEnumerable<(MethodSymbol Body, MethodSymbol Implemented)> SynthesizedInterfaceMethodImpls()
+            {
+                return SpecializedCollections.EmptyEnumerable<(MethodSymbol Body, MethodSymbol Implemented)>();
+            }
+        }
+    }
+}
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNames.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNames.cs
index 51a70440192ed..f931a3d46cb7b 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNames.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNames.cs
@@ -52,9 +52,9 @@ internal static string MakeLambdaDisplayClassName(int methodOrdinal, int generat
             return MakeMethodScopedSynthesizedName(GeneratedNameKind.LambdaDisplayClass, methodOrdinal, generation, suffix: "DisplayClass", entityOrdinal: closureOrdinal, entityGeneration: closureGeneration);
         }
 
-        internal static string MakeAnonymousTypeTemplateName(int index, int submissionSlotIndex, string moduleId)
+        internal static string MakeAnonymousTypeOrDelegateTemplateName(int index, int submissionSlotIndex, string moduleId, bool isDelegate)
         {
-            var name = "<" + moduleId + ">f__AnonymousType" + StringExtensions.GetNumeral(index);
+            var name = "<" + moduleId + (isDelegate ? ">f__AnonymousDelegate" : ">f__AnonymousType") + StringExtensions.GetNumeral(index);
             if (submissionSlotIndex >= 0)
             {
                 name += "#" + StringExtensions.GetNumeral(submissionSlotIndex);
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedContainer.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedContainer.cs
index e55fc29a04353..2d1937a69877a 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedContainer.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedContainer.cs
@@ -16,22 +16,13 @@
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
     /// <summary>
-    /// A container synthesized for a lambda, iterator method, async method, or dynamic-sites.
+    /// A container synthesized for a lambda, iterator method, or async method.
     /// </summary>
     internal abstract class SynthesizedContainer : NamedTypeSymbol
     {
         private readonly ImmutableArray<TypeParameterSymbol> _typeParameters;
         private readonly ImmutableArray<TypeParameterSymbol> _constructedFromTypeParameters;
 
-        protected SynthesizedContainer(string name, int parameterCount, bool returnsVoid)
-        {
-            Debug.Assert(name != null);
-            Name = name;
-            TypeMap = TypeMap.Empty;
-            _typeParameters = CreateTypeParameters(parameterCount, returnsVoid);
-            _constructedFromTypeParameters = default(ImmutableArray<TypeParameterSymbol>);
-        }
-
         protected SynthesizedContainer(string name, MethodSymbol containingMethod)
         {
             Debug.Assert(name != null);
@@ -58,22 +49,6 @@ protected SynthesizedContainer(string name, ImmutableArray<TypeParameterSymbol>
             TypeMap = typeMap;
         }
 
-        private ImmutableArray<TypeParameterSymbol> CreateTypeParameters(int parameterCount, bool returnsVoid)
-        {
-            var typeParameters = ArrayBuilder<TypeParameterSymbol>.GetInstance(parameterCount + (returnsVoid ? 0 : 1));
-            for (int i = 0; i < parameterCount; i++)
-            {
-                typeParameters.Add(new AnonymousTypeManager.AnonymousTypeParameterSymbol(this, i, "T" + (i + 1)));
-            }
-
-            if (!returnsVoid)
-            {
-                typeParameters.Add(new AnonymousTypeManager.AnonymousTypeParameterSymbol(this, parameterCount, "TResult"));
-            }
-
-            return typeParameters.ToImmutableAndFree();
-        }
-
         internal TypeMap TypeMap { get; }
 
         internal virtual MethodSymbol Constructor => null;
@@ -102,9 +77,6 @@ internal override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, r
         protected override NamedTypeSymbol WithTupleDataCore(TupleExtraData newData)
             => throw ExceptionUtilities.Unreachable;
 
-        /// <summary>
-        /// Note: Can be default if this SynthesizedContainer was constructed with <see cref="SynthesizedContainer(string, int, bool)"/>
-        /// </summary>
         internal ImmutableArray<TypeParameterSymbol> ConstructedFromTypeParameters => _constructedFromTypeParameters;
 
         public sealed override ImmutableArray<TypeParameterSymbol> TypeParameters => _typeParameters;
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedDelegateSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedDelegateSymbol.cs
index 3f312257b1ce5..e5c17ffc70887 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedDelegateSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedDelegateSymbol.cs
@@ -5,118 +5,11 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.Diagnostics;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
-    /// <summary>
-    /// Dynamic call-site delegate, for call-sites that do not
-    /// match System.Action or System.Func signatures.
-    /// </summary>
-    internal sealed class SynthesizedDelegateSymbol : SynthesizedContainer
-    {
-        private readonly NamespaceOrTypeSymbol _containingSymbol;
-        private readonly MethodSymbol _constructor;
-        private readonly MethodSymbol _invoke;
-
-        public SynthesizedDelegateSymbol(
-            NamespaceOrTypeSymbol containingSymbol,
-            string name,
-            TypeSymbol objectType,
-            TypeSymbol intPtrType,
-            TypeSymbol? voidReturnTypeOpt,
-            int parameterCount,
-            RefKindVector refKinds)
-            : base(name, parameterCount, returnsVoid: voidReturnTypeOpt is not null)
-        {
-            Debug.Assert(refKinds.IsNull || parameterCount == refKinds.Capacity - (voidReturnTypeOpt is { } ? 0 : 1));
-
-            _containingSymbol = containingSymbol;
-            _constructor = new SynthesizedDelegateConstructor(this, objectType, intPtrType);
-            _invoke = createInvokeMethod(this, refKinds, voidReturnTypeOpt);
-
-            static SynthesizedDelegateInvokeMethod createInvokeMethod(SynthesizedDelegateSymbol containingType, RefKindVector refKinds, TypeSymbol? voidReturnTypeOpt)
-            {
-                var typeParams = containingType.TypeParameters;
-
-                int parameterCount = typeParams.Length - (voidReturnTypeOpt is null ? 1 : 0);
-                var parameterTypes = ArrayBuilder<TypeWithAnnotations>.GetInstance(parameterCount);
-                var parameterRefKinds = ArrayBuilder<RefKind>.GetInstance(parameterCount);
-                for (int i = 0; i < parameterCount; i++)
-                {
-                    parameterTypes.Add(TypeWithAnnotations.Create(typeParams[i]));
-                    parameterRefKinds.Add(refKinds.IsNull ? RefKind.None : refKinds[i]);
-                }
-
-                // if we are given Void type the method returns Void, otherwise its return type is the last type parameter of the delegate:
-                var returnType = TypeWithAnnotations.Create(voidReturnTypeOpt ?? typeParams[parameterCount]);
-                var returnRefKind = (refKinds.IsNull || voidReturnTypeOpt is { }) ? RefKind.None : refKinds[parameterCount];
-
-                var method = new SynthesizedDelegateInvokeMethod(containingType, parameterTypes, parameterRefKinds, returnType, returnRefKind);
-                parameterRefKinds.Free();
-                parameterTypes.Free();
-                return method;
-            }
-        }
-
-        public override Symbol ContainingSymbol
-        {
-            get { return _containingSymbol; }
-        }
-
-        public override TypeKind TypeKind
-        {
-            get { return TypeKind.Delegate; }
-        }
-
-        internal override MethodSymbol Constructor
-        {
-            get { return _constructor; }
-        }
-
-        public override IEnumerable<string> MemberNames
-        {
-            get { return new[] { _constructor.Name, _invoke.Name }; }
-        }
-
-        public override ImmutableArray<Symbol> GetMembers()
-        {
-            return ImmutableArray.Create<Symbol>(_constructor, _invoke);
-        }
-
-        public override ImmutableArray<Symbol> GetMembers(string name)
-        {
-            return
-                (name == _constructor.Name) ? ImmutableArray.Create<Symbol>(_constructor) :
-                (name == _invoke.Name) ? ImmutableArray.Create<Symbol>(_invoke) :
-                ImmutableArray<Symbol>.Empty;
-        }
-
-        public override Accessibility DeclaredAccessibility
-        {
-            get { return Accessibility.Internal; }
-        }
-
-        public override bool IsSealed
-        {
-            get { return true; }
-        }
-
-        internal override NamedTypeSymbol BaseTypeNoUseSiteDiagnostics
-            => ContainingAssembly.GetSpecialType(SpecialType.System_MulticastDelegate);
-
-        public sealed override bool AreLocalsZeroed
-        {
-            get { throw ExceptionUtilities.Unreachable; }
-        }
-
-        internal override bool IsRecord => false;
-        internal override bool IsRecordStruct => false;
-        internal override bool HasPossibleWellKnownCloneMethod() => false;
-    }
-
     internal sealed class SynthesizedDelegateConstructor : SynthesizedInstanceConstructor
     {
         private readonly ImmutableArray<ParameterSymbol> _parameters;
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
index 0c143f283af8f..ec9e560cac3c7 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
@@ -407,6 +407,11 @@
         <target state="translated">Příkaz nemůže začínat na else.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_EncUpdateFailedDelegateTypeChanged">
+        <source>Cannot update because an inferred delegate type has changed.</source>
+        <target state="new">Cannot update because an inferred delegate type has changed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_EntryPointCannotBeUnmanagedCallersOnly">
         <source>Application entry points cannot be attributed with 'UnmanagedCallersOnly'.</source>
         <target state="translated">Vstupní body aplikací nemůžou mít atribut UnmanagedCallersOnly.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
index 20f5cf9246ee6..149f82bf4d4a3 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
@@ -407,6 +407,11 @@
         <target state="translated">Eine Anweisung kann nicht mit "else" beginnen.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_EncUpdateFailedDelegateTypeChanged">
+        <source>Cannot update because an inferred delegate type has changed.</source>
+        <target state="new">Cannot update because an inferred delegate type has changed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_EntryPointCannotBeUnmanagedCallersOnly">
         <source>Application entry points cannot be attributed with 'UnmanagedCallersOnly'.</source>
         <target state="translated">Anwendungseinstiegspunkte können nicht mit dem Attribut "UnmanagedCallersOnly" versehen werden.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
index e777231f2d8c5..c3b78832301d3 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
@@ -407,6 +407,11 @@
         <target state="translated">“else” no puede iniciar una instrucción.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_EncUpdateFailedDelegateTypeChanged">
+        <source>Cannot update because an inferred delegate type has changed.</source>
+        <target state="new">Cannot update because an inferred delegate type has changed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_EntryPointCannotBeUnmanagedCallersOnly">
         <source>Application entry points cannot be attributed with 'UnmanagedCallersOnly'.</source>
         <target state="translated">Los puntos de entrada de la aplicación no se pueden atribuir con "UnmanagedCallersOnly".</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
index a1ec5ce86a71e..d22a3a148793f 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
@@ -407,6 +407,11 @@
         <target state="translated">'else' ne peut pas démarrer d'instruction.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_EncUpdateFailedDelegateTypeChanged">
+        <source>Cannot update because an inferred delegate type has changed.</source>
+        <target state="new">Cannot update because an inferred delegate type has changed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_EntryPointCannotBeUnmanagedCallersOnly">
         <source>Application entry points cannot be attributed with 'UnmanagedCallersOnly'.</source>
         <target state="translated">Les points d'entrée d'application ne peuvent pas être attribués avec 'UnmanagedCallersOnly'.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
index 3099d6cfab162..477da70abd8da 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
@@ -407,6 +407,11 @@
         <target state="translated">Un'istruzione non può iniziare con 'else'.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_EncUpdateFailedDelegateTypeChanged">
+        <source>Cannot update because an inferred delegate type has changed.</source>
+        <target state="new">Cannot update because an inferred delegate type has changed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_EntryPointCannotBeUnmanagedCallersOnly">
         <source>Application entry points cannot be attributed with 'UnmanagedCallersOnly'.</source>
         <target state="translated">Non è possibile aggiungere ai punti di ingresso dell'applicazione l'attributo 'UnmanagedCallersOnly'.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
index 5ded70e499670..db71f23a2a21a 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
@@ -407,6 +407,11 @@
         <target state="translated">'else' でステートメントを開始することはできません。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_EncUpdateFailedDelegateTypeChanged">
+        <source>Cannot update because an inferred delegate type has changed.</source>
+        <target state="new">Cannot update because an inferred delegate type has changed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_EntryPointCannotBeUnmanagedCallersOnly">
         <source>Application entry points cannot be attributed with 'UnmanagedCallersOnly'.</source>
         <target state="translated">アプリケーションのエントリ ポイントに 'UnmanagedCallersOnly' 属性を設定することはできません。</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
index 0467b6f969aa3..764c202b48c21 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
@@ -407,6 +407,11 @@
         <target state="translated">'else'로 문을 시작할 수 없습니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_EncUpdateFailedDelegateTypeChanged">
+        <source>Cannot update because an inferred delegate type has changed.</source>
+        <target state="new">Cannot update because an inferred delegate type has changed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_EntryPointCannotBeUnmanagedCallersOnly">
         <source>Application entry points cannot be attributed with 'UnmanagedCallersOnly'.</source>
         <target state="translated">애플리케이션 진입점에는 'UnmanagedCallersOnly' 특성을 지정할 수 없습니다.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
index 3d05f013a9aff..2976cc0eaad15 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
@@ -407,6 +407,11 @@
         <target state="translated">Instrukcja nie może rozpoczynać się od elementu „else”.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_EncUpdateFailedDelegateTypeChanged">
+        <source>Cannot update because an inferred delegate type has changed.</source>
+        <target state="new">Cannot update because an inferred delegate type has changed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_EntryPointCannotBeUnmanagedCallersOnly">
         <source>Application entry points cannot be attributed with 'UnmanagedCallersOnly'.</source>
         <target state="translated">Punkty wejścia aplikacji nie mogą mieć atrybutu „UnmanagedCallersOnly”.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
index be99a4c58d7cb..06a92d1c4a239 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
@@ -407,6 +407,11 @@
         <target state="translated">'else' não pode iniciar uma instrução.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_EncUpdateFailedDelegateTypeChanged">
+        <source>Cannot update because an inferred delegate type has changed.</source>
+        <target state="new">Cannot update because an inferred delegate type has changed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_EntryPointCannotBeUnmanagedCallersOnly">
         <source>Application entry points cannot be attributed with 'UnmanagedCallersOnly'.</source>
         <target state="translated">Os pontos de entrada do aplicativo não podem ser atribuídos com 'UnmanagedCallersOnly'.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
index e385c0a76ab08..2b6b46e7bbb05 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
@@ -407,6 +407,11 @@
         <target state="translated">"else" не может запускать оператор.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_EncUpdateFailedDelegateTypeChanged">
+        <source>Cannot update because an inferred delegate type has changed.</source>
+        <target state="new">Cannot update because an inferred delegate type has changed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_EntryPointCannotBeUnmanagedCallersOnly">
         <source>Application entry points cannot be attributed with 'UnmanagedCallersOnly'.</source>
         <target state="translated">Точки входа приложения не могут иметь атрибут "UnmanagedCallersOnly".</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
index da8185fac7dfd..e17eea7c9feb4 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
@@ -407,6 +407,11 @@
         <target state="translated">'else' bir deyim başlatamaz.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_EncUpdateFailedDelegateTypeChanged">
+        <source>Cannot update because an inferred delegate type has changed.</source>
+        <target state="new">Cannot update because an inferred delegate type has changed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_EntryPointCannotBeUnmanagedCallersOnly">
         <source>Application entry points cannot be attributed with 'UnmanagedCallersOnly'.</source>
         <target state="translated">Uygulama giriş noktaları 'UnmanagedCallersOnly' ile ilişkilendirilemez.</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
index 9df925ab44fa9..b64286a6a6254 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
@@ -407,6 +407,11 @@
         <target state="translated">"else" 不能用在语句的开头。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_EncUpdateFailedDelegateTypeChanged">
+        <source>Cannot update because an inferred delegate type has changed.</source>
+        <target state="new">Cannot update because an inferred delegate type has changed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_EntryPointCannotBeUnmanagedCallersOnly">
         <source>Application entry points cannot be attributed with 'UnmanagedCallersOnly'.</source>
         <target state="translated">无法使用 "UnmanagedCallersOnly" 对应用程序入口点进行特性化。</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
index ae3bf3dadf94b..cc8b09c93001a 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
@@ -407,6 +407,11 @@
         <target state="translated">'else' 無法開始陳述式。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_EncUpdateFailedDelegateTypeChanged">
+        <source>Cannot update because an inferred delegate type has changed.</source>
+        <target state="new">Cannot update because an inferred delegate type has changed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_EntryPointCannotBeUnmanagedCallersOnly">
         <source>Application entry points cannot be attributed with 'UnmanagedCallersOnly'.</source>
         <target state="translated">無法使用 'UnmanagedCallersOnly' 將應用程式進入點屬性化。</target>
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs
index 6bb089c31cd58..4e08586668fdf 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs
@@ -1185,7 +1185,7 @@ void F()
         }
 
         [Fact]
-        public void Lambda_SynthesizedDelegate()
+        public void Lambda_SynthesizedDelegate_01()
         {
             var source0 = MarkedSource(@"
 class C
@@ -1273,6 +1273,354 @@ void F()
                 "C.<>c: {<>9__0_0, <>9__0_1#1, <>9__0_2#1, <F>b__0_0, <F>b__0_1#1, <F>b__0_2#1}");
         }
 
+        [Fact]
+        public void Lambda_SynthesizedDelegate_02()
+        {
+            var source0 = MarkedSource(
+@"class C
+{
+    static unsafe void F()
+    {
+        var x = <N:0>(int* a, int b) => *a</N:0>;
+    }
+}");
+            var source1 = MarkedSource(
+@"class C
+{
+    static unsafe void F()
+    {
+        var x = <N:0>(int* a, int b) => b</N:0>;
+        var y = <N:1>(int a, int* b) => a</N:1>;
+        var z = <N:2>(int* a) => a</N:2>;
+    }
+}");
+            var source2 = MarkedSource(
+@"class C
+{
+    static unsafe void F()
+    {
+        var x = <N:0>(int* a, int b) => b</N:0>;
+        var y = <N:1>(int a, int* b) => *b</N:1>;
+        var z = <N:2>(int* a) => a</N:2>;
+    }
+}");
+            var source3 = MarkedSource(
+@"class C
+{
+    static unsafe void F()
+    {
+        var x = <N:0>(int* a, int b) => b</N:0>;
+        var y = <N:1>(int a, int* b) => b</N:1>;
+        var z = <N:2>(int* a) => a</N:2>;
+    }
+}");
+
+            var compilation0 = CreateCompilation(source0.Tree, options: ComSafeDebugDll.WithAllowUnsafe(true).WithMetadataImportOptions(MetadataImportOptions.All));
+            var compilation1 = compilation0.WithSource(source1.Tree);
+            var compilation2 = compilation1.WithSource(source2.Tree);
+            var compilation3 = compilation2.WithSource(source3.Tree);
+
+            var v0 = CompileAndVerify(compilation0, verify: Verification.Skipped);
+            var md0 = ModuleMetadata.CreateFromImage(v0.EmittedAssemblyData);
+            var reader0 = md0.MetadataReader;
+
+            var method0 = compilation0.GetMember<MethodSymbol>("C.F");
+            var method1 = compilation1.GetMember<MethodSymbol>("C.F");
+            var method2 = compilation2.GetMember<MethodSymbol>("C.F");
+            var method3 = compilation3.GetMember<MethodSymbol>("C.F");
+
+            var generation0 = EmitBaseline.CreateInitialBaseline(md0, v0.CreateSymReader().GetEncMethodDebugInfo);
+
+            CheckNames(reader0, reader0.GetTypeDefNames(), "<Module>", "<>f__AnonymousDelegate0", "C", "<>c");
+            CheckNames(reader0, reader0.GetMethodDefNames(), ".ctor", "Invoke", "F", ".ctor", ".cctor", ".ctor", "<F>b__0_0");
+
+            var diff1 = compilation1.EmitDifference(
+                generation0,
+                ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1), preserveLocalVariables: true)));
+
+            // Verify delta metadata contains expected rows.
+            using var md1 = diff1.GetMetadata();
+            var reader1 = md1.Reader;
+            var readers = new[] { reader0, reader1 };
+
+            EncValidation.VerifyModuleMvid(1, reader0, reader1);
+
+            CheckNames(readers, reader1.GetTypeDefNames(), "<>f__AnonymousDelegate1", "<>f__AnonymousDelegate2");
+            CheckNames(readers, reader1.GetMethodDefNames(), "F", "<F>b__0_0", ".ctor", "Invoke", ".ctor", "Invoke", "<F>b__0_1#1", "<F>b__0_2#1");
+
+            diff1.VerifySynthesizedMembers(
+                "C: {<>c}",
+                "C.<>c: {<>9__0_0, <>9__0_1#1, <>9__0_2#1, <F>b__0_0, <F>b__0_1#1, <F>b__0_2#1}");
+
+            var diff2 = compilation2.EmitDifference(
+                diff1.NextGeneration,
+                ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1, method2, GetSyntaxMapFromMarkers(source1, source2), preserveLocalVariables: true)));
+
+            using var md2 = diff2.GetMetadata();
+            var reader2 = md2.Reader;
+            readers = new[] { reader0, reader1, reader2 };
+
+            EncValidation.VerifyModuleMvid(2, reader1, reader2);
+
+            CheckNames(readers, reader2.GetTypeDefNames());
+            CheckNames(readers, reader2.GetMethodDefNames(), "F", "<F>b__0_0", "<F>b__0_1#1", "<F>b__0_2#1");
+
+            diff2.VerifySynthesizedMembers(
+                "C: {<>c}",
+                "C.<>c: {<>9__0_0, <>9__0_1#1, <>9__0_2#1, <F>b__0_0, <F>b__0_1#1, <F>b__0_2#1}");
+
+            var diff3 = compilation3.EmitDifference(
+                diff2.NextGeneration,
+                ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method2, method3, GetSyntaxMapFromMarkers(source2, source3), preserveLocalVariables: true)));
+
+            Assert.False(diff3.EmitResult.Success);
+            diff3.EmitResult.Diagnostics.Verify(
+                // error CS8984: Cannot update because an inferred delegate type has changed.
+                Diagnostic(ErrorCode.ERR_EncUpdateFailedDelegateTypeChanged).WithLocation(1, 1));
+        }
+
+        [Fact]
+        public void Lambda_SynthesizedDelegate_03()
+        {
+            var source0 = MarkedSource(
+@"class A { }
+struct B<T> { }
+class C
+{
+    static unsafe void F()
+    {
+        var x = <N:0>(B<A>* a, int b) => a</N:0>;
+    }
+}");
+            var source1 = MarkedSource(
+@"class A { }
+struct B<T> { }
+class C
+{
+    static unsafe void F()
+    {
+        var x = <N:0>(B<A>* a, int b) => b</N:0>;
+    }
+}");
+
+            var compilation0 = CreateCompilation(source0.Tree, options: ComSafeDebugDll.WithAllowUnsafe(true).WithMetadataImportOptions(MetadataImportOptions.All));
+            var compilation1 = compilation0.WithSource(source1.Tree);
+
+            var v0 = CompileAndVerify(compilation0, verify: Verification.Skipped);
+            var md0 = ModuleMetadata.CreateFromImage(v0.EmittedAssemblyData);
+            var reader0 = md0.MetadataReader;
+
+            var method0 = compilation0.GetMember<MethodSymbol>("C.F");
+            var method1 = compilation1.GetMember<MethodSymbol>("C.F");
+
+            var generation0 = EmitBaseline.CreateInitialBaseline(md0, v0.CreateSymReader().GetEncMethodDebugInfo);
+
+            CheckNames(reader0, reader0.GetTypeDefNames(), "<Module>", "<>f__AnonymousDelegate0", "A", "B`1", "C", "<>c");
+            CheckNames(reader0, reader0.GetMethodDefNames(), ".ctor", "Invoke", ".ctor", "F", ".ctor", ".cctor", ".ctor", "<F>b__0_0");
+
+            var diff1 = compilation1.EmitDifference(
+                generation0,
+                ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1), preserveLocalVariables: true)));
+
+            Assert.False(diff1.EmitResult.Success);
+            diff1.EmitResult.Diagnostics.Verify(
+                // error CS8984: Cannot update because an inferred delegate type has changed.
+                Diagnostic(ErrorCode.ERR_EncUpdateFailedDelegateTypeChanged).WithLocation(1, 1));
+        }
+
+        [Fact]
+        public void Lambda_SynthesizedDelegate_04()
+        {
+            var source0 = MarkedSource(
+@"class A { }
+struct B<T> { }
+class C
+{
+    static unsafe void F()
+    {
+    }
+}");
+            var source1 = MarkedSource(
+@"class A { }
+struct B<T> { }
+class C
+{
+    static unsafe void F()
+    {
+        var x = <N:0>(B<A>* a, int b) => a</N:0>;
+    }
+}");
+            var source2 = MarkedSource(
+@"class A { }
+struct B<T> { }
+class C
+{
+    static unsafe void F()
+    {
+        var x = <N:0>(B<A>* a, int b) => b</N:0>;
+    }
+}");
+
+            var compilation0 = CreateCompilation(source0.Tree, options: ComSafeDebugDll.WithAllowUnsafe(true).WithMetadataImportOptions(MetadataImportOptions.All));
+            var compilation1 = compilation0.WithSource(source1.Tree);
+            var compilation2 = compilation1.WithSource(source2.Tree);
+
+            var v0 = CompileAndVerify(compilation0, verify: Verification.Skipped);
+            var md0 = ModuleMetadata.CreateFromImage(v0.EmittedAssemblyData);
+            var reader0 = md0.MetadataReader;
+
+            var method0 = compilation0.GetMember<MethodSymbol>("C.F");
+            var method1 = compilation1.GetMember<MethodSymbol>("C.F");
+            var method2 = compilation2.GetMember<MethodSymbol>("C.F");
+
+            var generation0 = EmitBaseline.CreateInitialBaseline(md0, v0.CreateSymReader().GetEncMethodDebugInfo);
+
+            CheckNames(reader0, reader0.GetTypeDefNames(), "<Module>", "A", "B`1", "C");
+            CheckNames(reader0, reader0.GetMethodDefNames(), ".ctor", "F", ".ctor");
+
+            var diff1 = compilation1.EmitDifference(
+                generation0,
+                ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1), preserveLocalVariables: true)));
+
+            // Verify delta metadata contains expected rows.
+            using var md1 = diff1.GetMetadata();
+            var reader1 = md1.Reader;
+            var readers = new[] { reader0, reader1 };
+
+            EncValidation.VerifyModuleMvid(1, reader0, reader1);
+
+            CheckNames(readers, reader1.GetTypeDefNames(), "<>f__AnonymousDelegate0", "<>c");
+            CheckNames(readers, reader1.GetMethodDefNames(), "F", ".ctor", "Invoke", ".cctor", ".ctor", "<F>b__0#1");
+
+            diff1.VerifySynthesizedMembers(
+               "C.<>c: {<>9__0#1, <F>b__0#1}",
+               "C: {<>c}");
+
+            var diff2 = compilation2.EmitDifference(
+                diff1.NextGeneration,
+                ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1, method2, GetSyntaxMapFromMarkers(source1, source2), preserveLocalVariables: true)));
+
+            Assert.False(diff2.EmitResult.Success);
+            diff2.EmitResult.Diagnostics.Verify(
+                // error CS8984: Cannot update because an inferred delegate type has changed.
+                Diagnostic(ErrorCode.ERR_EncUpdateFailedDelegateTypeChanged).WithLocation(1, 1));
+        }
+
+        [Fact]
+        public void Lambda_SynthesizedDelegate_05()
+        {
+            var source0 = MarkedSource(
+@"class C<T> where T : unmanaged
+{
+    static unsafe void F<U>() where U : unmanaged
+    {
+        var x = <N:0>(T t, U* u) => *u</N:0>;
+    }
+}");
+            var source1 = MarkedSource(
+@"class C<T> where T : unmanaged
+{
+    static unsafe void F<U>() where U : unmanaged
+    {
+        var x = <N:0>(T t, U* u) => default(U)</N:0>;
+        var y = <N:1>(U u, T* t) => *t</N:1>;
+    }
+}");
+            var source2 = MarkedSource(
+@"class C<T> where T : unmanaged
+{
+    static unsafe void F<U>() where U : unmanaged
+    {
+        var x = <N:0>(T t, U* u) => *u</N:0>;
+        var y = <N:1>(U u, T* t) => *t</N:1>;
+    }
+}");
+            var source3 = MarkedSource(
+@"class C<T> where T : unmanaged
+{
+    static unsafe void F<U>() where U : unmanaged
+    {
+        var x = <N:0>(T t, U* u) => *u</N:0>;
+        var y = <N:1>(U u, T* t) => t</N:1>;
+    }
+}");
+
+            var compilation0 = CreateCompilation(source0.Tree, options: ComSafeDebugDll.WithAllowUnsafe(true).WithMetadataImportOptions(MetadataImportOptions.All));
+            var compilation1 = compilation0.WithSource(source1.Tree);
+            var compilation2 = compilation1.WithSource(source2.Tree);
+            var compilation3 = compilation2.WithSource(source3.Tree);
+
+            var v0 = CompileAndVerify(compilation0, verify: Verification.Skipped);
+            var md0 = ModuleMetadata.CreateFromImage(v0.EmittedAssemblyData);
+            var reader0 = md0.MetadataReader;
+
+            var method0 = compilation0.GetMember<MethodSymbol>("C.F");
+            var method1 = compilation1.GetMember<MethodSymbol>("C.F");
+            var method2 = compilation2.GetMember<MethodSymbol>("C.F");
+            var method3 = compilation3.GetMember<MethodSymbol>("C.F");
+
+            var generation0 = EmitBaseline.CreateInitialBaseline(md0, v0.CreateSymReader().GetEncMethodDebugInfo);
+
+            CheckNames(reader0, reader0.GetTypeDefNames(), "<Module>", "<>f__AnonymousDelegate0`2", "EmbeddedAttribute", "IsUnmanagedAttribute", "C`1", "<>c__0`1");
+            CheckNames(reader0, reader0.GetMethodDefNames(), ".ctor", "Invoke", ".ctor", ".ctor", "F", ".ctor", ".cctor", ".ctor", "<F>b__0_0");
+
+            var diff1 = compilation1.EmitDifference(
+                generation0,
+                ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1), preserveLocalVariables: true)));
+
+            // Verify delta metadata contains expected rows.
+            using var md1 = diff1.GetMetadata();
+            var reader1 = md1.Reader;
+            var readers = new[] { reader0, reader1 };
+
+            EncValidation.VerifyModuleMvid(1, reader0, reader1);
+
+            CheckNames(readers, reader1.GetTypeDefNames(), "<>f__AnonymousDelegate1`2");
+            CheckNames(readers, reader1.GetMethodDefNames(), "F", "<F>b__0_0", ".ctor", "Invoke", "<F>b__0_1#1");
+
+            diff1.VerifySynthesizedMembers(
+                "Microsoft.CodeAnalysis: {EmbeddedAttribute}",
+                "Microsoft: {CodeAnalysis}",
+                "System.Runtime: {CompilerServices}",
+                "C<T>: {<>c__0}",
+                "<global namespace>: {Microsoft, System}",
+                "System: {Runtime}",
+                "System.Runtime.CompilerServices: {IsUnmanagedAttribute}",
+                "C<T>.<>c__0<U>: {<>9__0_0, <>9__0_1#1, <F>b__0_0, <F>b__0_1#1}");
+
+            var diff2 = compilation2.EmitDifference(
+                diff1.NextGeneration,
+                ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1, method2, GetSyntaxMapFromMarkers(source1, source2), preserveLocalVariables: true)));
+
+            using var md2 = diff2.GetMetadata();
+            var reader2 = md2.Reader;
+            readers = new[] { reader0, reader1, reader2 };
+
+            EncValidation.VerifyModuleMvid(2, reader1, reader2);
+
+            CheckNames(readers, reader2.GetTypeDefNames());
+            CheckNames(readers, reader2.GetMethodDefNames(), "F", "<F>b__0_0", "<F>b__0_1#1");
+
+            diff2.VerifySynthesizedMembers(
+                "Microsoft.CodeAnalysis: {EmbeddedAttribute}",
+                "System: {Runtime}",
+                "<global namespace>: {Microsoft, System}",
+                "C<T>: {<>c__0}",
+                "System.Runtime.CompilerServices: {IsUnmanagedAttribute}",
+                "System.Runtime: {CompilerServices}",
+                "Microsoft: {CodeAnalysis}",
+                "C<T>.<>c__0<U>: {<>9__0_0, <>9__0_1#1, <F>b__0_0, <F>b__0_1#1}");
+
+            var diff3 = compilation3.EmitDifference(
+                diff2.NextGeneration,
+                ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method2, method3, GetSyntaxMapFromMarkers(source2, source3), preserveLocalVariables: true)));
+
+            Assert.False(diff3.EmitResult.Success);
+            diff3.EmitResult.Diagnostics.Verify(
+                // error CS8984: Cannot update because an inferred delegate type has changed.
+                Diagnostic(ErrorCode.ERR_EncUpdateFailedDelegateTypeChanged).WithLocation(1, 1));
+        }
+
         [WorkItem(962219, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/962219")]
         [Fact]
         public void PartialMethod()
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/SymbolMatcherTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/SymbolMatcherTests.cs
index 88b332ce65632..44c719e3f2770 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/SymbolMatcherTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/SymbolMatcherTests.cs
@@ -70,6 +70,7 @@ interface I { }
             for (int i = 0; i < 10; i++)
             {
                 var matcher = new CSharpSymbolMatcher(
+                    null,
                     null,
                     null,
                     compilation1.SourceAssembly,
@@ -128,6 +129,7 @@ struct S
             var compilation1 = compilation0.WithSource(source);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -161,6 +163,7 @@ static void M<T>(I<T> o) where T : I<T>
             var compilation1 = compilation0.WithSource(source);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -196,6 +199,7 @@ .method public abstract virtual instance object modopt(A) [] F(int32 modopt(obje
             Assert.Equal(1, ((ArrayTypeSymbol)member1.ReturnType).ElementTypeWithAnnotations.CustomModifiers.Length);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -240,6 +244,7 @@ abstract class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -291,6 +296,7 @@ abstract class C
             var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll).WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -328,6 +334,7 @@ public void F(D a) {}
             var compilation1 = compilation0.WithSource(source).WithReferences(MscorlibRef, lib1.ToMetadataReference());
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -369,6 +376,7 @@ class D {}
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -407,6 +415,7 @@ class D {}
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -446,6 +455,7 @@ struct D {}
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -488,6 +498,7 @@ class D {}
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -536,7 +547,7 @@ static void F()
             var reader0 = peModule0.Module.MetadataReader;
             var decoder0 = new MetadataDecoder(peModule0);
 
-            var anonymousTypeMap0 = PEDeltaAssemblyBuilder.GetAnonymousTypeMapFromMetadata(reader0, decoder0);
+            PEDeltaAssemblyBuilder.GetAnonymousTypeMapFromMetadata(reader0, decoder0, out var anonymousTypeMap0, out _);
             Assert.Equal("<>f__AnonymousType0", anonymousTypeMap0[new AnonymousTypeKey(ImmutableArray.Create(new AnonymousTypeKeyField("A", isKey: false, ignoreCase: false)))].Name);
             Assert.Equal("<>f__AnonymousType1", anonymousTypeMap0[new AnonymousTypeKey(ImmutableArray.Create(new AnonymousTypeKeyField("B", isKey: false, ignoreCase: false)))].Name);
             Assert.Equal(2, anonymousTypeMap0.Count);
@@ -559,7 +570,7 @@ static void F()
             Assert.Equal("x1", x1.Name);
             Assert.Equal("x2", x2.Name);
 
-            var matcher = new CSharpSymbolMatcher(anonymousTypeMap0, null, compilation1.SourceAssembly, emitContext, peAssemblySymbol0);
+            var matcher = new CSharpSymbolMatcher(anonymousTypeMap0, null, null, compilation1.SourceAssembly, emitContext, peAssemblySymbol0);
 
             var mappedX1 = (Cci.IFieldDefinition)matcher.MapDefinition(x1);
             var mappedX2 = (Cci.IFieldDefinition)matcher.MapDefinition(x2);
@@ -605,7 +616,7 @@ static void F()
             var reader0 = peModule0.Module.MetadataReader;
             var decoder0 = new MetadataDecoder(peModule0);
 
-            var anonymousTypeMap0 = PEDeltaAssemblyBuilder.GetAnonymousTypeMapFromMetadata(reader0, decoder0);
+            PEDeltaAssemblyBuilder.GetAnonymousTypeMapFromMetadata(reader0, decoder0, out var anonymousTypeMap0, out _);
             Assert.Equal("<>f__AnonymousType0", anonymousTypeMap0[new AnonymousTypeKey(ImmutableArray.Create(new AnonymousTypeKeyField("A", isKey: false, ignoreCase: false)))].Name);
             Assert.Equal("<>f__AnonymousType1", anonymousTypeMap0[new AnonymousTypeKey(ImmutableArray.Create(new AnonymousTypeKeyField("X", isKey: false, ignoreCase: false)))].Name);
             Assert.Equal("<>f__AnonymousType2", anonymousTypeMap0[new AnonymousTypeKey(ImmutableArray.Create(new AnonymousTypeKeyField("Y", isKey: false, ignoreCase: false)))].Name);
@@ -628,7 +639,7 @@ static void F()
             var x1 = fields.Where(f => f.Name == "x1").Single();
             var x2 = fields.Where(f => f.Name == "x2").Single();
 
-            var matcher = new CSharpSymbolMatcher(anonymousTypeMap0, null, compilation1.SourceAssembly, emitContext, peAssemblySymbol0);
+            var matcher = new CSharpSymbolMatcher(anonymousTypeMap0, null, null, compilation1.SourceAssembly, emitContext, peAssemblySymbol0);
 
             var mappedX1 = (Cci.IFieldDefinition)matcher.MapDefinition(x1);
             var mappedX2 = (Cci.IFieldDefinition)matcher.MapDefinition(x2);
@@ -654,6 +665,7 @@ class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -685,6 +697,7 @@ class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -716,6 +729,7 @@ class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -747,6 +761,7 @@ class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -778,6 +793,7 @@ class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -809,6 +825,7 @@ class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -840,6 +857,7 @@ public struct Vector
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -871,6 +889,7 @@ public struct Vector
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -902,6 +921,7 @@ public class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -933,6 +953,7 @@ public class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -978,6 +999,7 @@ struct C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -1033,6 +1055,7 @@ struct C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -1095,7 +1118,7 @@ int I<int, bool>.this[int anotherIndex]
             Assert.Equal("anotherIndex", parameters[0].Name);
 
             var emitContext = new EmitContext(peAssemblyBuilder, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
-            var matcher = new CSharpSymbolMatcher(null, null, compilation1.SourceAssembly, emitContext, peAssemblySymbol0);
+            var matcher = new CSharpSymbolMatcher(null, null, null, compilation1.SourceAssembly, emitContext, peAssemblySymbol0);
 
             var mappedProperty = (Cci.IPropertyDefinition)matcher.MapDefinition(property.GetCciAdapter());
 
@@ -1123,6 +1146,7 @@ class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -1155,6 +1179,7 @@ class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -1187,6 +1212,7 @@ class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -1217,6 +1243,7 @@ class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -1273,7 +1300,7 @@ static void M(string? x)
             var reader0 = peModule0.Module.MetadataReader;
             var decoder0 = new MetadataDecoder(peModule0);
 
-            var anonymousTypeMap0 = PEDeltaAssemblyBuilder.GetAnonymousTypeMapFromMetadata(reader0, decoder0);
+            PEDeltaAssemblyBuilder.GetAnonymousTypeMapFromMetadata(reader0, decoder0, out var anonymousTypeMap0, out _);
             Assert.Equal("<>f__AnonymousType0", anonymousTypeMap0[new AnonymousTypeKey(ImmutableArray.Create(new AnonymousTypeKeyField("A", isKey: false, ignoreCase: false)))].Name);
             Assert.Equal("<>f__AnonymousType1", anonymousTypeMap0[new AnonymousTypeKey(ImmutableArray.Create(new AnonymousTypeKeyField("B", isKey: false, ignoreCase: false)))].Name);
             Assert.Equal(2, anonymousTypeMap0.Count);
@@ -1295,7 +1322,7 @@ static void M(string? x)
             var y1 = fields.Where(f => f.Name == "y1").Single();
             var y2 = fields.Where(f => f.Name == "y2").Single();
 
-            var matcher = new CSharpSymbolMatcher(anonymousTypeMap0, null, compilation1.SourceAssembly, emitContext, peAssemblySymbol0);
+            var matcher = new CSharpSymbolMatcher(anonymousTypeMap0, null, null, compilation1.SourceAssembly, emitContext, peAssemblySymbol0);
 
             var mappedY1 = (Cci.IFieldDefinition)matcher.MapDefinition(y1);
             var mappedY2 = (Cci.IFieldDefinition)matcher.MapDefinition(y2);
@@ -1329,6 +1356,7 @@ event Action F { add { } remove { } }
             var compilation1 = compilation0.WithSource(source);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -1385,6 +1413,7 @@ unsafe class C
             var compilation1 = compilation0.WithSource(source);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -1426,6 +1455,7 @@ unsafe class C
             var compilation1 = compilation0.WithSource(source2);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -1484,6 +1514,7 @@ static void verify(string source1, string source2)
                 var compilation1 = compilation0.WithSource(source2);
 
                 var matcher = new CSharpSymbolMatcher(
+                    null,
                     null,
                     null,
                     compilation1.SourceAssembly,
@@ -1514,6 +1545,7 @@ public record R
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -1543,6 +1575,7 @@ public record R
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -1573,6 +1606,7 @@ public record R
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -1601,6 +1635,7 @@ public record R(int X)
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -1634,6 +1669,7 @@ public R(int X)
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 null,
                 compilation1.SourceAssembly,
@@ -1652,7 +1688,7 @@ public R(int X)
         }
 
         [Fact]
-        public void SynthesizedDelegates()
+        public void SynthesizedDelegates_01()
         {
             var source0 = @"
 using System;
@@ -1688,7 +1724,7 @@ static void F()
             var reader0 = peModule0.Module.MetadataReader;
             var decoder0 = new MetadataDecoder(peModule0);
 
-            var synthesizedDelegates0 = PEDeltaAssemblyBuilder.GetSynthesizedDelegateMapFromMetadata(reader0, decoder0);
+            var synthesizedDelegates0 = PEDeltaAssemblyBuilder.GetAnonymousDelegateMapFromMetadata(reader0, decoder0);
             Assert.Contains(new SynthesizedDelegateKey("<>F{00000004}`3"), synthesizedDelegates0);
             Assert.Contains(new SynthesizedDelegateKey("<>A{00000003}`2"), synthesizedDelegates0);
             Assert.Contains(new SynthesizedDelegateKey("<>A{00000000,00000001}`33"), synthesizedDelegates0);
@@ -1714,7 +1750,7 @@ static void F()
             Assert.Equal("<>9__0_1", field2.Name);
             Assert.Equal("<>9__0_2", field3.Name);
 
-            var matcher = new CSharpSymbolMatcher(null, synthesizedDelegates0, compilation1.SourceAssembly, emitContext, peAssemblySymbol0);
+            var matcher = new CSharpSymbolMatcher(null, synthesizedDelegates0, null, compilation1.SourceAssembly, emitContext, peAssemblySymbol0);
 
             var mappedField1 = (Cci.IFieldDefinition)matcher.MapDefinition(field1);
             var mappedField2 = (Cci.IFieldDefinition)matcher.MapDefinition(field2);
@@ -1724,5 +1760,56 @@ static void F()
             Assert.Equal("<>9__0_1", mappedField2.Name);
             Assert.Equal("<>9__0_2", mappedField3.Name);
         }
+
+        [Fact]
+        public void SynthesizedDelegates_02()
+        {
+            var source0 =
+@"unsafe class Program
+{
+    static void Main()
+    {
+        var d1 = (int* p) => *p;
+    }
+}";
+            var source1 =
+@"unsafe class Program
+{
+    static void Main()
+    {
+        var d1 = (int* p) => 1;
+    }
+}";
+
+            var compilation0 = CreateCompilation(source0, options: TestOptions.UnsafeDebugDll);
+            var compilation1 = CreateCompilation(source1, options: TestOptions.UnsafeDebugDll);
+
+            var peRef0 = compilation0.EmitToImageReference();
+            var peAssemblySymbol0 = (PEAssemblySymbol)CreateCompilation("", new[] { peRef0 }).GetReferencedAssemblySymbol(peRef0);
+            var peModule0 = (PEModuleSymbol)peAssemblySymbol0.Modules[0];
+
+            var reader0 = peModule0.Module.MetadataReader;
+            var decoder0 = new MetadataDecoder(peModule0);
+
+            PEDeltaAssemblyBuilder.GetAnonymousTypeMapFromMetadata(reader0, decoder0, out _, out var anonymousDelegates0);
+            Assert.Equal("<>f__AnonymousDelegate0", anonymousDelegates0["<>f__AnonymousDelegate0"].Name);
+            Assert.Equal(1, anonymousDelegates0.Count);
+
+            var testData = new CompilationTestData();
+            compilation1.EmitToArray(testData: testData);
+            var peAssemblyBuilder = (PEAssemblyBuilder)testData.Module;
+
+            var type = compilation1.GetMember<NamedTypeSymbol>("Program");
+            var displayClass = peAssemblyBuilder.GetSynthesizedTypes(type).Single();
+            Assert.Equal("<>c", displayClass.Name);
+
+            var emitContext = new EmitContext(peAssemblyBuilder, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
+            var field0 = displayClass.GetFields(emitContext).Single(f => f.Name == "<>9__0_0");
+            Assert.Equal("<>f__AnonymousDelegate0", field0.GetType(emitContext).ToString());
+
+            var matcher = new CSharpSymbolMatcher(null, null, anonymousDelegates0, compilation1.SourceAssembly, emitContext, peAssemblySymbol0);
+            var field1 = (Cci.IFieldDefinition)matcher.MapDefinition(field0);
+            Assert.Equal("<>9__0_0", field1.Name);
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs
index 3db35f37d6dfc..9f9c94f3dded2 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs
@@ -1946,24 +1946,27 @@ static void Main()
         public void InvalidTypeArguments()
         {
             var source =
-@"unsafe class Program
+@"using System;
+unsafe class Program
 {
-    static int* F() => throw null;
+    static int* F() { Console.WriteLine(nameof(F)); return (int*)0; }
     static void Main()
     {
-        System.Delegate d;
-        d = F;
-        d = (int x, int* y) => { };
+        var d1 = F;
+        var d2 = (int x, int* y) => { Console.WriteLine((x, (int)y)); };
+        d1.Invoke();
+        d2.Invoke(1, (int*)2);
+        Report(d1);
+        Report(d2);
     }
+    static void Report(Delegate d) => Console.WriteLine(d.GetType());
 }";
-            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview, options: TestOptions.UnsafeReleaseExe);
-            comp.VerifyDiagnostics(
-                // (7,13): error CS8917: The delegate type could not be inferred.
-                //         d = F;
-                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "F").WithLocation(7, 13),
-                // (8,13): error CS8917: The delegate type could not be inferred.
-                //         d = (int x, int* y) => { };
-                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "(int x, int* y) => { }").WithLocation(8, 13));
+            CompileAndVerify(source, parseOptions: TestOptions.RegularPreview, options: TestOptions.UnsafeReleaseExe, verify: Verification.Skipped, expectedOutput:
+@"F
+(1, 2)
+<>f__AnonymousDelegate0
+<>f__AnonymousDelegate1
+");
         }
 
         [Fact]
@@ -2722,7 +2725,7 @@ static void Main()
         }
 
         [Fact]
-        public void SystemIntPtr_Missing()
+        public void SystemIntPtr_Missing_01()
         {
             var sourceA =
 @"namespace System
@@ -2757,6 +2760,42 @@ static void Main()
                 Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "(ref int i) => i").WithArguments("System.IntPtr").WithLocation(6, 13));
         }
 
+        [Fact]
+        public void SystemIntPtr_Missing_02()
+        {
+            var sourceA =
+@"namespace System
+{
+    public class Object { }
+    public abstract class ValueType { }
+    public class String { }
+    public class Type { }
+    public struct Void { }
+    public struct Boolean { }
+    public struct Int32 { }
+    public abstract class Delegate { }
+    public abstract class MulticastDelegate : Delegate { }
+}";
+            var sourceB =
+@"class Program
+{
+    static unsafe void Main()
+    {
+        System.Delegate d;
+        d = (int* p) => p;
+    }
+}";
+            var comp = CreateEmptyCompilation(new[] { sourceA, sourceB }, options: TestOptions.UnsafeReleaseExe);
+            comp.VerifyEmitDiagnostics(
+                // warning CS8021: No value for RuntimeMetadataVersion found. No assembly containing System.Object was found nor was a value for RuntimeMetadataVersion specified through options.
+                Diagnostic(ErrorCode.WRN_NoRuntimeMetadataVersion).WithLocation(1, 1),
+                // error CS0518: Predefined type 'System.IntPtr' is not defined or imported
+                Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound).WithArguments("System.IntPtr").WithLocation(1, 1),
+                // (6,13): error CS0518: Predefined type 'System.IntPtr' is not defined or imported
+                //         d = (int* p) => p;
+                Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "(int* p) => p").WithArguments("System.IntPtr").WithLocation(6, 13));
+        }
+
         [Fact]
         public void SystemMulticastDelegate_Missing()
         {
@@ -8356,31 +8395,40 @@ static void Main()
         public void SynthesizedDelegateTypes_11()
         {
             var source =
-@"class Program
+@"using System;
+class Program
 {
     unsafe static void Main()
     {
-        var d1 = int* () => (int*)42;
-        var d2 = (int* p) => { };
-        var d3 = delegate*<void> () => default;
-        var d4 = (delegate*<void> d) => { };
+        var d1 = int* () => { Console.WriteLine(1); return (int*)42; };
+        var d2 = (int* p) => { Console.WriteLine((int)p); };
+        var d3 = delegate*<void> () => { Console.WriteLine(3); return default; };
+        var d4 = (delegate*<void> d) => { Console.WriteLine((int)d); };
+        d1.Invoke();
+        d2.Invoke((int*)2);
+        d3.Invoke();
+        d4.Invoke((delegate*<void>)4);
+        Report(d1);
+        Report(d2);
+        Report(d3);
+        Report(d4);
     }
+    static void Report(Delegate d) => Console.WriteLine(d.GetType());
 }";
 
             var comp = CreateCompilation(source, options: TestOptions.UnsafeReleaseExe);
-            comp.VerifyDiagnostics(
-                // (5,18): error CS8917: The delegate type could not be inferred.
-                //         var d1 = int* () => (int*)42;
-                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "int* () => (int*)42").WithLocation(5, 18),
-                // (6,18): error CS8917: The delegate type could not be inferred.
-                //         var d2 = (int* p) => { };
-                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "(int* p) => { }").WithLocation(6, 18),
-                // (7,18): error CS8917: The delegate type could not be inferred.
-                //         var d3 = delegate*<void> () => default;
-                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "delegate*<void> () => default").WithLocation(7, 18),
-                // (8,18): error CS8917: The delegate type could not be inferred.
-                //         var d4 = (delegate*<void> d) => { };
-                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "(delegate*<void> d) => { }").WithLocation(8, 18));
+            comp.VerifyDiagnostics();
+
+            CompileAndVerify(comp, verify: Verification.Skipped, expectedOutput:
+@"1
+2
+3
+4
+<>f__AnonymousDelegate0
+<>f__AnonymousDelegate1
+<>f__AnonymousDelegate2
+<>f__AnonymousDelegate3
+");
         }
 
         [WorkItem(55217, "https://github.com/dotnet/roslyn/issues/55217")]
@@ -8396,19 +8444,21 @@ static void Main()
         var d1 = (TypedReference x) => { };
         var d2 = (int x, RuntimeArgumentHandle y) => { };
         var d3 = (ArgIterator x) => { };
+        Report(d1);
+        Report(d2);
+        Report(d3);
     }
+    static void Report(Delegate d) => Console.WriteLine(d.GetType());
 }";
-            var comp = CreateCompilation(source);
-            comp.VerifyDiagnostics(
-                // (6,18): error CS8917: The delegate type could not be inferred.
-                //         var d1 = (TypedReference x) => { };
-                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "(TypedReference x) => { }").WithLocation(6, 18),
-                // (7,18): error CS8917: The delegate type could not be inferred.
-                //         var d2 = (int x, RuntimeArgumentHandle y) => { };
-                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "(int x, RuntimeArgumentHandle y) => { }").WithLocation(7, 18),
-                // (8,18): error CS8917: The delegate type could not be inferred.
-                //         var d3 = (ArgIterator x) => { };
-                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "(ArgIterator x) => { }").WithLocation(8, 18));
+
+            var comp = CreateCompilation(source, options: TestOptions.ReleaseExe);
+            comp.VerifyDiagnostics();
+
+            CompileAndVerify(comp, expectedOutput:
+@"<>f__AnonymousDelegate0
+<>f__AnonymousDelegate1
+<>f__AnonymousDelegate2
+");
         }
 
         [WorkItem(55217, "https://github.com/dotnet/roslyn/issues/55217")]
@@ -8416,25 +8466,33 @@ static void Main()
         public void SynthesizedDelegateTypes_13()
         {
             var source =
-@"ref struct S<T> { }
+@"using System;
+ref struct S<T> { }
 class Program
 {
-    static void F1(int x, S<int> y) { }
-    static S<T> F2<T>() => throw null;
+    static void F1(int x, S<int> y) { Console.WriteLine(x); }
+    static S<T> F2<T>() { Console.WriteLine(typeof(T)); return default; }
     static void Main()
     {
         var d1 = F1;
         var d2 = F2<object>;
+        d1.Invoke(0, default);
+        d2.Invoke();
+        Report(d1);
+        Report(d2);
     }
+    static void Report(Delegate d) => Console.WriteLine(d.GetType());
 }";
-            var comp = CreateCompilation(source);
-            comp.VerifyDiagnostics(
-                // (8,18): error CS8917: The delegate type could not be inferred.
-                //         var d1 = F1;
-                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "F1").WithLocation(8, 18),
-                // (9,18): error CS8917: The delegate type could not be inferred.
-                //         var d2 = F2<object>;
-                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "F2<object>").WithLocation(9, 18));
+
+            var comp = CreateCompilation(source, options: TestOptions.ReleaseExe);
+            comp.VerifyDiagnostics();
+
+            CompileAndVerify(comp, expectedOutput:
+@"0
+System.Object
+<>f__AnonymousDelegate0
+<>f__AnonymousDelegate1
+");
         }
 
         [Fact]
@@ -8852,6 +8910,703 @@ class B<T>
 ");
         }
 
+        [Fact]
+        public void SynthesizedDelegateTypes_25()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        Delegate d1 = A.F1();
+        Delegate d2 = A.F2<int>();
+        Delegate d3 = B<string>.F3();
+        Delegate d4 = A.F2<string>();
+        Delegate d5 = B<int>.F3();
+        d1.DynamicInvoke();
+        d2.DynamicInvoke();
+        d3.DynamicInvoke();
+        d4.DynamicInvoke();
+        d5.DynamicInvoke();
+        Report(d1);
+        Report(d2);
+        Report(d3);
+        Report(d4);
+        Report(d5);
+    }
+    static void Report(Delegate d) => Console.WriteLine(d.GetType());
+}
+class A
+{
+    internal unsafe static Delegate F1() => int* () => { Console.WriteLine(nameof(F1)); return (int*)1; };
+    internal unsafe static Delegate F2<T>() => int* () => { Console.WriteLine((nameof(F2), typeof(T))); return (int*)2; };
+}
+class B<T>
+{
+    internal unsafe static Delegate F3() => int* () => { Console.WriteLine((nameof(F3), typeof(T))); return (int*)3; };
+}";
+            CompileAndVerify(source, options: TestOptions.UnsafeReleaseExe, verify: Verification.Skipped, expectedOutput:
+@"F1
+(F2, System.Int32)
+(F3, System.String)
+(F2, System.String)
+(F3, System.Int32)
+<>f__AnonymousDelegate0
+<>f__AnonymousDelegate0
+<>f__AnonymousDelegate0
+<>f__AnonymousDelegate0
+<>f__AnonymousDelegate0
+");
+        }
+
+        [WorkItem(55217, "https://github.com/dotnet/roslyn/issues/55217")]
+        [Fact]
+        public void SynthesizedDelegateTypes_26()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        Span<int> s = stackalloc int[] { 1, 2, 3 };
+        var d = (Span<int> s) => { Console.WriteLine(s.Length); };
+        d.Invoke(s);
+        Console.WriteLine(d.GetType());
+    }
+}";
+            var comp = CreateCompilationWithSpan(source, options: TestOptions.ReleaseExe);
+            CompileAndVerify(comp, verify: Verification.Skipped, expectedOutput:
+@"3
+<>f__AnonymousDelegate0
+");
+        }
+
+        [WorkItem(55217, "https://github.com/dotnet/roslyn/issues/55217")]
+        [Fact]
+        public void SynthesizedDelegateTypes_27()
+        {
+            var source =
+@"#nullable enable
+class Program
+{
+    unsafe static void Main()
+    {
+        object o = null; // 1
+        var d = (int* p) => o;
+        d((int*)42).ToString(); // 2
+    }
+}";
+            // Should report warning 2.
+            var comp = CreateCompilation(source, options: TestOptions.UnsafeReleaseExe);
+            comp.VerifyDiagnostics(
+                // (6,20): warning CS8600: Converting null literal or possible null value to non-nullable type.
+                //         object o = null; // 1
+                Diagnostic(ErrorCode.WRN_ConvertingNullableToNonNullable, "null").WithLocation(6, 20));
+        }
+
+        [WorkItem(55217, "https://github.com/dotnet/roslyn/issues/55217")]
+        [Fact]
+        public void SynthesizedDelegateTypes_28()
+        {
+            var sourceA =
+@"using System;
+class A
+{
+    static void Main()
+    {
+        B.M();
+        C.M();
+    }
+    internal static void Report(Delegate d) => Console.WriteLine(d.GetType());
+}";
+            var sourceB =
+@"using System;
+class B
+{
+    internal unsafe static void M()
+    {
+        int* x = (int*)42;
+        var d1 = (int y) => { Console.WriteLine((1, y)); return x; };
+        var d2 = (ref int y) => { Console.WriteLine((2, y)); return x; };
+        var d3 = (out int y) => { Console.WriteLine(3); y = 0; return x; };
+        var d4 = (in int y) => { Console.WriteLine((4, y)); return x; };
+        int i = 42;
+        d1.Invoke(i);
+        d2.Invoke(ref i);
+        d3.Invoke(out i);
+        d4.Invoke(in i);
+        A.Report(d1);
+        A.Report(d2);
+        A.Report(d3);
+        A.Report(d4);
+    }
+}";
+            var sourceC =
+@"using System;
+class C
+{
+    internal unsafe static void M()
+    {
+        int* p = (int*)42;
+        var d1 = (in int i) => { Console.WriteLine((1, i)); return p; };
+        var d2 = (out int i) => { Console.WriteLine(2); i = 0; return p; };
+        var d3 = (ref int i) => { Console.WriteLine((3, i)); return p; };
+        var d4 = (int i) => { Console.WriteLine((4, i)); return p; };
+        int i = 42;
+        d1.Invoke(in i);
+        d2.Invoke(out i);
+        d3.Invoke(ref i);
+        d4.Invoke(i);
+        A.Report(d1);
+        A.Report(d2);
+        A.Report(d3);
+        A.Report(d4);
+    }
+}";
+            CompileAndVerify(new[] { sourceA, sourceB, sourceC }, options: TestOptions.UnsafeReleaseExe, verify: Verification.Skipped, expectedOutput:
+@"(1, 42)
+(2, 42)
+3
+(4, 0)
+<>f__AnonymousDelegate0
+<>f__AnonymousDelegate1
+<>f__AnonymousDelegate2
+<>f__AnonymousDelegate3
+(1, 42)
+2
+(3, 0)
+(4, 0)
+<>f__AnonymousDelegate3
+<>f__AnonymousDelegate2
+<>f__AnonymousDelegate1
+<>f__AnonymousDelegate0
+");
+        }
+
+        [WorkItem(55217, "https://github.com/dotnet/roslyn/issues/55217")]
+        [Fact]
+        public void SynthesizedDelegateTypes_29()
+        {
+            var sourceA =
+@"using System;
+class A
+{
+    static void Main()
+    {
+        B.M();
+        C.M();
+    }
+    internal static void Report(Delegate d) => Console.WriteLine(d.GetType());
+}";
+            var sourceB =
+@"class B
+{
+    internal unsafe static void M()
+    {
+        A.Report((int* x, int y) => { });
+        A.Report((short* x, int y) => { });
+        A.Report((int* x, object y) => { });
+    }
+}";
+            var sourceC =
+@"class C
+{
+    internal unsafe static void M()
+    {
+        A.Report((int* x, string y) => { });
+        A.Report((short* x, int y) => { });
+        A.Report((char* x, char y) => { });
+        A.Report((int* x, int y) => { });
+        A.Report((int* x, object y) => { });
+    }
+}";
+            CompileAndVerify(new[] { sourceA, sourceB, sourceC }, options: TestOptions.UnsafeReleaseExe, verify: Verification.Skipped, expectedOutput:
+@"<>f__AnonymousDelegate0
+<>f__AnonymousDelegate1
+<>f__AnonymousDelegate2
+<>f__AnonymousDelegate3
+<>f__AnonymousDelegate1
+<>f__AnonymousDelegate4
+<>f__AnonymousDelegate0
+<>f__AnonymousDelegate2
+");
+        }
+
+        [Fact]
+        public void SynthesizedDelegateTypes_30()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        Delegate d = F<string>();
+        Console.WriteLine(d.GetType());
+    }
+    unsafe static Delegate F<T>()
+    {
+        return Local<int>();
+        static Delegate Local<U>() where U : unmanaged
+        {
+            var d = (T t, U* u) => { Console.WriteLine((t, (int)u)); };
+            d.Invoke(default, (U*)42);
+            return d;
+        }
+    }
+}";
+            CompileAndVerify(source, options: TestOptions.UnsafeReleaseExe, verify: Verification.Skipped, expectedOutput:
+@"(, 42)
+<>f__AnonymousDelegate0`2[System.String,System.Int32]
+");
+        }
+
+        [Fact]
+        public void SynthesizedDelegateTypes_31()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        Report(C<string>.F());
+        Report(C<float>.F());
+    }
+    static void Report(Delegate d) => Console.WriteLine(d.GetType());
+}
+unsafe class C<T>
+{
+    internal static Func<Delegate> F = () =>
+    {
+        return Local1<int>();
+        static Delegate Local1<U>() where U : unmanaged
+        {
+            return Local2<double>();
+            static Delegate Local2<V>() where V : struct
+            {
+                var d = U* (T t) => { Console.WriteLine((typeof(T), typeof(U))); return (U*)42; };
+                d.Invoke(default);
+                return d;
+            }
+        }
+    };
+}";
+            CompileAndVerify(source, options: TestOptions.UnsafeReleaseExe, verify: Verification.Skipped, expectedOutput:
+@" (System.String, System.Int32)
+<>f__AnonymousDelegate0`2[System.String,System.Int32]
+(System.Single, System.Int32)
+<>f__AnonymousDelegate0`2[System.Single,System.Int32]
+");
+        }
+
+        [Fact]
+        public void SynthesizedDelegateTypes_32()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        Report(S<int>.F);
+        Report(S<char>.P);
+    }
+    static void Report(Delegate d) => Console.WriteLine(d.GetType());
+}
+unsafe struct S<T> where T : unmanaged
+{
+    internal static Delegate F = T* () => (T*)1;
+    internal static Delegate P => S<T>* () => (S<T>*)2;
+}";
+            CompileAndVerify(source, options: TestOptions.UnsafeReleaseExe, verify: Verification.Skipped, expectedOutput:
+@"<>f__AnonymousDelegate0`1[System.Int32]
+<>f__AnonymousDelegate1`1[System.Char]
+");
+        }
+
+        [Fact]
+        public void SynthesizedDelegateTypes_33()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        Report(A.F1<int, string>());
+        Report(A.F1<string, int>());
+        Report(A.B<int, string>.F2());
+        Report(A.B<string, int>.F2());
+        Report(S<int>.C.F3<string>());
+        Report(S<string>.C.F3<int>());
+    }
+    static void Report(Delegate d) => Console.WriteLine(d.GetType());
+}
+class A
+{
+    internal unsafe static Delegate F1<T, U>()
+    {
+        var d = int (int* x, T[] y, S<U> z) => { Console.WriteLine(((int)x, typeof(T), typeof(U))); return 0; };
+        d.Invoke((int*)1, null, default);
+        return d;
+    }
+    internal struct B<T, U>
+    {
+        internal unsafe static Delegate F2()
+        {
+            var d = int (int* x, T[] y, S<U> z) => { Console.WriteLine(((int)x, typeof(T), typeof(U))); return 0; };
+            d.Invoke((int*)2, null, default);
+            return d;
+        }
+    }
+}
+struct S<U>
+{
+    internal class C
+    {
+        internal unsafe static Delegate F3<T>()
+        {
+            var d = int (int* x, T[] y, S<U> z) => { Console.WriteLine(((int)x, typeof(T), typeof(U))); return 0; };
+            d.Invoke((int*)3, null, default);
+            return d;
+        }
+    }
+}";
+            CompileAndVerify(source, options: TestOptions.UnsafeReleaseExe, verify: Verification.Skipped, expectedOutput:
+@"(1, System.Int32, System.String)
+<>f__AnonymousDelegate0`2[System.Int32,System.String]
+(1, System.String, System.Int32)
+<>f__AnonymousDelegate0`2[System.String,System.Int32]
+(2, System.Int32, System.String)
+<>f__AnonymousDelegate0`2[System.Int32,System.String]
+(2, System.String, System.Int32)
+<>f__AnonymousDelegate0`2[System.String,System.Int32]
+(3, System.String, System.Int32)
+<>f__AnonymousDelegate1`2[System.Int32,System.String]
+(3, System.Int32, System.String)
+<>f__AnonymousDelegate1`2[System.String,System.Int32]
+");
+        }
+
+        [Fact]
+        public void SynthesizedDelegateTypes_34()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        Report(A<int>.B<string>.M1<object>());
+        Report(A<int>.M2());
+        Report(A<int>.M3<string>());
+        Report(A<int>.M4<string, object>());
+        Report(A<string>.B<object>.M1<int>());
+        Report(A<string>.M2());
+        Report(A<string>.M3<object>());
+        Report(A<string>.M4<object, int>());
+    }
+    static void Report(Delegate d) => Console.WriteLine(d.GetType());
+}
+struct A<T>
+{
+    internal class B<U>
+    {
+        internal unsafe static Delegate M1<V>()
+        {
+            var d = void (int* x) => { Console.WriteLine(((int)x, typeof(T), typeof(U), typeof(V))); };
+            d.Invoke((int*)1);
+            return d;
+        }
+    }
+    internal unsafe static Delegate M2()
+    {
+        var d = void (int* x) => { Console.WriteLine(((int)x, typeof(T))); };
+        d.Invoke((int*)2);
+        return d;
+    }
+    internal unsafe static Delegate M3<U>()
+    {
+        var d = void (int* x) => { Console.WriteLine(((int)x, typeof(T), typeof(U))); };
+        d.Invoke((int*)3);
+        return d;
+    }
+    internal unsafe static Delegate M4<U, V>()
+    {
+        var d = void (int* x) => { Console.WriteLine(((int)x, typeof(T), typeof(U), typeof(V))); };
+        d.Invoke((int*)4);
+        return d;
+    }
+}";
+            CompileAndVerify(source, options: TestOptions.UnsafeReleaseExe, verify: Verification.Skipped, expectedOutput:
+@"(1, System.Int32, System.String, System.Object)
+<>f__AnonymousDelegate0
+(2, System.Int32)
+<>f__AnonymousDelegate0
+(3, System.Int32, System.String)
+<>f__AnonymousDelegate0
+(4, System.Int32, System.String, System.Object)
+<>f__AnonymousDelegate0
+(1, System.String, System.Object, System.Int32)
+<>f__AnonymousDelegate0
+(2, System.String)
+<>f__AnonymousDelegate0
+(3, System.String, System.Object)
+<>f__AnonymousDelegate0
+(4, System.String, System.Object, System.Int32)
+<>f__AnonymousDelegate0
+");
+        }
+
+        [Fact]
+        public void SynthesizedDelegateTypes_35()
+        {
+            var sourceA =
+@".class public A`1<T>
+{
+  .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret }
+  .method public static void F1(int32* modopt(class A`1<!T>) i) { ret }
+  .method public static int32* F2<U>(!T modopt(class A`1<!!U>) t) { ldnull throw }
+}";
+            var refA = CompileIL(sourceA);
+
+            var sourceB =
+@"using System;
+class B1<T> : A<T>
+{
+    unsafe public static Delegate F()
+    {
+        return F1;
+    }
+}
+class B2 : A<string>
+{
+    unsafe public static Delegate F<T>()
+    {
+        return F2<T>;
+    }
+}
+class Program
+{
+    unsafe static void Main()
+    {
+        var d1 = B1<double>.F();
+        Report(d1);
+        var d2 = B2.F<double>();
+        Report(d2);
+    }
+    static void Report(Delegate d)
+    {
+        var t = d.GetType();
+        Console.WriteLine(t);
+    }
+}";
+            CompileAndVerify(sourceB, references: new[] { refA }, options: TestOptions.UnsafeReleaseExe, verify: Verification.Skipped, expectedOutput:
+@"<>f__AnonymousDelegate0`1[System.Double]
+<>f__AnonymousDelegate1`1[System.Double]
+");
+        }
+
+        [Fact]
+        public void SynthesizedDelegateTypes_36()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        Report(S<int>.F1<string>());
+        Report(S<int>.F2<string>());
+        Report(S<int>.F3<string>());
+        Report(S<int>.F4<string>());
+    }
+    static void Report(Delegate d) => Console.WriteLine(d.GetType());
+}
+struct S<T>
+{
+    internal unsafe static Delegate F1<U>()
+    {
+        var d1 = (ref int x) => (ref int y) => { Console.WriteLine((y, typeof(T), typeof(U))); return default(T); };
+        int x = 1;
+        int y = 2;
+        d1.Invoke(ref x).Invoke(ref y);
+        return d1;
+    }
+    internal unsafe static Delegate F2<U>()
+    {
+        var d1 = (ref int x) => (int* y) => { Console.WriteLine(((int)y, typeof(T), typeof(U))); return default(T); };
+        int x = 3;
+        int* y = (int*)4;
+        d1.Invoke(ref x).Invoke(y);
+        return d1;
+    }
+    internal unsafe static Delegate F3<U>()
+    {
+        var d1 = (int* x) => (ref int y) => { Console.WriteLine(((int)x, y, typeof(T), typeof(U))); return default(U); };
+        int* x = (int*)5;
+        int y = 6;
+        d1.Invoke(x).Invoke(ref y);
+        return d1;
+    }
+    internal unsafe static Delegate F4<U>()
+    {
+        var d1 = (int* x) => (int* y) => { Console.WriteLine(((int)x, (int)y, typeof(T), typeof(U))); return default(U); };
+        int* x = (int*)7;
+        int* y = (int*)8;
+        d1.Invoke(x).Invoke(y);
+        return d1;
+    }
+}";
+            CompileAndVerify(source, options: TestOptions.UnsafeReleaseExe, verify: Verification.Skipped, expectedOutput:
+@"(2, System.Int32, System.String)
+<>F{00000001}`2[System.Int32,<>F{00000001}`2[System.Int32,System.Int32]]
+(4, System.Int32, System.String)
+<>F{00000001}`2[System.Int32,<>f__AnonymousDelegate0`1[System.Int32]]
+(5, 6, System.Int32, System.String)
+<>f__AnonymousDelegate1`1[System.String]
+(7, 8, System.Int32, System.String)
+<>f__AnonymousDelegate2`1[System.String]
+");
+        }
+
+        [Fact]
+        public void SynthesizedDelegateTypes_37()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        Report(S<int>.F1<string>());
+        Report(S<int>.F2<string>());
+    }
+    static void Report(Delegate d) => Console.WriteLine(d.GetType());
+}
+struct S<T>
+{
+    internal unsafe static Delegate F1<U>()
+    {
+        var d = (int* x) => { Console.WriteLine(((int)x, typeof(T), typeof(U))); return new { A = default(T) }; };
+        d.Invoke((int*)1);
+        return d;
+    }
+    internal unsafe static Delegate F2<U>()
+    {
+        var d = (int* x) => { Console.WriteLine(((int)x, typeof(T), typeof(U))); return new { B = default(U) }; };
+        d.Invoke((int*)2);
+        return d;
+    }
+}";
+            CompileAndVerify(source, options: TestOptions.UnsafeReleaseExe, verify: Verification.Skipped, expectedOutput:
+@"(1, System.Int32, System.String)
+<>f__AnonymousDelegate0`1[System.Int32]
+(2, System.Int32, System.String)
+<>f__AnonymousDelegate1`1[System.String]
+");
+        }
+
+        [Fact]
+        public void SynthesizedDelegateTypes_Constraints_01()
+        {
+            var source =
+@"using System;
+class A
+{
+    internal void F<T>(T? t) where T : struct
+    {
+        Console.WriteLine((typeof(T), t.HasValue ? t.Value.ToString() : ""<null>""));
+    }
+}
+struct S
+{
+}
+class Program
+{
+    static void Main()
+    {
+        var a = new A();
+        Report(M(a, 1));
+        Report(M(a, (short)2));
+        Report(M(a, new S()));
+    }
+    static void Report(Delegate d)
+    {
+        Console.WriteLine(d.GetType());
+    }
+    unsafe static Delegate M<T, U>(T t, U u)
+        where T : A
+        where U : struct
+    {
+        var d = void (int* p, T t, U? u) =>
+        {
+            t.F(u);
+        };
+        d.Invoke((int*)0, t, u);
+        d.Invoke((int*)1, t, default(U?));
+        return d;
+    }
+}";
+            CompileAndVerify(source, options: TestOptions.UnsafeReleaseExe, verify: Verification.Skipped, expectedOutput:
+@"(System.Int32, 1)
+(System.Int32, <null>)
+<>f__AnonymousDelegate0`2[A,System.Int32]
+(System.Int16, 2)
+(System.Int16, <null>)
+<>f__AnonymousDelegate0`2[A,System.Int16]
+(S, S)
+(S, <null>)
+<>f__AnonymousDelegate0`2[A,S]
+");
+        }
+
+        [Fact]
+        public void SynthesizedDelegateTypes_Constraints_02()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        Report(M1(new object(), string.Empty));
+        Report(M1(new object(), 1));
+        Report(M2(2, new object()));
+        Report(M2((short)3, (long)4));
+    }
+    static void Report(Delegate d) => Console.WriteLine(d.GetType());
+    unsafe static Delegate M1<T, U>(T t, U u)
+        where T : class
+        where U : T
+    {
+        var d = void (int* x, T y, U z) => { Console.WriteLine(((int)x, y.GetType(), z.GetType())); };
+        d.Invoke((int*)1, t, u);
+        return d;
+    }
+    unsafe static Delegate M2<T, U>(T t, U u)
+        where T : struct
+    {
+        var d = void (int* x, T y, U z) => { Console.WriteLine(((int)x, y.GetType(), z.GetType())); };
+        d.Invoke((int*)2, t, u);
+        return d;
+    }
+}";
+            CompileAndVerify(source, options: TestOptions.UnsafeReleaseExe, verify: Verification.Skipped, expectedOutput:
+@"(1, System.Object, System.String)
+<>f__AnonymousDelegate0`2[System.Object,System.String]
+(1, System.Object, System.Int32)
+<>f__AnonymousDelegate0`2[System.Object,System.Int32]
+(2, System.Int32, System.Object)
+<>f__AnonymousDelegate0`2[System.Int32,System.Object]
+(2, System.Int16, System.Int64)
+<>f__AnonymousDelegate0`2[System.Int16,System.Int64]
+");
+        }
+
         private static void VerifyLocalDelegateType(SemanticModel model, VariableDeclaratorSyntax variable, string expectedInvokeMethod)
         {
             var expectedBaseType = ((CSharpCompilation)model.Compilation).GetSpecialType(SpecialType.System_MulticastDelegate);
@@ -8914,6 +9669,50 @@ static void Main()
             CompileAndVerify(source, expectedOutput: @"<>F{00000001}`2[System.Int32,System.Int32]");
         }
 
+        [WorkItem(56808, "https://github.com/dotnet/roslyn/issues/56808")]
+        [Fact]
+        public void Invoke_03()
+        {
+            var source =
+@"class Program
+{
+    static void Main()
+    {
+        M1();
+        M2();
+    }
+    static void M1()
+    {
+        var d1 = (ref object obj) => { };
+        object obj = null;
+        var result = d1.BeginInvoke(ref obj, null, null);
+        d1.EndInvoke(result);
+    }
+    unsafe static void M2()
+    {
+        var d2 = (int* p) => p;
+        int* p = (int*)0;
+        var result = d2.BeginInvoke(p, null, null);
+        d2.EndInvoke(result);
+    }
+}";
+            var comp = CreateCompilation(source, options: TestOptions.UnsafeReleaseExe);
+            // https://github.com/dotnet/roslyn/issues/56808: Synthesized delegates should include BeginInvoke() and EndInvoke().
+            comp.VerifyDiagnostics(
+                // (12,25): error CS1061: '<anonymous delegate>' does not contain a definition for 'BeginInvoke' and no accessible extension method 'BeginInvoke' accepting a first argument of type '<anonymous delegate>' could be found (are you missing a using directive or an assembly reference?)
+                //         var result = d1.BeginInvoke(ref obj, null, null);
+                Diagnostic(ErrorCode.ERR_NoSuchMemberOrExtension, "BeginInvoke").WithArguments("<anonymous delegate>", "BeginInvoke").WithLocation(12, 25),
+                // (13,12): error CS1061: '<anonymous delegate>' does not contain a definition for 'EndInvoke' and no accessible extension method 'EndInvoke' accepting a first argument of type '<anonymous delegate>' could be found (are you missing a using directive or an assembly reference?)
+                //         d1.EndInvoke(result);
+                Diagnostic(ErrorCode.ERR_NoSuchMemberOrExtension, "EndInvoke").WithArguments("<anonymous delegate>", "EndInvoke").WithLocation(13, 12),
+                // (19,25): error CS1061: '<anonymous delegate>' does not contain a definition for 'BeginInvoke' and no accessible extension method 'BeginInvoke' accepting a first argument of type '<anonymous delegate>' could be found (are you missing a using directive or an assembly reference?)
+                //         var result = d2.BeginInvoke(p, null, null);
+                Diagnostic(ErrorCode.ERR_NoSuchMemberOrExtension, "BeginInvoke").WithArguments("<anonymous delegate>", "BeginInvoke").WithLocation(19, 25),
+                // (20,12): error CS1061: '<anonymous delegate>' does not contain a definition for 'EndInvoke' and no accessible extension method 'EndInvoke' accepting a first argument of type '<anonymous delegate>' could be found (are you missing a using directive or an assembly reference?)
+                //         d2.EndInvoke(result);
+                Diagnostic(ErrorCode.ERR_NoSuchMemberOrExtension, "EndInvoke").WithArguments("<anonymous delegate>", "EndInvoke").WithLocation(20, 12));
+        }
+
         [Fact]
         public void With()
         {
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/LambdaTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/LambdaTests.cs
index 3d22d654f2b61..17855adb842ae 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/LambdaTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/LambdaTests.cs
@@ -5250,21 +5250,12 @@ static void Main()
                 // (7,13): error CS1599: The return type of a method, delegate, or function pointer cannot be 'TypedReference'
                 //         d = TypedReference () => throw null;
                 Diagnostic(ErrorCode.ERR_MethodReturnCantBeRefAny, "TypedReference").WithArguments("System.TypedReference").WithLocation(7, 13),
-                // (7,13): error CS8917: The delegate type could not be inferred.
-                //         d = TypedReference () => throw null;
-                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "TypedReference () => throw null").WithLocation(7, 13),
                 // (8,13): error CS1599: The return type of a method, delegate, or function pointer cannot be 'RuntimeArgumentHandle'
                 //         d = RuntimeArgumentHandle () => throw null;
                 Diagnostic(ErrorCode.ERR_MethodReturnCantBeRefAny, "RuntimeArgumentHandle").WithArguments("System.RuntimeArgumentHandle").WithLocation(8, 13),
-                // (8,13): error CS8917: The delegate type could not be inferred.
-                //         d = RuntimeArgumentHandle () => throw null;
-                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "RuntimeArgumentHandle () => throw null").WithLocation(8, 13),
                 // (9,13): error CS1599: The return type of a method, delegate, or function pointer cannot be 'ArgIterator'
                 //         d = ArgIterator () => throw null;
-                Diagnostic(ErrorCode.ERR_MethodReturnCantBeRefAny, "ArgIterator").WithArguments("System.ArgIterator").WithLocation(9, 13),
-                // (9,13): error CS8917: The delegate type could not be inferred.
-                //         d = ArgIterator () => throw null;
-                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "ArgIterator () => throw null").WithLocation(9, 13));
+                Diagnostic(ErrorCode.ERR_MethodReturnCantBeRefAny, "ArgIterator").WithArguments("System.ArgIterator").WithLocation(9, 13));
         }
 
         [Fact]
diff --git a/src/Compilers/Core/Portable/Emit/AnonymousTypeKey.cs b/src/Compilers/Core/Portable/Emit/AnonymousTypeKey.cs
index 2dca21ea50905..c862903532865 100644
--- a/src/Compilers/Core/Portable/Emit/AnonymousTypeKey.cs
+++ b/src/Compilers/Core/Portable/Emit/AnonymousTypeKey.cs
@@ -8,13 +8,12 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Linq;
-using Microsoft.CodeAnalysis.Collections;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Emit
 {
-    internal struct AnonymousTypeKeyField : IEquatable<AnonymousTypeKeyField>
+    internal readonly struct AnonymousTypeKeyField : IEquatable<AnonymousTypeKeyField>
     {
         /// <summary>
         /// Name of the anonymous type field.
@@ -61,7 +60,7 @@ public override int GetHashCode()
     }
 
     [DebuggerDisplay("{GetDebuggerDisplay(), nq}")]
-    internal struct AnonymousTypeKey : IEquatable<AnonymousTypeKey>
+    internal readonly struct AnonymousTypeKey : IEquatable<AnonymousTypeKey>
     {
         internal readonly bool IsDelegate;
         internal readonly ImmutableArray<AnonymousTypeKeyField> Fields;
@@ -97,7 +96,7 @@ private string GetDebuggerDisplay()
                 {
                     builder.Append("|");
                 }
-                builder.Append(this.Fields[i]);
+                builder.Append(this.Fields[i].Name);
             }
             return pooledBuilder.ToStringAndFree();
         }
diff --git a/src/Compilers/Core/Portable/Emit/EditAndContinue/DeltaMetadataWriter.cs b/src/Compilers/Core/Portable/Emit/EditAndContinue/DeltaMetadataWriter.cs
index 69244750636ea..4412a2bbbe4bf 100644
--- a/src/Compilers/Core/Portable/Emit/EditAndContinue/DeltaMetadataWriter.cs
+++ b/src/Compilers/Core/Portable/Emit/EditAndContinue/DeltaMetadataWriter.cs
@@ -217,7 +217,8 @@ internal EmitBaseline GetDelta(Compilation compilation, Guid encId, MetadataSize
                 // Guid stream accumulates on the GUID heap unlike other heaps, so the previous generations are already included.
                 guidStreamLengthAdded: metadataSizes.HeapSizes[(int)HeapIndex.Guid],
                 anonymousTypeMap: ((IPEDeltaAssemblyBuilder)module).GetAnonymousTypeMap(),
-                synthesizedDelegates: ((IPEDeltaAssemblyBuilder)module).GetSynthesizedDelegates(),
+                anonymousDelegates: ((IPEDeltaAssemblyBuilder)module).GetAnonymousDelegates(),
+                anonymousDelegatesWithFixedTypes: ((IPEDeltaAssemblyBuilder)module).GetAnonymousDelegatesWithFixedTypes(),
                 synthesizedMembers: synthesizedMembers,
                 addedOrChangedMethods: AddRange(_previousGeneration.AddedOrChangedMethods, addedOrChangedMethodsByIndex),
                 debugInformationProvider: _previousGeneration.DebugInformationProvider,
diff --git a/src/Compilers/Core/Portable/Emit/EditAndContinue/EmitBaseline.cs b/src/Compilers/Core/Portable/Emit/EditAndContinue/EmitBaseline.cs
index 6f5560169c21d..760749f4ac1b6 100644
--- a/src/Compilers/Core/Portable/Emit/EditAndContinue/EmitBaseline.cs
+++ b/src/Compilers/Core/Portable/Emit/EditAndContinue/EmitBaseline.cs
@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
 using System.Reflection.Metadata;
@@ -63,9 +64,22 @@ public sealed class EmitBaseline
 
         internal sealed class MetadataSymbols
         {
+            /// <summary>
+            /// In C#, this is the set of anonymous types only; in VB, this is the set of anonymous types and delegates.
+            /// </summary>
             public readonly IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> AnonymousTypes;
 
-            public readonly IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> SynthesizedDelegates;
+            /// <summary>
+            /// In C#, the set of anonymous delegates where the parameter types and return type are
+            /// generic type arguments; in VB, this set is unused and empty.
+            /// </summary>
+            public readonly IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> AnonymousDelegates;
+
+            /// <summary>
+            /// In C#, the set of anonymous delegates where at least one of the parameter types or return type
+            /// is not a valid type argument; in VB, this set is unused and empty.
+            /// </summary>
+            public readonly IReadOnlyDictionary<string, AnonymousTypeValue> AnonymousDelegatesWithFixedTypes;
 
             /// <summary>
             /// A map of the assembly identities of the baseline compilation to the identities of the original metadata AssemblyRefs.
@@ -77,17 +91,20 @@ internal sealed class MetadataSymbols
 
             public MetadataSymbols(
                 IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> anonymousTypes,
-                IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> synthesizedDelegates,
+                IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> anonymousDelegates,
+                IReadOnlyDictionary<string, AnonymousTypeValue> anonymousDelegatesWithFixedTypes,
                 object metadataDecoder,
                 ImmutableDictionary<AssemblyIdentity, AssemblyIdentity> assemblyReferenceIdentityMap)
             {
                 Debug.Assert(anonymousTypes != null);
-                Debug.Assert(synthesizedDelegates != null);
+                Debug.Assert(anonymousDelegates != null);
+                Debug.Assert(anonymousDelegatesWithFixedTypes != null);
                 Debug.Assert(metadataDecoder != null);
                 Debug.Assert(assemblyReferenceIdentityMap != null);
 
                 this.AnonymousTypes = anonymousTypes;
-                this.SynthesizedDelegates = synthesizedDelegates;
+                this.AnonymousDelegates = anonymousDelegates;
+                this.AnonymousDelegatesWithFixedTypes = anonymousDelegatesWithFixedTypes;
                 this.MetadataDecoder = metadataDecoder;
                 this.AssemblyReferenceIdentityMap = assemblyReferenceIdentityMap;
             }
@@ -229,7 +246,8 @@ public static EmitBaseline CreateInitialBaseline(
                 userStringStreamLengthAdded: 0,
                 guidStreamLengthAdded: 0,
                 anonymousTypeMap: null, // Unset for initial metadata
-                synthesizedDelegates: null, // Unset for initial metadata
+                anonymousDelegates: null, // Unset for initial metadata
+                anonymousDelegatesWithFixedTypes: null, // Unset for initial metadata
                 synthesizedMembers: ImmutableDictionary<ISymbolInternal, ImmutableArray<ISymbolInternal>>.Empty,
                 methodsAddedOrChanged: new Dictionary<int, AddedOrChangedMethodInfo>(),
                 debugInformationProvider: debugInformationProvider,
@@ -317,7 +335,8 @@ public static EmitBaseline CreateInitialBaseline(
         internal readonly IReadOnlyDictionary<int, int> TypeToPropertyMap;
         internal readonly IReadOnlyDictionary<MethodImplKey, int> MethodImpls;
         private readonly IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue>? _anonymousTypeMap;
-        private readonly IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue>? _synthesizedDelegates;
+        private readonly IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue>? _anonymousDelegates;
+        private readonly IReadOnlyDictionary<string, AnonymousTypeValue>? _anonymousDelegatesWithFixedTypes;
         internal readonly ImmutableDictionary<ISymbolInternal, ImmutableArray<ISymbolInternal>> SynthesizedMembers;
 
         private EmitBaseline(
@@ -346,7 +365,8 @@ private EmitBaseline(
             int userStringStreamLengthAdded,
             int guidStreamLengthAdded,
             IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue>? anonymousTypeMap,
-            IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue>? synthesizedDelegates,
+            IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue>? anonymousDelegates,
+            IReadOnlyDictionary<string, AnonymousTypeValue>? anonymousDelegatesWithFixedTypes,
             ImmutableDictionary<ISymbolInternal, ImmutableArray<ISymbolInternal>> synthesizedMembers,
             IReadOnlyDictionary<int, AddedOrChangedMethodInfo> methodsAddedOrChanged,
             Func<MethodDefinitionHandle, EditAndContinueMethodDebugInformation> debugInformationProvider,
@@ -359,7 +379,8 @@ private EmitBaseline(
             Debug.Assert((ordinal == 0) == (encId == default));
             Debug.Assert((ordinal == 0) == (initialBaseline == null));
             Debug.Assert((ordinal == 0) == (anonymousTypeMap == null));
-            Debug.Assert((ordinal == 0) == (synthesizedDelegates == null));
+            Debug.Assert((ordinal == 0) == (anonymousDelegates == null));
+            Debug.Assert((ordinal == 0) == (anonymousDelegatesWithFixedTypes == null));
             Debug.Assert(encId != module.GetModuleVersionId());
             Debug.Assert(debugInformationProvider != null);
             Debug.Assert(localSignatureProvider != null);
@@ -411,7 +432,8 @@ private EmitBaseline(
             UserStringStreamLengthAdded = userStringStreamLengthAdded;
             GuidStreamLengthAdded = guidStreamLengthAdded;
             _anonymousTypeMap = anonymousTypeMap;
-            _synthesizedDelegates = synthesizedDelegates;
+            _anonymousDelegates = anonymousDelegates;
+            _anonymousDelegatesWithFixedTypes = anonymousDelegatesWithFixedTypes;
             SynthesizedMembers = synthesizedMembers;
             AddedOrChangedMethods = methodsAddedOrChanged;
 
@@ -445,7 +467,8 @@ internal EmitBaseline With(
             int userStringStreamLengthAdded,
             int guidStreamLengthAdded,
             IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> anonymousTypeMap,
-            IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> synthesizedDelegates,
+            IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> anonymousDelegates,
+            IReadOnlyDictionary<string, AnonymousTypeValue> anonymousDelegatesWithFixedTypes,
             ImmutableDictionary<ISymbolInternal, ImmutableArray<ISymbolInternal>> synthesizedMembers,
             IReadOnlyDictionary<int, AddedOrChangedMethodInfo> addedOrChangedMethods,
             Func<MethodDefinitionHandle, EditAndContinueMethodDebugInformation> debugInformationProvider,
@@ -454,8 +477,11 @@ internal EmitBaseline With(
             Debug.Assert(_anonymousTypeMap == null || anonymousTypeMap != null);
             Debug.Assert(_anonymousTypeMap == null || anonymousTypeMap.Count >= _anonymousTypeMap.Count);
 
-            Debug.Assert(_synthesizedDelegates == null || synthesizedDelegates != null);
-            Debug.Assert(_synthesizedDelegates == null || synthesizedDelegates.Count >= _synthesizedDelegates.Count);
+            Debug.Assert(_anonymousDelegates == null || anonymousDelegates != null);
+            Debug.Assert(_anonymousDelegates == null || anonymousDelegates.Count >= _anonymousDelegates.Count);
+
+            Debug.Assert(_anonymousDelegatesWithFixedTypes == null || anonymousDelegatesWithFixedTypes != null);
+            Debug.Assert(_anonymousDelegatesWithFixedTypes == null || anonymousDelegatesWithFixedTypes.Count >= _anonymousDelegatesWithFixedTypes.Count);
 
             return new EmitBaseline(
                 InitialBaseline,
@@ -483,7 +509,8 @@ internal EmitBaseline With(
                 userStringStreamLengthAdded: userStringStreamLengthAdded,
                 guidStreamLengthAdded: guidStreamLengthAdded,
                 anonymousTypeMap: anonymousTypeMap,
-                synthesizedDelegates: synthesizedDelegates,
+                anonymousDelegates: anonymousDelegates,
+                anonymousDelegatesWithFixedTypes: anonymousDelegatesWithFixedTypes,
                 synthesizedMembers: synthesizedMembers,
                 methodsAddedOrChanged: addedOrChangedMethods,
                 debugInformationProvider: debugInformationProvider,
@@ -503,23 +530,38 @@ internal IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> AnonymousType
                     return _anonymousTypeMap;
                 }
 
-                RoslynDebug.AssertNotNull(LazyMetadataSymbols);
+                Debug.Assert(LazyMetadataSymbols is object);
                 return LazyMetadataSymbols.AnonymousTypes;
             }
         }
 
-        internal IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> SynthesizedDelegates
+        internal IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> AnonymousDelegates
+        {
+            get
+            {
+                if (Ordinal > 0)
+                {
+                    Debug.Assert(_anonymousDelegates is object);
+                    return _anonymousDelegates;
+                }
+
+                Debug.Assert(LazyMetadataSymbols is object);
+                return LazyMetadataSymbols.AnonymousDelegates;
+            }
+        }
+
+        internal IReadOnlyDictionary<string, AnonymousTypeValue> AnonymousDelegatesWithFixedTypes
         {
             get
             {
                 if (Ordinal > 0)
                 {
-                    Debug.Assert(_synthesizedDelegates is not null);
-                    return _synthesizedDelegates;
+                    Debug.Assert(_anonymousDelegatesWithFixedTypes is object);
+                    return _anonymousDelegatesWithFixedTypes;
                 }
 
-                RoslynDebug.AssertNotNull(LazyMetadataSymbols);
-                return LazyMetadataSymbols.SynthesizedDelegates;
+                Debug.Assert(LazyMetadataSymbols is object);
+                return LazyMetadataSymbols.AnonymousDelegatesWithFixedTypes;
             }
         }
 
diff --git a/src/Compilers/Core/Portable/Emit/EditAndContinue/IPEDeltaAssemblyBuilder.cs b/src/Compilers/Core/Portable/Emit/EditAndContinue/IPEDeltaAssemblyBuilder.cs
index c968ea595379a..874b70f450104 100644
--- a/src/Compilers/Core/Portable/Emit/EditAndContinue/IPEDeltaAssemblyBuilder.cs
+++ b/src/Compilers/Core/Portable/Emit/EditAndContinue/IPEDeltaAssemblyBuilder.cs
@@ -10,6 +10,7 @@ internal interface IPEDeltaAssemblyBuilder
     {
         void OnCreatedIndices(DiagnosticBag diagnostics);
         IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> GetAnonymousTypeMap();
-        IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> GetSynthesizedDelegates();
+        IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> GetAnonymousDelegates();
+        IReadOnlyDictionary<string, AnonymousTypeValue> GetAnonymousDelegatesWithFixedTypes();
     }
 }
diff --git a/src/Compilers/Core/Portable/Emit/EditAndContinue/SymbolMatcher.cs b/src/Compilers/Core/Portable/Emit/EditAndContinue/SymbolMatcher.cs
index 75ae6c2ee81c4..9748a92841ec3 100644
--- a/src/Compilers/Core/Portable/Emit/EditAndContinue/SymbolMatcher.cs
+++ b/src/Compilers/Core/Portable/Emit/EditAndContinue/SymbolMatcher.cs
@@ -61,7 +61,8 @@ public EmitBaseline MapBaselineToCompilation(
                 userStringStreamLengthAdded: baseline.UserStringStreamLengthAdded,
                 guidStreamLengthAdded: baseline.GuidStreamLengthAdded,
                 anonymousTypeMap: MapAnonymousTypes(baseline.AnonymousTypeMap),
-                synthesizedDelegates: MapSynthesizedDelegates(baseline.SynthesizedDelegates),
+                anonymousDelegates: MapAnonymousDelegates(baseline.AnonymousDelegates),
+                anonymousDelegatesWithFixedTypes: MapAnonymousDelegatesWithFixedTypes(baseline.AnonymousDelegatesWithFixedTypes),
                 synthesizedMembers: mappedSynthesizedMembers,
                 addedOrChangedMethods: MapAddedOrChangedMethods(baseline.AddedOrChangedMethods),
                 debugInformationProvider: baseline.DebugInformationProvider,
@@ -114,11 +115,11 @@ private IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> MapAnonymousTy
             return result;
         }
 
-        private IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> MapSynthesizedDelegates(IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> synthesizedDelegates)
+        private IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> MapAnonymousDelegates(IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> anonymousDelegates)
         {
             var result = new Dictionary<SynthesizedDelegateKey, SynthesizedDelegateValue>();
 
-            foreach (var (key, value) in synthesizedDelegates)
+            foreach (var (key, value) in anonymousDelegates)
             {
                 var delegateTypeDef = (Cci.ITypeDefinition?)MapDefinition(value.Delegate);
                 RoslynDebug.Assert(delegateTypeDef != null);
@@ -128,6 +129,20 @@ private IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> Ma
             return result;
         }
 
+        private IReadOnlyDictionary<string, AnonymousTypeValue> MapAnonymousDelegatesWithFixedTypes(IReadOnlyDictionary<string, AnonymousTypeValue> anonymousDelegates)
+        {
+            var result = new Dictionary<string, AnonymousTypeValue>();
+
+            foreach (var (key, value) in anonymousDelegates)
+            {
+                var type = (Cci.ITypeDefinition?)MapDefinition(value.Type);
+                RoslynDebug.Assert(type != null);
+                result.Add(key, new AnonymousTypeValue(value.Name, value.UniqueIndex, type));
+            }
+
+            return result;
+        }
+
         /// <summary>
         /// Merges synthesized members generated during lowering of the current compilation with aggregate synthesized members 
         /// from all previous source generations (gen >= 1).
diff --git a/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/PEDeltaAssemblyBuilder.vb b/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/PEDeltaAssemblyBuilder.vb
index 1954808a25714..ca213c02940cc 100644
--- a/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/PEDeltaAssemblyBuilder.vb
+++ b/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/PEDeltaAssemblyBuilder.vb
@@ -115,9 +115,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Emit
             Dim metadataAssembly = metadataCompilation.GetBoundReferenceManager().CreatePEAssemblyForAssemblyMetadata(AssemblyMetadata.Create(originalMetadata), MetadataImportOptions.All, assemblyReferenceIdentityMap)
             Dim metadataDecoder = New MetadataDecoder(metadataAssembly.PrimaryModule)
             Dim metadataAnonymousTypes = GetAnonymousTypeMapFromMetadata(originalMetadata.MetadataReader, metadataDecoder)
-            ' VB synthesized delegates are handled as anonymous types in the map above
-            Dim synthesizedDelegates = SpecializedCollections.EmptyReadOnlyDictionary(Of SynthesizedDelegateKey, SynthesizedDelegateValue)
-            Dim metadataSymbols = New EmitBaseline.MetadataSymbols(metadataAnonymousTypes, synthesizedDelegates, metadataDecoder, assemblyReferenceIdentityMap)
+            ' VB anonymous delegates are handled as anonymous types in the map above
+            Dim anonymousDelegates = SpecializedCollections.EmptyReadOnlyDictionary(Of SynthesizedDelegateKey, SynthesizedDelegateValue)
+            Dim anonymousDelegatesWithFixedTypes = SpecializedCollections.EmptyReadOnlyDictionary(Of String, AnonymousTypeValue)
+            Dim metadataSymbols = New EmitBaseline.MetadataSymbols(metadataAnonymousTypes, anonymousDelegates, anonymousDelegatesWithFixedTypes, metadataDecoder, assemblyReferenceIdentityMap)
 
             Return InterlockedOperations.Initialize(initialBaseline.LazyMetadataSymbols, metadataSymbols)
         End Function
@@ -235,11 +236,16 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Emit
             Return anonymousTypes
         End Function
 
-        Friend Overloads Function GetSynthesizedDelegates() As IReadOnlyDictionary(Of SynthesizedDelegateKey, SynthesizedDelegateValue) Implements IPEDeltaAssemblyBuilder.GetSynthesizedDelegates
-            ' VB synthesized delegates are handled as anonymous types in the method above
+        Friend Overloads Function GetAnonymousDelegates() As IReadOnlyDictionary(Of SynthesizedDelegateKey, SynthesizedDelegateValue) Implements IPEDeltaAssemblyBuilder.GetAnonymousDelegates
+            ' VB anonymous delegates are handled as anonymous types in the method above
             Return SpecializedCollections.EmptyReadOnlyDictionary(Of SynthesizedDelegateKey, SynthesizedDelegateValue)
         End Function
 
+        Friend Overloads Function GetAnonymousDelegatesWithFixedTypes() As IReadOnlyDictionary(Of String, AnonymousTypeValue) Implements IPEDeltaAssemblyBuilder.GetAnonymousDelegatesWithFixedTypes
+            ' VB anonymous delegates are handled as anonymous types in the method above
+            Return SpecializedCollections.EmptyReadOnlyDictionary(Of String, AnonymousTypeValue)
+        End Function
+
         Friend Overrides Function TryCreateVariableSlotAllocator(method As MethodSymbol, topLevelMethod As MethodSymbol, diagnostics As DiagnosticBag) As VariableSlotAllocator
             Return _previousDefinitions.TryCreateVariableSlotAllocator(_previousGeneration, Compilation, method, topLevelMethod, diagnostics)
         End Function

From f51c1b219058583b56aa826d8ed89a9d92495243 Mon Sep 17 00:00:00 2001
From: AlekseyTs <AlekseyTs@users.noreply.github.com>
Date: Mon, 10 Jan 2022 10:54:55 -0800
Subject: [PATCH 289/444] SpillSequenceSpiller.Spill - ensure sequences under
 ref assignments are spilled. (#58657)

Fixes #58569.
---
 .../Portable/Lowering/SpillSequenceSpiller.cs |  21 +-
 .../Test/Emit/CodeGen/IndexAndRangeTests.cs   | 205 ++++++++++++++++++
 2 files changed, 223 insertions(+), 3 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Lowering/SpillSequenceSpiller.cs b/src/Compilers/CSharp/Portable/Lowering/SpillSequenceSpiller.cs
index c235cf371059b..86f9fc49a6cf3 100644
--- a/src/Compilers/CSharp/Portable/Lowering/SpillSequenceSpiller.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/SpillSequenceSpiller.cs
@@ -311,11 +311,26 @@ private BoundExpression Spill(
                         continue;
 
                     case BoundKind.Sequence:
-                        // neither the side-effects nor the value of the sequence contains await 
-                        // (otherwise it would be converted to a SpillSequenceBuilder).
                         if (refKind != RefKind.None)
                         {
-                            return expression;
+                            var sequence = (BoundSequence)expression;
+
+                            PromoteAndAddLocals(builder, sequence.Locals);
+                            builder.AddExpressions(sequence.SideEffects);
+                            expression = sequence.Value;
+                            continue;
+                        }
+
+                        goto default;
+
+                    case BoundKind.AssignmentOperator:
+                        var assignment = (BoundAssignmentOperator)expression;
+                        if (assignment.IsRef &&
+                            assignment is not { Left.Kind: BoundKind.Local, Right.Kind: BoundKind.ArrayAccess }) // Optimize for some known to be safe scenarios.
+                        {
+                            var left = Spill(builder, assignment.Left, RefKind.Ref);
+                            var right = Spill(builder, assignment.Right, RefKind.Ref);
+                            expression = assignment.Update(left, right, assignment.IsRef, assignment.Type);
                         }
 
                         goto default;
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/IndexAndRangeTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/IndexAndRangeTests.cs
index 62f565161795d..668905cf2ed05 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/IndexAndRangeTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/IndexAndRangeTests.cs
@@ -3582,5 +3582,210 @@ class C
                 Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "c").WithLocation(10, 5)
                 );
         }
+
+        [Fact]
+        public void PatternIndexArrayAndAwait_01()
+        {
+            var src = @"
+class C
+{
+    static async System.Threading.Tasks.Task M1(int[] arr)
+    {
+        arr[^1] = await System.Threading.Tasks.Task.FromResult(0);
+    }
+
+    static async System.Threading.Tasks.Task Main()
+    {
+        var arr = new[] { 123 };
+        System.Console.WriteLine(arr[0]);
+        await M1(arr);
+        System.Console.WriteLine(arr[0]);
+    }
+}
+";
+            CompileAndVerifyWithIndexAndRange(src, expectedOutput:
+@"
+123
+0
+").VerifyDiagnostics();
+        }
+
+        [Fact]
+        public void PatternIndexArrayAndAwait_02()
+        {
+            var src = @"
+class C
+{
+    static async System.Threading.Tasks.Task M1(int[] arr)
+    {
+        (arr[^1], arr[0]) = (123, await System.Threading.Tasks.Task.FromResult(124));
+    }
+
+    static async System.Threading.Tasks.Task Main()
+    {
+        var arr = new int[2];
+        await M1(arr);
+        System.Console.WriteLine(arr[0]);
+        System.Console.WriteLine(arr[1]);
+    }
+}
+";
+            CompileAndVerifyWithIndexAndRange(src, expectedOutput:
+@"
+124
+123
+").VerifyDiagnostics();
+        }
+
+        [Fact]
+        public void PatternIndexArrayAndAwait_03()
+        {
+            var src = @"
+class C
+{
+    static async System.Threading.Tasks.Task M1((int x, int y)[] arr)
+    {
+        arr[^1].x = await System.Threading.Tasks.Task.FromResult(124);
+    }
+
+    static async System.Threading.Tasks.Task Main()
+    {
+        var arr = new (int x, int y)[1];
+        await M1(arr);
+        System.Console.WriteLine(arr[0].x);
+    }
+}
+";
+            CompileAndVerifyWithIndexAndRange(src, expectedOutput:
+@"
+124
+").VerifyDiagnostics();
+        }
+
+        [Fact]
+        [WorkItem(58569, "https://github.com/dotnet/roslyn/issues/58569")]
+        public void PatternIndexArrayAndAwait_04()
+        {
+            var src = @"
+class C
+{
+    static async System.Threading.Tasks.Task M1((int x, int y)[] arr)
+    {
+        (arr[^1].x, arr[0].y) = (123, await System.Threading.Tasks.Task.FromResult(124));
+    }
+
+    static async System.Threading.Tasks.Task Main()
+    {
+        var arr = new (int x, int y)[2];
+        await M1(arr);
+        System.Console.WriteLine(arr[0].y);
+        System.Console.WriteLine(arr[1].x);
+    }
+}
+";
+            CompileAndVerifyWithIndexAndRange(src, expectedOutput:
+@"
+124
+123
+").VerifyDiagnostics();
+        }
+
+        [Fact]
+        [WorkItem(58569, "https://github.com/dotnet/roslyn/issues/58569")]
+        public void PatternIndexArrayAndAwait_05()
+        {
+            var src = @"
+class C
+{
+    static async System.Threading.Tasks.Task M1((int x, int y)[] arr)
+    {
+        arr[^1].x += await System.Threading.Tasks.Task.FromResult(124);
+    }
+
+    static async System.Threading.Tasks.Task Main()
+    {
+        var arr = new (int x, int y)[] { (1, 2) };
+        await M1(arr);
+        System.Console.WriteLine(arr[0].x);
+    }
+}
+";
+            CompileAndVerifyWithIndexAndRange(src, expectedOutput:
+@"
+125
+").VerifyDiagnostics();
+        }
+
+        [Fact]
+        public void PatternIndexArrayAndAwait_06()
+        {
+            var src = @"
+class C
+{
+    static async System.Threading.Tasks.Task M1(int[] arr)
+    {
+        arr[^1] += await System.Threading.Tasks.Task.FromResult(124);
+    }
+
+    static async System.Threading.Tasks.Task Main()
+    {
+        var arr = new int[] { 1 };
+        await M1(arr);
+        System.Console.WriteLine(arr[0]);
+    }
+}
+";
+            CompileAndVerifyWithIndexAndRange(src, expectedOutput:
+@"
+125
+").VerifyDiagnostics();
+        }
+
+        [Fact]
+        public void PatternIndexArrayAndAwait_07()
+        {
+            var src = @"
+class C
+{
+    static async System.Threading.Tasks.Task M1(int[][] arr)
+    {
+        arr[^1][0] += await System.Threading.Tasks.Task.FromResult(124);
+    }
+
+    static async System.Threading.Tasks.Task Main()
+    {
+        var arr = new[] { new[] { 1 } };
+        await M1(arr);
+        System.Console.WriteLine(arr[0][0]);
+    }
+}
+";
+            CompileAndVerifyWithIndexAndRange(src, expectedOutput:
+@"
+125
+").VerifyDiagnostics();
+        }
+
+        [Fact]
+        public void PatternIndexArrayAndAwait_08()
+        {
+            var src = @"
+class C
+{
+    static async System.Threading.Tasks.Task M1((int x, int y)[] arr)
+    {
+        (arr[1..][^1].x, arr[1..][0].y) = (123, await System.Threading.Tasks.Task.FromResult(124));
+    }
+
+    static async System.Threading.Tasks.Task Main()
+    {
+        var arr = new (int x, int y)[5];
+        await M1(arr);
+        System.Console.WriteLine(""Done"");
+    }
+}
+";
+            CompileAndVerifyWithIndexAndRange(src, expectedOutput: "Done").VerifyDiagnostics();
+        }
     }
 }

From e39fa728c6dfaabea3e78c06c9d16087a7ed02ff Mon Sep 17 00:00:00 2001
From: dotnet bot <dotnet-bot@dotnetfoundation.org>
Date: Mon, 10 Jan 2022 11:29:07 -0800
Subject: [PATCH 290/444] Localized file check-in by OneLocBuild Task: Build
 definition ID 327: Build ID 1545084

---
 src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf      | 2 +-
 src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf      | 2 +-
 src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf      | 2 +-
 src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf      | 2 +-
 src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf      | 2 +-
 src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf      | 2 +-
 src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf   | 2 +-
 src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf      | 2 +-
 src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf | 2 +-
 src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf | 2 +-
 10 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
index d59ee5981246f..9a6c0a861541b 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
@@ -1194,7 +1194,7 @@
       </trans-unit>
       <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
         <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
-        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <target state="translated">Eine „Struktur“ mit Feldinitialisierern muss einen explizit deklarierten Konstruktor enthalten.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
index b8e28c18aa352..d1e1bbb520e55 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
@@ -1194,7 +1194,7 @@
       </trans-unit>
       <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
         <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
-        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <target state="translated">Un 'struct' con inicializadores de campo debe incluir un constructor declarado explícitamente.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
index e301593dd7f24..bb9fb2d0e3578 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
@@ -1194,7 +1194,7 @@
       </trans-unit>
       <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
         <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
-        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <target state="translated">Un 'struct' avec des initialiseurs de champ doit inclure un constructeur explicitement déclaré.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
index 08c3886f52c80..42835c68d96fa 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
@@ -1194,7 +1194,7 @@
       </trans-unit>
       <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
         <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
-        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <target state="translated">Un elemento 'struct' con inizializzatori di campo deve includere un costruttore dichiarato in modo esplicito.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
index 7ad7f17c7f674..7ae8a63934bcc 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
@@ -1194,7 +1194,7 @@
       </trans-unit>
       <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
         <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
-        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <target state="translated">필드 이니셜라이저가 있는 '구조체'에는 명시적으로 선언된 생성자가 포함되어야 합니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
index 91f88ca15314a..c0a268f5f986a 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
@@ -1194,7 +1194,7 @@
       </trans-unit>
       <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
         <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
-        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <target state="translated">Element „struct” z inicjatorami pól musi zawierać jawnie zadeklarowanego konstruktora.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
index 2b3171caf9dc3..5dc1fd0954763 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
@@ -1194,7 +1194,7 @@
       </trans-unit>
       <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
         <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
-        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <target state="translated">Uma 'estrutura' com inicializadores de campo deve incluir um construtor declarado explicitamente.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
index 6f74471fd15a5..4493a1e577644 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
@@ -1194,7 +1194,7 @@
       </trans-unit>
       <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
         <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
-        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <target state="translated">Alan başlatıcılarına sahip bir 'struct' açıkça bildirilen bir oluşturucu içermelidir.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
index 461d32ca1734c..c603510e72ed4 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
@@ -1194,7 +1194,7 @@
       </trans-unit>
       <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
         <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
-        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <target state="translated">具有字段初始值设定项的“结构”必须包含显式声明的构造函数。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
index a6fb5751e8164..e0dd4b31167fa 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
@@ -1194,7 +1194,7 @@
       </trans-unit>
       <trans-unit id="ERR_StructHasInitializersAndNoDeclaredConstructor">
         <source>A 'struct' with field initializers must include an explicitly declared constructor.</source>
-        <target state="new">A 'struct' with field initializers must include an explicitly declared constructor.</target>
+        <target state="translated">具有欄位初始設定式的 'struct' 必須包含明確宣告的建構函式。</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_SwitchArmSubsumed">

From c19fb4e4ccaecd96eb3d28e8c18981ce15fa9dc4 Mon Sep 17 00:00:00 2001
From: dotnet bot <dotnet-bot@dotnetfoundation.org>
Date: Mon, 10 Jan 2022 11:32:02 -0800
Subject: [PATCH 291/444] Localized file check-in by OneLocBuild Task: Build
 definition ID 327: Build ID 1545084


From f3c7b8c19222adf1f25b68872845d11483ea0f15 Mon Sep 17 00:00:00 2001
From: dotnet bot <dotnet-bot@dotnetfoundation.org>
Date: Mon, 10 Jan 2022 11:38:12 -0800
Subject: [PATCH 292/444] Localized file check-in by OneLocBuild Task: Build
 definition ID 327: Build ID 1545084


From 1a1b5898b31f5ac5c759528c5843d77840519323 Mon Sep 17 00:00:00 2001
From: dotnet bot <dotnet-bot@dotnetfoundation.org>
Date: Mon, 10 Jan 2022 11:41:11 -0800
Subject: [PATCH 293/444] Localized file check-in by OneLocBuild Task: Build
 definition ID 327: Build ID 1545084


From 04ae33252790ebc0ff97c9e42196561be0ac0938 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 10 Jan 2022 12:07:45 -0800
Subject: [PATCH 294/444] Fix code

---
 .../CSharp/Portable/CodeGeneration/MethodGenerator.cs           | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
index 3d14b9fd17f7c..0b30c1abcbd72 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
@@ -24,7 +24,7 @@ internal static class MethodGenerator
         private static readonly TypeParameterConstraintSyntax s_structConstraint = SyntaxFactory.ClassOrStructConstraint(SyntaxKind.StructConstraint);
         private static readonly TypeParameterConstraintSyntax s_defaultConstraint = SyntaxFactory.DefaultConstraint();
 
-        internal static NamespaceDeclarationSyntax AddMethodTo(
+        internal static BaseNamespaceDeclarationSyntax AddMethodTo(
             BaseNamespaceDeclarationSyntax destination,
             IMethodSymbol method,
             CodeGenerationOptions options,

From fddd6d06033638ff6e9b5da93d92e70ebec4ee06 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 10 Jan 2022 12:16:46 -0800
Subject: [PATCH 295/444] Get things building

---
 .../CSharpTest/ImplementInterface/ImplementInterfaceTests.cs  | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs b/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs
index 2322e3ee6af3e..847e4386acf16 100644
--- a/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs
+++ b/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs
@@ -9434,7 +9434,7 @@ void I.M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d)
     {
         throw new System.NotImplementedException();
     }
-}", index: 1);
+}", codeAction: ("", 1));
         }
 
         [WorkItem(53012, "https://github.com/dotnet/roslyn/issues/53012")]
@@ -9467,7 +9467,7 @@ void I.M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d)
     {
         throw new System.NotImplementedException();
     }
-}", index: 1);
+}", codeAction: ("", 1));
         }
 
         [WorkItem(51779, "https://github.com/dotnet/roslyn/issues/51779")]

From 7a6923a664d0a2c0a451f28f64b1e63d0b593c65 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 10 Jan 2022 12:41:09 -0800
Subject: [PATCH 296/444] Fix tests

---
 .../ImplementInterfaceTests.cs                | 27 ++++++++++++-------
 1 file changed, 18 insertions(+), 9 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs b/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs
index 847e4386acf16..f072bdc5b8417 100644
--- a/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs
+++ b/src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs
@@ -100,6 +100,7 @@ private static async Task TestInRegularAndScriptAsync(
                 FixedCode = expectedMarkup,
                 CodeActionEquivalenceKey = codeAction?.equivalenceKey,
                 CodeActionIndex = codeAction?.index,
+                LanguageVersion = LanguageVersion.CSharp10,
             }.RunAsync();
         }
 
@@ -9386,15 +9387,19 @@ public void Bar(string? x)
         public async Task TestNullableTypeParameter()
         {
             await TestInRegularAndScriptAsync(
-@"interface I
+@"#nullable enable
+
+interface I
 {
     void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d);
 }
 
-class D : [|I|]
+class D : {|CS0535:I|}
 {
 }",
-@"interface I
+@"#nullable enable
+
+interface I
 {
     void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d);
 }
@@ -9413,15 +9418,19 @@ public void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d)
         public async Task TestNullableTypeParameter_ExplicitInterfaceImplementation()
         {
             await TestInRegularAndScriptAsync(
-@"interface I
+@"#nullable enable
+
+interface I
 {
     void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d);
 }
 
-class D : [|I|]
+class D : {|CS0535:I|}
 {
 }",
-@"interface I
+@"#nullable enable
+
+interface I
 {
     void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d);
 }
@@ -9434,7 +9443,7 @@ void I.M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d)
     {
         throw new System.NotImplementedException();
     }
-}", codeAction: ("", 1));
+}", codeAction: ("True;False;False:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [WorkItem(53012, "https://github.com/dotnet/roslyn/issues/53012")]
@@ -9449,7 +9458,7 @@ interface I
     void M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d) where T1 : class;
 }
 
-class D : [|I|]
+class D : {|CS0535:I|}
 {
 }",
 @"#nullable enable
@@ -9467,7 +9476,7 @@ void I.M<T1, T2, T3>(T1? a, T2 b, T1? c, T3? d)
     {
         throw new System.NotImplementedException();
     }
-}", codeAction: ("", 1));
+}", codeAction: ("True;False;False:global::I;TestProject;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;", 1));
         }
 
         [WorkItem(51779, "https://github.com/dotnet/roslyn/issues/51779")]

From 24ef0f30f29298be003d2d7d5de29f9906c37611 Mon Sep 17 00:00:00 2001
From: Charles Stoner <10732005+cston@users.noreply.github.com>
Date: Mon, 10 Jan 2022 13:32:42 -0800
Subject: [PATCH 297/444] Move CSharp/Test/Emit/Attributes to Emit2 (#58754)

---
 .../CodeGen/CodeGenOverridingAndHiding.cs     | 21 ++++++++++++++++++-
 .../Attributes/AttributeTests.cs              |  0
 .../Attributes/AttributeTests_Assembly.cs     |  0
 .../AttributeTests_CallerInfoAttributes.cs    |  0
 .../Attributes/AttributeTests_Conditional.cs  |  0
 .../Attributes/AttributeTests_Dynamic.cs      |  0
 .../Attributes/AttributeTests_Embedded.cs     |  0
 .../Attributes/AttributeTests_Experimental.cs |  0
 .../Attributes/AttributeTests_IsByRefLike.cs  |  0
 .../Attributes/AttributeTests_IsUnmanaged.cs  |  0
 .../Attributes/AttributeTests_Locations.cs    |  0
 .../Attributes/AttributeTests_MarshalAs.cs    |  0
 .../AttributeTests_NativeInteger.cs           |  0
 .../Attributes/AttributeTests_Nullable.cs     |  0
 .../AttributeTests_NullableContext.cs         |  0
 .../AttributeTests_NullablePublicOnly.cs      |  0
 .../AttributeTests_ReadOnlyStruct.cs          |  0
 .../Attributes/AttributeTests_RefReadOnly.cs  |  0
 .../Attributes/AttributeTests_Security.cs     |  0
 .../Attributes/AttributeTests_StructLayout.cs |  0
 .../Attributes/AttributeTests_Synthesized.cs  |  0
 .../Attributes/AttributeTests_Tuples.cs       |  0
 .../AttributeTests_WellKnownAttributes.cs     |  0
 .../Attributes/EmitTestStrongNameProvider.cs  |  0
 .../InternalsVisibleToAndStrongNameTests.cs   |  0
 .../Attributes/WellKnownAttributesTestBase.cs |  0
 .../Emit/UnmanagedTypeModifierTests.cs        |  0
 27 files changed, 20 insertions(+), 1 deletion(-)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/AttributeTests.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/AttributeTests_Assembly.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/AttributeTests_CallerInfoAttributes.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/AttributeTests_Conditional.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/AttributeTests_Dynamic.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/AttributeTests_Embedded.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/AttributeTests_Experimental.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/AttributeTests_IsByRefLike.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/AttributeTests_IsUnmanaged.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/AttributeTests_Locations.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/AttributeTests_MarshalAs.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/AttributeTests_NativeInteger.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/AttributeTests_Nullable.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/AttributeTests_NullableContext.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/AttributeTests_NullablePublicOnly.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/AttributeTests_ReadOnlyStruct.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/AttributeTests_RefReadOnly.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/AttributeTests_Security.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/AttributeTests_StructLayout.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/AttributeTests_Synthesized.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/AttributeTests_Tuples.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/AttributeTests_WellKnownAttributes.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/EmitTestStrongNameProvider.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/InternalsVisibleToAndStrongNameTests.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Attributes/WellKnownAttributesTestBase.cs (100%)
 rename src/Compilers/CSharp/Test/{Emit => Emit2}/Emit/UnmanagedTypeModifierTests.cs (100%)

diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenOverridingAndHiding.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenOverridingAndHiding.cs
index e013c7f76c9a1..2a4e0a2776d79 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenOverridingAndHiding.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenOverridingAndHiding.cs
@@ -7,6 +7,7 @@
 using System;
 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;
@@ -4121,13 +4122,31 @@ static void Main()
 
                 if (isFromMetadata)
                 {
-                    WellKnownAttributesTestBase.VerifyParamArrayAttribute(parameterB);
+                    VerifyParamArrayAttribute(parameterB);
                 };
             };
 
             var verifier = CompileAndVerify(source, symbolValidator: validator(true), sourceSymbolValidator: validator(false), expectedOutput: @"System.Int32[]");
         }
 
+        private static void VerifyParamArrayAttribute(ParameterSymbol parameter, bool expected = true)
+        {
+            Assert.Equal(expected, parameter.IsParams);
+
+            var peParameter = (PEParameterSymbol)parameter;
+            var allAttributes = ((PEModuleSymbol)parameter.ContainingModule).GetCustomAttributesForToken(peParameter.Handle);
+            var paramArrayAttributes = allAttributes.Where(a => a.AttributeClass.ToTestDisplayString() == "System.ParamArrayAttribute");
+
+            if (expected)
+            {
+                Assert.Equal(1, paramArrayAttributes.Count());
+            }
+            else
+            {
+                Assert.Empty(paramArrayAttributes);
+            }
+        }
+
         [WorkItem(543158, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543158")]
         [Fact]
         public void XNoDefaultForParams_Dev10781558()
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Assembly.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Assembly.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Assembly.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Assembly.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_CallerInfoAttributes.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_CallerInfoAttributes.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_CallerInfoAttributes.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_CallerInfoAttributes.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Conditional.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Conditional.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Conditional.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Conditional.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Dynamic.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Dynamic.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Dynamic.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Dynamic.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Embedded.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Embedded.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Embedded.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Embedded.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Experimental.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Experimental.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Experimental.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Experimental.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_IsByRefLike.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_IsByRefLike.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_IsByRefLike.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_IsByRefLike.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_IsUnmanaged.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_IsUnmanaged.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_IsUnmanaged.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_IsUnmanaged.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Locations.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Locations.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Locations.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Locations.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_MarshalAs.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_MarshalAs.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_MarshalAs.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_MarshalAs.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_NativeInteger.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_NativeInteger.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_NativeInteger.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_NativeInteger.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Nullable.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Nullable.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Nullable.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Nullable.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_NullableContext.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_NullableContext.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_NullableContext.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_NullableContext.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_NullablePublicOnly.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_NullablePublicOnly.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_NullablePublicOnly.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_NullablePublicOnly.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_ReadOnlyStruct.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_ReadOnlyStruct.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_ReadOnlyStruct.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_ReadOnlyStruct.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_RefReadOnly.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_RefReadOnly.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_RefReadOnly.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_RefReadOnly.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Security.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Security.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Security.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Security.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_StructLayout.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_StructLayout.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_StructLayout.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_StructLayout.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Synthesized.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Synthesized.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Synthesized.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Synthesized.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Tuples.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Tuples.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Tuples.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Tuples.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_WellKnownAttributes.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_WellKnownAttributes.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_WellKnownAttributes.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_WellKnownAttributes.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/EmitTestStrongNameProvider.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/EmitTestStrongNameProvider.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/EmitTestStrongNameProvider.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/EmitTestStrongNameProvider.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/InternalsVisibleToAndStrongNameTests.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/InternalsVisibleToAndStrongNameTests.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/InternalsVisibleToAndStrongNameTests.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/InternalsVisibleToAndStrongNameTests.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Attributes/WellKnownAttributesTestBase.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/WellKnownAttributesTestBase.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Attributes/WellKnownAttributesTestBase.cs
rename to src/Compilers/CSharp/Test/Emit2/Attributes/WellKnownAttributesTestBase.cs
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/UnmanagedTypeModifierTests.cs b/src/Compilers/CSharp/Test/Emit2/Emit/UnmanagedTypeModifierTests.cs
similarity index 100%
rename from src/Compilers/CSharp/Test/Emit/Emit/UnmanagedTypeModifierTests.cs
rename to src/Compilers/CSharp/Test/Emit2/Emit/UnmanagedTypeModifierTests.cs

From defd26343cd043b8c0561294ddb236c9dc8e9d5e Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Mon, 10 Jan 2022 14:57:01 -0800
Subject: [PATCH 298/444] Update CSharpUseTupleSwapCodeFixProvider for
 top-level statements

Fixes #58759
---
 .../CSharpUseTupleSwapCodeFixProvider.cs      |  6 ++--
 .../Tests/UseTupleSwap/UseTupleSwapTests.cs   | 28 +++++++++++++++++++
 2 files changed, 31 insertions(+), 3 deletions(-)

diff --git a/src/Analyzers/CSharp/CodeFixes/UseTupleSwap/CSharpUseTupleSwapCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/UseTupleSwap/CSharpUseTupleSwapCodeFixProvider.cs
index 2e09f3def0a69..0eb78ed1f3d54 100644
--- a/src/Analyzers/CSharp/CodeFixes/UseTupleSwap/CSharpUseTupleSwapCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/UseTupleSwap/CSharpUseTupleSwapCodeFixProvider.cs
@@ -58,10 +58,10 @@ protected override Task FixAllAsync(
         private static void FixOne(
             SyntaxEditor editor, Diagnostic diagnostic, CancellationToken cancellationToken)
         {
-            var localDeclarationStatement = (LocalDeclarationStatementSyntax)diagnostic.AdditionalLocations[0].FindNode(cancellationToken);
+            var localDeclarationStatement = (LocalDeclarationStatementSyntax)diagnostic.AdditionalLocations[0].FindNode(getInnermostNodeForTie: true, cancellationToken);
             // `expr_a = expr_b`;
-            var firstAssignmentStatement = (ExpressionStatementSyntax)diagnostic.AdditionalLocations[1].FindNode(cancellationToken);
-            var secondAssignmentStatment = (ExpressionStatementSyntax)diagnostic.AdditionalLocations[2].FindNode(cancellationToken);
+            var firstAssignmentStatement = (ExpressionStatementSyntax)diagnostic.AdditionalLocations[1].FindNode(getInnermostNodeForTie: true, cancellationToken);
+            var secondAssignmentStatment = (ExpressionStatementSyntax)diagnostic.AdditionalLocations[2].FindNode(getInnermostNodeForTie: true, cancellationToken);
 
             editor.RemoveNode(firstAssignmentStatement);
             editor.RemoveNode(secondAssignmentStatment);
diff --git a/src/Analyzers/CSharp/Tests/UseTupleSwap/UseTupleSwapTests.cs b/src/Analyzers/CSharp/Tests/UseTupleSwap/UseTupleSwapTests.cs
index 299967479636c..c7645212249da 100644
--- a/src/Analyzers/CSharp/Tests/UseTupleSwap/UseTupleSwapTests.cs
+++ b/src/Analyzers/CSharp/Tests/UseTupleSwap/UseTupleSwapTests.cs
@@ -8,6 +8,8 @@
 using Microsoft.CodeAnalysis.CSharp.UseTupleSwap;
 using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
 using Microsoft.CodeAnalysis.Test.Utilities;
+using Microsoft.CodeAnalysis.Testing;
+using Roslyn.Test.Utilities;
 using Xunit;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.UseTupleSwap
@@ -442,5 +444,31 @@ void M(string[] args)
                 FixedCode = code,
             }.RunAsync();
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseLocalFunction)]
+        [WorkItem(58759, "https://github.com/dotnet/roslyn/issues/58759")]
+        public async Task TestTopLevelStatements()
+        {
+            await new VerifyCS.Test
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                LanguageVersion = LanguageVersion.CSharp9,
+                TestState =
+                {
+                    Sources =
+                    {
+                        @"
+[|var|] temp = args[0];
+args[0] = args[1];
+args[1] = temp;
+",
+                    },
+                    OutputKind = OutputKind.ConsoleApplication,
+                },
+                FixedCode = @"
+(args[1], args[0]) = (args[0], args[1]);
+",
+            }.RunAsync();
+        }
     }
 }

From bcc2112d0d8caf1d62b1112dff734e674417dc36 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Fri, 7 Jan 2022 11:54:36 -0800
Subject: [PATCH 299/444] Avoid cyclic references during incremental project
 update

This change operates under the assumption that neither the starting
state nor the final state include any cycles. By removing all project
references from projects that change their reference sets prior to other
work, we ensure extraneous references cannot lead to an invalid
intermediate state.

This increases the amount of work required to complete an incremental
update when project references change, but does not impact the more
common updates where all project references are unchanged.

Fixes #52578
---
 .../Services/ServiceHubServicesTests.cs       | 48 +++++++++++++++++++
 .../Host/RemoteWorkspace.SolutionCreator.cs   | 23 +++++++--
 2 files changed, 67 insertions(+), 4 deletions(-)

diff --git a/src/VisualStudio/Core/Test.Next/Services/ServiceHubServicesTests.cs b/src/VisualStudio/Core/Test.Next/Services/ServiceHubServicesTests.cs
index 32c1f79810c4a..987204412186e 100644
--- a/src/VisualStudio/Core/Test.Next/Services/ServiceHubServicesTests.cs
+++ b/src/VisualStudio/Core/Test.Next/Services/ServiceHubServicesTests.cs
@@ -307,6 +307,54 @@ await solution.State.GetChecksumAsync(CancellationToken.None),
                 await remoteWorkspace.CurrentSolution.State.GetChecksumAsync(CancellationToken.None));
         }
 
+        [Fact]
+        [WorkItem(52578, "https://github.com/dotnet/roslyn/issues/52578")]
+        public async Task TestIncrementalUpdateHandlesReferenceReversal()
+        {
+            using var workspace = CreateWorkspace();
+
+            using var client = await InProcRemoteHostClient.GetTestClientAsync(workspace).ConfigureAwait(false);
+            var remoteWorkspace = client.GetRemoteWorkspace();
+
+            var solution = workspace.CurrentSolution;
+            solution = AddProject(solution, LanguageNames.CSharp, documents: Array.Empty<string>(), additionalDocuments: Array.Empty<string>(), p2pReferences: Array.Empty<ProjectId>());
+            var projectId1 = solution.ProjectIds.Single();
+            solution = AddProject(solution, LanguageNames.CSharp, documents: Array.Empty<string>(), additionalDocuments: Array.Empty<string>(), p2pReferences: Array.Empty<ProjectId>());
+            var projectId2 = solution.ProjectIds.Where(id => id != projectId1).Single();
+
+            var project1ToProject2 = new ProjectReference(projectId2);
+            var project2ToProject1 = new ProjectReference(projectId1);
+
+            // Start with projectId1 -> projectId2
+            solution = solution.AddProjectReference(projectId1, project1ToProject2);
+
+            // verify initial setup
+            await UpdatePrimaryWorkspace(client, solution);
+            await VerifyAssetStorageAsync(client, solution, includeProjectCones: false);
+
+            Assert.Equal(
+                await solution.State.GetChecksumAsync(CancellationToken.None),
+                await remoteWorkspace.CurrentSolution.State.GetChecksumAsync(CancellationToken.None));
+
+            // reverse project references and incrementally update
+            solution = solution.RemoveProjectReference(projectId1, project1ToProject2);
+            solution = solution.AddProjectReference(projectId2, project2ToProject1);
+            await UpdatePrimaryWorkspace(client, solution);
+
+            Assert.Equal(
+                await solution.State.GetChecksumAsync(CancellationToken.None),
+                await remoteWorkspace.CurrentSolution.State.GetChecksumAsync(CancellationToken.None));
+
+            // reverse project references again and incrementally update
+            solution = solution.RemoveProjectReference(projectId2, project2ToProject1);
+            solution = solution.AddProjectReference(projectId1, project1ToProject2);
+            await UpdatePrimaryWorkspace(client, solution);
+
+            Assert.Equal(
+                await solution.State.GetChecksumAsync(CancellationToken.None),
+                await remoteWorkspace.CurrentSolution.State.GetChecksumAsync(CancellationToken.None));
+        }
+
         [Fact]
         public void TestRemoteWorkspaceCircularReferences()
         {
diff --git a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.SolutionCreator.cs b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.SolutionCreator.cs
index 37d81cffed904..e650ef41b4af7 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.SolutionCreator.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.SolutionCreator.cs
@@ -150,7 +150,8 @@ private async Task<Solution> UpdateProjectsAsync(Solution solution, HashSet<Chec
                     }
                 }
 
-                // changed project
+                // remove all project references from projects that changed. this ensures exceptions will not occur for
+                // cyclic references during an incremental update.
                 foreach (var (projectId, newProjectChecksums) in newMap)
                 {
                     if (!oldMap.TryGetValue(projectId, out var oldProjectChecksums))
@@ -158,9 +159,10 @@ private async Task<Solution> UpdateProjectsAsync(Solution solution, HashSet<Chec
                         continue;
                     }
 
-                    Contract.ThrowIfTrue(oldProjectChecksums.Checksum == newProjectChecksums.Checksum);
-
-                    solution = await UpdateProjectAsync(solution.GetProject(projectId)!, oldProjectChecksums, newProjectChecksums).ConfigureAwait(false);
+                    if (oldProjectChecksums.ProjectReferences.Checksum != newProjectChecksums.ProjectReferences.Checksum)
+                    {
+                        solution = solution.WithProjectReferences(projectId, SpecializedCollections.EmptyEnumerable<ProjectReference>());
+                    }
                 }
 
                 // removed project
@@ -173,6 +175,19 @@ private async Task<Solution> UpdateProjectsAsync(Solution solution, HashSet<Chec
                     }
                 }
 
+                // changed project
+                foreach (var (projectId, newProjectChecksums) in newMap)
+                {
+                    if (!oldMap.TryGetValue(projectId, out var oldProjectChecksums))
+                    {
+                        continue;
+                    }
+
+                    Contract.ThrowIfTrue(oldProjectChecksums.Checksum == newProjectChecksums.Checksum);
+
+                    solution = await UpdateProjectAsync(solution.GetProject(projectId)!, oldProjectChecksums, newProjectChecksums).ConfigureAwait(false);
+                }
+
                 return solution;
             }
 

From 3eccd08bf9e1d2b5602e2d1d3f8bae21672b48f8 Mon Sep 17 00:00:00 2001
From: Jared Parsons <jaredpparsons@gmail.com>
Date: Mon, 10 Jan 2022 16:19:15 -0800
Subject: [PATCH 300/444] Update language feature status (#58758)

---
 docs/Language Feature Status.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/docs/Language Feature Status.md b/docs/Language Feature Status.md
index 6676470c7d0e8..4188a05fdd7ee 100644
--- a/docs/Language Feature Status.md	
+++ b/docs/Language Feature Status.md	
@@ -23,6 +23,10 @@ efforts behind them.
 | [Top Level statement attribute specifiers](https://github.com/dotnet/csharplang/issues/5045) | [main-attributes](https://github.com/dotnet/roslyn/tree/features/main-attributes) | [In Progress](https://github.com/dotnet/roslyn/issues/57047) | [chsienki](https://github.com/chsienki) | TBD | [jaredpar](https://github.com/jaredpar) |
 | [Primary Constructors](https://github.com/dotnet/csharplang/issues/2691) | [primary-constructors](https://github.com/dotnet/roslyn/tree/features/primary-constructors) | [In Progress](https://github.com/dotnet/roslyn/issues/57048) | TBD | TBD | [MadsTorgersen](https://github.com/MadsTorgersen) |
 | [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) |
+| [Cache delegates for static method group](https://github.com/dotnet/roslyn/issues/5835) | main | [In Progress](https://github.com/dotnet/roslyn/pull/58288) | [pawchen](https://github.com/pawchen) | [AlekseyTs](https://github.com/AlekseyTs), [jcouv](https://github.com/jcouv) | [AlekseyTs](https://github.com/AlekseyTs) |
+| [Switch on ReadOnlySpan<char>](https://github.com/dotnet/csharplang/issues/1881) | main | [In Progress](https://github.com/dotnet/roslyn/pull/44388) | [YairHalberstadt ](https://github.com/YairHalberstadt) | [cston](https://github.com/cston), [RikkiGibson](https://github.com/RikkiGibson) | [jcouv](https://github.com/jcouv) |
+| [nameof accessing instance memebers](https://github.com/dotnet/roslyn/issues/40229) | main | [In Progress](https://github.com/dotnet/roslyn/pull/48754) | [YairHalberstadt ](https://github.com/YairHalberstadt) | [333fred](https://github.com/333fred), [AlekseyTs](https://github.com/AlekseyTs)  | [333fred](https://github.com/333fred) |
+
   
 # C# 10.0
 

From 6d9b18ca1540347201f6de42e75d34a20849a037 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Tue, 11 Jan 2022 10:20:09 -0800
Subject: [PATCH 301/444] UPdate test

---
 src/Workspaces/CSharpTest/Formatting/FormattingTests.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Workspaces/CSharpTest/Formatting/FormattingTests.cs b/src/Workspaces/CSharpTest/Formatting/FormattingTests.cs
index a19b4808c5618..d33aca02deba6 100644
--- a/src/Workspaces/CSharpTest/Formatting/FormattingTests.cs
+++ b/src/Workspaces/CSharpTest/Formatting/FormattingTests.cs
@@ -4510,7 +4510,7 @@ class innerClass
 {
     public innerClass()
     {
-        myDelegate x = (int y = 1) => { return; };
+        myDelegate x = (int y=1) => { return; };
     }
 }";
 

From 0613817bdba10db04ec072d680d17aa8137ef541 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Tue, 11 Jan 2022 10:21:52 -0800
Subject: [PATCH 302/444] Fix comment

---
 src/Compilers/CSharp/Portable/Parser/LanguageParser.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
index c1c64a833999a..ec5ba76eb5b4f 100644
--- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
+++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
@@ -13112,8 +13112,8 @@ private ParameterSyntax ParseLambdaParameter()
             ParseParameterNullCheck(out var exclamationExclamationToken, out var equalsToken);
 
             // If we didn't already consume an equals sign as part of !!=, then try to scan one out now. Note: this is
-            // not legal code.  But we detect it so that we can give the user a good message, and so we don't completely
-            // off the rails.
+            // not legal code.  But we detect it so that we can give the user a good message, and so we don't go
+            // completely off the rails.
             //
             // Note: we add the `= value` as skipped trivia to either the identifier or `!!` (if we have the latter).
             // This allows us to handle this code without ever showing it the binding phases.  We could consider

From 8bb17dbf7bc118af7f97eb63eafebb44cac7fde9 Mon Sep 17 00:00:00 2001
From: Alireza Habibi <habibi.alireza@outlook.com>
Date: Tue, 11 Jan 2022 22:04:26 +0330
Subject: [PATCH 303/444] Remove unused resource string (#58772)

---
 src/Compilers/CSharp/Portable/CSharpResources.resx           | 5 +----
 src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf     | 5 -----
 src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf     | 5 -----
 src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf     | 5 -----
 src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf     | 5 -----
 src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf     | 5 -----
 src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf     | 5 -----
 src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf     | 5 -----
 src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf     | 5 -----
 src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf  | 5 -----
 src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf     | 5 -----
 src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf     | 5 -----
 .../CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf          | 5 -----
 .../CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf          | 5 -----
 14 files changed, 1 insertion(+), 69 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/CSharpResources.resx b/src/Compilers/CSharp/Portable/CSharpResources.resx
index 4220added2ad8..4ce105b21ba20 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.resx
+++ b/src/Compilers/CSharp/Portable/CSharpResources.resx
@@ -6757,9 +6757,6 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="IDS_FeatureListPattern" xml:space="preserve">
     <value>list pattern</value>
   </data>
-  <data name="IDS_FeatureLengthPattern" xml:space="preserve">
-    <value>length pattern</value>
-  </data>
   <data name="ERR_UnsupportedTypeForListPattern" xml:space="preserve">
     <value>List patterns may not be used for a value of type '{0}'.</value>
   </data>
@@ -6944,4 +6941,4 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="WRN_LowerCaseTypeName_Title" xml:space="preserve">
     <value>The type name only contains lower-cased ascii characters. Such names may become reserved for the language.</value>
   </data>
-</root>
+</root>
\ No newline at end of file
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
index ec9e560cac3c7..fe10c752dbd73 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
@@ -1352,11 +1352,6 @@
         <target state="translated">návratový typ lambda</target>
         <note />
       </trans-unit>
-      <trans-unit id="IDS_FeatureLengthPattern">
-        <source>length pattern</source>
-        <target state="new">length pattern</target>
-        <note />
-      </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
         <source>line span directive</source>
         <target state="translated">direktiva line span</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
index 149f82bf4d4a3..0d9b6d29889fe 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
@@ -1352,11 +1352,6 @@
         <target state="translated">Lambda-Rückgabetyp</target>
         <note />
       </trans-unit>
-      <trans-unit id="IDS_FeatureLengthPattern">
-        <source>length pattern</source>
-        <target state="new">length pattern</target>
-        <note />
-      </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
         <source>line span directive</source>
         <target state="translated">Zeilenabstand-Anweisung</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
index c3b78832301d3..ef014e0aebe0f 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
@@ -1352,11 +1352,6 @@
         <target state="translated">tipo de valor devuelto de lambda</target>
         <note />
       </trans-unit>
-      <trans-unit id="IDS_FeatureLengthPattern">
-        <source>length pattern</source>
-        <target state="new">length pattern</target>
-        <note />
-      </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
         <source>line span directive</source>
         <target state="translated">directiva de intervalo de línea</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
index d22a3a148793f..60a3bfb9cf4bd 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
@@ -1352,11 +1352,6 @@
         <target state="translated">type de retour lambda</target>
         <note />
       </trans-unit>
-      <trans-unit id="IDS_FeatureLengthPattern">
-        <source>length pattern</source>
-        <target state="new">length pattern</target>
-        <note />
-      </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
         <source>line span directive</source>
         <target state="translated">directive de l’étendue de ligne</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
index 477da70abd8da..2a73814a12f8c 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
@@ -1352,11 +1352,6 @@
         <target state="translated">tipo restituito dell'espressione lambda</target>
         <note />
       </trans-unit>
-      <trans-unit id="IDS_FeatureLengthPattern">
-        <source>length pattern</source>
-        <target state="new">length pattern</target>
-        <note />
-      </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
         <source>line span directive</source>
         <target state="translated">direttiva per intervallo di riga</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
index db71f23a2a21a..7fdb148cd31f0 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
@@ -1352,11 +1352,6 @@
         <target state="translated">ラムダ戻り値の型</target>
         <note />
       </trans-unit>
-      <trans-unit id="IDS_FeatureLengthPattern">
-        <source>length pattern</source>
-        <target state="new">length pattern</target>
-        <note />
-      </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
         <source>line span directive</source>
         <target state="translated">line span ディレクティブ</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
index 764c202b48c21..afea15f43ed4e 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
@@ -1352,11 +1352,6 @@
         <target state="translated">람다 반환 유형</target>
         <note />
       </trans-unit>
-      <trans-unit id="IDS_FeatureLengthPattern">
-        <source>length pattern</source>
-        <target state="new">length pattern</target>
-        <note />
-      </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
         <source>line span directive</source>
         <target state="translated">라인 범위 지시문</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
index 2976cc0eaad15..d8a86444ac9f6 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
@@ -1352,11 +1352,6 @@
         <target state="translated">zwracany typ lambda</target>
         <note />
       </trans-unit>
-      <trans-unit id="IDS_FeatureLengthPattern">
-        <source>length pattern</source>
-        <target state="new">length pattern</target>
-        <note />
-      </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
         <source>line span directive</source>
         <target state="translated">dyrektywa zakresu wierszy</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
index 06a92d1c4a239..cd71d97bfe5f0 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
@@ -1352,11 +1352,6 @@
         <target state="translated">tipo de retorno de lambda</target>
         <note />
       </trans-unit>
-      <trans-unit id="IDS_FeatureLengthPattern">
-        <source>length pattern</source>
-        <target state="new">length pattern</target>
-        <note />
-      </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
         <source>line span directive</source>
         <target state="translated">diretiva de extensão de linha</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
index 2b6b46e7bbb05..d23379f62d4c0 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
@@ -1352,11 +1352,6 @@
         <target state="translated">тип возвращаемого значения лямбда</target>
         <note />
       </trans-unit>
-      <trans-unit id="IDS_FeatureLengthPattern">
-        <source>length pattern</source>
-        <target state="new">length pattern</target>
-        <note />
-      </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
         <source>line span directive</source>
         <target state="translated">директива line span</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
index e17eea7c9feb4..2b7951794a4f5 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
@@ -1352,11 +1352,6 @@
         <target state="translated">lambda dönüş türü</target>
         <note />
       </trans-unit>
-      <trans-unit id="IDS_FeatureLengthPattern">
-        <source>length pattern</source>
-        <target state="new">length pattern</target>
-        <note />
-      </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
         <source>line span directive</source>
         <target state="translated">satır aralığı yönergesi</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
index b64286a6a6254..dc626757bee24 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
@@ -1352,11 +1352,6 @@
         <target state="translated">lambda 返回类型</target>
         <note />
       </trans-unit>
-      <trans-unit id="IDS_FeatureLengthPattern">
-        <source>length pattern</source>
-        <target state="new">length pattern</target>
-        <note />
-      </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
         <source>line span directive</source>
         <target state="translated">行跨度指令</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
index cc8b09c93001a..1c795af698a23 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
@@ -1352,11 +1352,6 @@
         <target state="translated">lambda 傳回型別</target>
         <note />
       </trans-unit>
-      <trans-unit id="IDS_FeatureLengthPattern">
-        <source>length pattern</source>
-        <target state="new">length pattern</target>
-        <note />
-      </trans-unit>
       <trans-unit id="IDS_FeatureLineSpanDirective">
         <source>line span directive</source>
         <target state="translated">line span 指示詞</target>

From 26393a41932fcd248f97a4fe9c0ebe5cc49a47b6 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Tue, 11 Jan 2022 10:54:58 -0800
Subject: [PATCH 304/444] Unify logic and add tests

---
 .../CSharp/Portable/Parser/LanguageParser.cs  |  36 +++-
 .../Syntax/Parsing/DeclarationParsingTests.cs | 184 ++++++++++++++----
 2 files changed, 178 insertions(+), 42 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
index ec5ba76eb5b4f..252d63f75fd0c 100644
--- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
+++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
@@ -4387,16 +4387,21 @@ private ParameterSyntax ParseParameter()
             {
                 this.ParseParameterModifiers(modifiers);
 
+                TypeSyntax type;
+                SyntaxToken identifier;
+
                 if (this.CurrentToken.Kind == SyntaxKind.ArgListKeyword)
                 {
                     // We store an __arglist parameter as a parameter with null type and whose 
                     // .Identifier has the kind ArgListKeyword.
-                    return _syntaxFactory.Parameter(
-                        attributes, modifiers.ToList(), type: null, this.EatToken(SyntaxKind.ArgListKeyword), exclamationExclamationToken: null, @default: null);
+                    type = null;
+                    identifier = this.EatToken(SyntaxKind.ArgListKeyword);
+                }
+                else
+                {
+                    type = this.ParseType(mode: ParseTypeMode.Parameter);
+                    identifier = this.ParseIdentifierToken();
                 }
-
-                var type = this.ParseType(mode: ParseTypeMode.Parameter);
-                var identifier = this.ParseIdentifierToken();
 
                 // When the user type "int goo[]", give them a useful error
                 if (this.CurrentToken.Kind is SyntaxKind.OpenBracketToken && this.PeekToken(1).Kind is SyntaxKind.CloseBracketToken)
@@ -4415,6 +4420,27 @@ private ParameterSyntax ParseParameter()
                 if (equalsToken != null)
                     equalsValueClause = CheckFeatureAvailability(_syntaxFactory.EqualsValueClause(equalsToken, this.ParseExpressionCore()), MessageID.IDS_FeatureOptionalParameter);
 
+                if (type == null)
+                {
+                    // in the __arglist case, all other parameter pieces are not legal.  So attach anything else we get
+                    // to the identifier.
+                    if (exclamationExclamationToken != null)
+                    {
+                        if (!exclamationExclamationToken.ContainsDiagnostics)
+                            exclamationExclamationToken = AddError(exclamationExclamationToken, ErrorCode.ERR_UnexpectedToken, exclamationExclamationToken.ToString());
+
+                        identifier = AddTrailingSkippedSyntax(identifier, exclamationExclamationToken);
+                        exclamationExclamationToken = null;
+                    }
+
+                    if (equalsValueClause != null)
+                    {
+                        identifier = AddTrailingSkippedSyntax(identifier,
+                            AddErrorToFirstToken(equalsValueClause, ErrorCode.ERR_DefaultValueNotAllowed));
+                        equalsValueClause = null;
+                    }
+                }
+
                 return _syntaxFactory.Parameter(attributes, modifiers.ToList(), type, identifier, exclamationExclamationToken, equalsValueClause);
             }
             finally
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs
index 8fa08646a5360..d288930566db9 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs
@@ -7432,12 +7432,12 @@ public void TestOptParamMethodDeclarationWithNullValidationNoSpaces()
         }
 
         [Fact]
-        public void TestNullCheckedArgList()
+        public void TestNullCheckedArgList1()
         {
             UsingStatement(@"void M(__arglist!) { }", options: TestOptions.RegularPreview,
-                    // (1,17): error CS1003: Syntax error, ',' expected
+                    // (1,17): error CS1003: Syntax error, '!!' expected
                     // void M(__arglist!) { }
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments(",", "!").WithLocation(1, 17));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 17));
             N(SyntaxKind.LocalFunctionStatement);
             {
                 N(SyntaxKind.PredefinedType);
@@ -7464,21 +7464,12 @@ public void TestNullCheckedArgList()
         }
 
         [Fact]
-        public void TestArgListWithBrackets()
+        public void TestNullCheckedArgList2()
         {
-            UsingStatement(@"void M(__arglist[]) { }", options: TestOptions.RegularPreview,
-                    // (1,17): error CS1003: Syntax error, ',' expected
-                    // void M(__arglist[]) { }
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "[").WithArguments(",", "[").WithLocation(1, 17),
-                    // (1,18): error CS1001: Identifier expected
-                    // void M(__arglist[]) { }
-                    Diagnostic(ErrorCode.ERR_IdentifierExpected, "]").WithLocation(1, 18),
-                    // (1,19): error CS1031: Type expected
-                    // void M(__arglist[]) { }
-                    Diagnostic(ErrorCode.ERR_TypeExpected, ")").WithLocation(1, 19),
-                    // (1,19): error CS1001: Identifier expected
-                    // void M(__arglist[]) { }
-                    Diagnostic(ErrorCode.ERR_IdentifierExpected, ")").WithLocation(1, 19));
+            UsingStatement(@"void M(__arglist!!) { }", options: TestOptions.RegularPreview,
+                    // (1,17): error CS1073: Unexpected token '!!'
+                    // void M(__arglist!!) { }
+                    Diagnostic(ErrorCode.ERR_UnexpectedToken, "!!").WithArguments("!!").WithLocation(1, 17));
             N(SyntaxKind.LocalFunctionStatement);
             {
                 N(SyntaxKind.PredefinedType);
@@ -7493,26 +7484,145 @@ public void TestArgListWithBrackets()
                     {
                         N(SyntaxKind.ArgListKeyword);
                     }
-                    M(SyntaxKind.CommaToken);
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestNullCheckedArgList3()
+        {
+            UsingStatement(@"void M(__arglist!! = null) { }", options: TestOptions.RegularPreview,
+                    // (1,17): error CS1073: Unexpected token '!!'
+                    // void M(__arglist!! = null) { }
+                    Diagnostic(ErrorCode.ERR_UnexpectedToken, "!!").WithArguments("!!").WithLocation(1, 17),
+                    // (1,20): error CS1065: Default values are not valid in this context.
+                    // void M(__arglist!! = null) { }
+                    Diagnostic(ErrorCode.ERR_DefaultValueNotAllowed, "=").WithLocation(1, 20));
+            N(SyntaxKind.LocalFunctionStatement);
+            {
+                N(SyntaxKind.PredefinedType);
+                {
+                    N(SyntaxKind.VoidKeyword);
+                }
+                N(SyntaxKind.IdentifierToken, "M");
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
                     N(SyntaxKind.Parameter);
                     {
-                        N(SyntaxKind.AttributeList);
-                        {
-                            N(SyntaxKind.OpenBracketToken);
-                            M(SyntaxKind.Attribute);
-                            {
-                                M(SyntaxKind.IdentifierName);
-                                {
-                                    M(SyntaxKind.IdentifierToken);
-                                }
-                            }
-                            N(SyntaxKind.CloseBracketToken);
-                        }
-                        M(SyntaxKind.IdentifierName);
-                        {
-                            M(SyntaxKind.IdentifierToken);
-                        }
-                        M(SyntaxKind.IdentifierToken);
+                        N(SyntaxKind.ArgListKeyword);
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestNullCheckedArgList4()
+        {
+            UsingStatement(@"void M(__arglist!!= null) { }", options: TestOptions.RegularPreview,
+                    // (1,17): error CS1073: Unexpected token '!!'
+                    // void M(__arglist!!= null) { }
+                    Diagnostic(ErrorCode.ERR_UnexpectedToken, "!!").WithArguments("!!").WithLocation(1, 17),
+                    // (1,19): error CS1065: Default values are not valid in this context.
+                    // void M(__arglist!!= null) { }
+                    Diagnostic(ErrorCode.ERR_DefaultValueNotAllowed, "=").WithLocation(1, 19));
+            N(SyntaxKind.LocalFunctionStatement);
+            {
+                N(SyntaxKind.PredefinedType);
+                {
+                    N(SyntaxKind.VoidKeyword);
+                }
+                N(SyntaxKind.IdentifierToken, "M");
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.ArgListKeyword);
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestNullCheckedArgList5()
+        {
+            UsingStatement(@"void M(__arglist[]!!= null) { }", options: TestOptions.RegularPreview,
+                    // (1,17): error CS1552: Array type specifier, [], must appear before parameter name
+                    // void M(__arglist[]!!= null) { }
+                    Diagnostic(ErrorCode.ERR_BadArraySyntax, "[").WithLocation(1, 17),
+                    // (1,19): error CS1073: Unexpected token '!!'
+                    // void M(__arglist[]!!= null) { }
+                    Diagnostic(ErrorCode.ERR_UnexpectedToken, "!!").WithArguments("!!").WithLocation(1, 19),
+                    // (1,21): error CS1065: Default values are not valid in this context.
+                    // void M(__arglist[]!!= null) { }
+                    Diagnostic(ErrorCode.ERR_DefaultValueNotAllowed, "=").WithLocation(1, 21));
+            N(SyntaxKind.LocalFunctionStatement);
+            {
+                N(SyntaxKind.PredefinedType);
+                {
+                    N(SyntaxKind.VoidKeyword);
+                }
+                N(SyntaxKind.IdentifierToken, "M");
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.ArgListKeyword);
+                    }
+                    N(SyntaxKind.CloseParenToken);
+                }
+                N(SyntaxKind.Block);
+                {
+                    N(SyntaxKind.OpenBraceToken);
+                    N(SyntaxKind.CloseBraceToken);
+                }
+            }
+            EOF();
+        }
+
+        [Fact]
+        public void TestArgListWithBrackets()
+        {
+            UsingStatement(@"void M(__arglist[]) { }", options: TestOptions.RegularPreview,
+                // (1,17): error CS1552: Array type specifier, [], must appear before parameter name
+                // void M(__arglist[]) { }
+                Diagnostic(ErrorCode.ERR_BadArraySyntax, "[").WithLocation(1, 17));
+            N(SyntaxKind.LocalFunctionStatement);
+            {
+                N(SyntaxKind.PredefinedType);
+                {
+                    N(SyntaxKind.VoidKeyword);
+                }
+                N(SyntaxKind.IdentifierToken, "M");
+                N(SyntaxKind.ParameterList);
+                {
+                    N(SyntaxKind.OpenParenToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.ArgListKeyword);
                     }
                     N(SyntaxKind.CloseParenToken);
                 }
@@ -7529,9 +7639,9 @@ public void TestArgListWithBrackets()
         public void TestArgListWithDefaultValue()
         {
             UsingStatement(@"void M(__arglist = null) { }", options: TestOptions.RegularPreview,
-                    // (1,18): error CS1003: Syntax error, ',' expected
+                    // (1,18): error CS1065: Default values are not valid in this context.
                     // void M(__arglist = null) { }
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments(",", "=").WithLocation(1, 18));
+                    Diagnostic(ErrorCode.ERR_DefaultValueNotAllowed, "=").WithLocation(1, 18));
             N(SyntaxKind.LocalFunctionStatement);
             {
                 N(SyntaxKind.PredefinedType);

From 349d9cc7d6a23ebb7c0c6319c37abb3a533494d5 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 11 Jan 2022 09:09:49 -1000
Subject: [PATCH 305/444] Update
 src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

Co-authored-by: Charles Stoner <10732005+cston@users.noreply.github.com>
---
 src/Compilers/CSharp/Portable/Parser/LanguageParser.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
index 252d63f75fd0c..4ad75a9e4cc0e 100644
--- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
+++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
@@ -4422,7 +4422,7 @@ private ParameterSyntax ParseParameter()
 
                 if (type == null)
                 {
-                    // in the __arglist case, all other parameter pieces are not legal.  So attach anything else we get
+                    // In the __arglist case, none of the other parameter pieces are legal, so attach anything else we get
                     // to the identifier.
                     if (exclamationExclamationToken != null)
                     {

From acdabcb2c7606698ed4c435d0437c69cb1e78742 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Tue, 11 Jan 2022 11:33:30 -0800
Subject: [PATCH 306/444] REvert __arglist changes

---
 .../CSharp/Portable/Parser/LanguageParser.cs  |  46 ++-----
 .../Syntax/Parsing/DeclarationParsingTests.cs | 113 +++++++++++++-----
 2 files changed, 95 insertions(+), 64 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
index 252d63f75fd0c..bfe6488af215c 100644
--- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
+++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
@@ -4373,6 +4373,8 @@ private static bool CanReuseParameter(CSharp.Syntax.ParameterSyntax parameter)
             return true;
         }
 
+#nullable enable
+
         private ParameterSyntax ParseParameter()
         {
             if (this.IsIncrementalAndFactoryContextMatches && CanReuseParameter(this.CurrentNode as CSharp.Syntax.ParameterSyntax))
@@ -4387,22 +4389,17 @@ private ParameterSyntax ParseParameter()
             {
                 this.ParseParameterModifiers(modifiers);
 
-                TypeSyntax type;
-                SyntaxToken identifier;
-
                 if (this.CurrentToken.Kind == SyntaxKind.ArgListKeyword)
                 {
                     // We store an __arglist parameter as a parameter with null type and whose 
                     // .Identifier has the kind ArgListKeyword.
-                    type = null;
-                    identifier = this.EatToken(SyntaxKind.ArgListKeyword);
-                }
-                else
-                {
-                    type = this.ParseType(mode: ParseTypeMode.Parameter);
-                    identifier = this.ParseIdentifierToken();
+                    return _syntaxFactory.Parameter(
+                        attributes, modifiers.ToList(), type: null, this.EatToken(SyntaxKind.ArgListKeyword), exclamationExclamationToken: null, @default: null);
                 }
 
+                var type = this.ParseType(mode: ParseTypeMode.Parameter);
+                var identifier = this.ParseIdentifierToken();
+
                 // When the user type "int goo[]", give them a useful error
                 if (this.CurrentToken.Kind is SyntaxKind.OpenBracketToken && this.PeekToken(1).Kind is SyntaxKind.CloseBracketToken)
                 {
@@ -4416,30 +4413,9 @@ private ParameterSyntax ParseParameter()
                 // If we didn't already consume an equals sign as part of !!=, then try to scan one out now.
                 equalsToken ??= TryEatToken(SyntaxKind.EqualsToken);
 
-                EqualsValueClauseSyntax equalsValueClause = null;
-                if (equalsToken != null)
-                    equalsValueClause = CheckFeatureAvailability(_syntaxFactory.EqualsValueClause(equalsToken, this.ParseExpressionCore()), MessageID.IDS_FeatureOptionalParameter);
-
-                if (type == null)
-                {
-                    // in the __arglist case, all other parameter pieces are not legal.  So attach anything else we get
-                    // to the identifier.
-                    if (exclamationExclamationToken != null)
-                    {
-                        if (!exclamationExclamationToken.ContainsDiagnostics)
-                            exclamationExclamationToken = AddError(exclamationExclamationToken, ErrorCode.ERR_UnexpectedToken, exclamationExclamationToken.ToString());
-
-                        identifier = AddTrailingSkippedSyntax(identifier, exclamationExclamationToken);
-                        exclamationExclamationToken = null;
-                    }
-
-                    if (equalsValueClause != null)
-                    {
-                        identifier = AddTrailingSkippedSyntax(identifier,
-                            AddErrorToFirstToken(equalsValueClause, ErrorCode.ERR_DefaultValueNotAllowed));
-                        equalsValueClause = null;
-                    }
-                }
+                var equalsValueClause = equalsToken == null
+                    ? null
+                    : CheckFeatureAvailability(_syntaxFactory.EqualsValueClause(equalsToken, this.ParseExpressionCore()), MessageID.IDS_FeatureOptionalParameter);
 
                 return _syntaxFactory.Parameter(attributes, modifiers.ToList(), type, identifier, exclamationExclamationToken, equalsValueClause);
             }
@@ -4449,8 +4425,6 @@ private ParameterSyntax ParseParameter()
             }
         }
 
-#nullable enable
-
         /// <summary>
         /// Parses the <c>!!</c> following a parameter type and identifier.  If the token
         /// is followed by <c>!!=</c> or <c>! !=</c>, then the final equals will be returned through <paramref
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs
index d288930566db9..f6c25667d5b3e 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/DeclarationParsingTests.cs
@@ -7435,9 +7435,9 @@ public void TestOptParamMethodDeclarationWithNullValidationNoSpaces()
         public void TestNullCheckedArgList1()
         {
             UsingStatement(@"void M(__arglist!) { }", options: TestOptions.RegularPreview,
-                    // (1,17): error CS1003: Syntax error, '!!' expected
+                    // (1,17): error CS1003: Syntax error, ',' expected
                     // void M(__arglist!) { }
-                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments("!!", "!").WithLocation(1, 17));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments(",", "!").WithLocation(1, 17));
             N(SyntaxKind.LocalFunctionStatement);
             {
                 N(SyntaxKind.PredefinedType);
@@ -7467,9 +7467,9 @@ public void TestNullCheckedArgList1()
         public void TestNullCheckedArgList2()
         {
             UsingStatement(@"void M(__arglist!!) { }", options: TestOptions.RegularPreview,
-                    // (1,17): error CS1073: Unexpected token '!!'
+                    // (1,17): error CS1003: Syntax error, ',' expected
                     // void M(__arglist!!) { }
-                    Diagnostic(ErrorCode.ERR_UnexpectedToken, "!!").WithArguments("!!").WithLocation(1, 17));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments(",", "!").WithLocation(1, 17));
             N(SyntaxKind.LocalFunctionStatement);
             {
                 N(SyntaxKind.PredefinedType);
@@ -7499,12 +7499,9 @@ public void TestNullCheckedArgList2()
         public void TestNullCheckedArgList3()
         {
             UsingStatement(@"void M(__arglist!! = null) { }", options: TestOptions.RegularPreview,
-                    // (1,17): error CS1073: Unexpected token '!!'
+                    // (1,17): error CS1003: Syntax error, ',' expected
                     // void M(__arglist!! = null) { }
-                    Diagnostic(ErrorCode.ERR_UnexpectedToken, "!!").WithArguments("!!").WithLocation(1, 17),
-                    // (1,20): error CS1065: Default values are not valid in this context.
-                    // void M(__arglist!! = null) { }
-                    Diagnostic(ErrorCode.ERR_DefaultValueNotAllowed, "=").WithLocation(1, 20));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments(",", "!").WithLocation(1, 17));
             N(SyntaxKind.LocalFunctionStatement);
             {
                 N(SyntaxKind.PredefinedType);
@@ -7534,12 +7531,9 @@ public void TestNullCheckedArgList3()
         public void TestNullCheckedArgList4()
         {
             UsingStatement(@"void M(__arglist!!= null) { }", options: TestOptions.RegularPreview,
-                    // (1,17): error CS1073: Unexpected token '!!'
-                    // void M(__arglist!!= null) { }
-                    Diagnostic(ErrorCode.ERR_UnexpectedToken, "!!").WithArguments("!!").WithLocation(1, 17),
-                    // (1,19): error CS1065: Default values are not valid in this context.
+                    // (1,17): error CS1003: Syntax error, ',' expected
                     // void M(__arglist!!= null) { }
-                    Diagnostic(ErrorCode.ERR_DefaultValueNotAllowed, "=").WithLocation(1, 19));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "!").WithArguments(",", "!").WithLocation(1, 17));
             N(SyntaxKind.LocalFunctionStatement);
             {
                 N(SyntaxKind.PredefinedType);
@@ -7569,15 +7563,18 @@ public void TestNullCheckedArgList4()
         public void TestNullCheckedArgList5()
         {
             UsingStatement(@"void M(__arglist[]!!= null) { }", options: TestOptions.RegularPreview,
-                    // (1,17): error CS1552: Array type specifier, [], must appear before parameter name
-                    // void M(__arglist[]!!= null) { }
-                    Diagnostic(ErrorCode.ERR_BadArraySyntax, "[").WithLocation(1, 17),
-                    // (1,19): error CS1073: Unexpected token '!!'
-                    // void M(__arglist[]!!= null) { }
-                    Diagnostic(ErrorCode.ERR_UnexpectedToken, "!!").WithArguments("!!").WithLocation(1, 19),
-                    // (1,21): error CS1065: Default values are not valid in this context.
-                    // void M(__arglist[]!!= null) { }
-                    Diagnostic(ErrorCode.ERR_DefaultValueNotAllowed, "=").WithLocation(1, 21));
+                // (1,17): error CS1003: Syntax error, ',' expected
+                // void M(__arglist[]!!= null) { }
+                Diagnostic(ErrorCode.ERR_SyntaxError, "[").WithArguments(",", "[").WithLocation(1, 17),
+                // (1,18): error CS1001: Identifier expected
+                // void M(__arglist[]!!= null) { }
+                Diagnostic(ErrorCode.ERR_IdentifierExpected, "]").WithLocation(1, 18),
+                // (1,19): error CS1031: Type expected
+                // void M(__arglist[]!!= null) { }
+                Diagnostic(ErrorCode.ERR_TypeExpected, "!").WithLocation(1, 19),
+                // (1,19): error CS1001: Identifier expected
+                // void M(__arglist[]!!= null) { }
+                Diagnostic(ErrorCode.ERR_IdentifierExpected, "!").WithLocation(1, 19));
             N(SyntaxKind.LocalFunctionStatement);
             {
                 N(SyntaxKind.PredefinedType);
@@ -7592,6 +7589,36 @@ public void TestNullCheckedArgList5()
                     {
                         N(SyntaxKind.ArgListKeyword);
                     }
+                    M(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.AttributeList);
+                        {
+                            N(SyntaxKind.OpenBracketToken);
+                            M(SyntaxKind.Attribute);
+                            {
+                                M(SyntaxKind.IdentifierName);
+                                {
+                                    M(SyntaxKind.IdentifierToken);
+                                }
+                            }
+                            N(SyntaxKind.CloseBracketToken);
+                        }
+                        M(SyntaxKind.IdentifierName);
+                        {
+                            M(SyntaxKind.IdentifierToken);
+                        }
+                        M(SyntaxKind.IdentifierToken);
+                        N(SyntaxKind.ExclamationExclamationToken);
+                        N(SyntaxKind.EqualsValueClause);
+                        {
+                            N(SyntaxKind.EqualsToken);
+                            N(SyntaxKind.NullLiteralExpression);
+                            {
+                                N(SyntaxKind.NullKeyword);
+                            }
+                        }
+                    }
                     N(SyntaxKind.CloseParenToken);
                 }
                 N(SyntaxKind.Block);
@@ -7607,9 +7634,18 @@ public void TestNullCheckedArgList5()
         public void TestArgListWithBrackets()
         {
             UsingStatement(@"void M(__arglist[]) { }", options: TestOptions.RegularPreview,
-                // (1,17): error CS1552: Array type specifier, [], must appear before parameter name
-                // void M(__arglist[]) { }
-                Diagnostic(ErrorCode.ERR_BadArraySyntax, "[").WithLocation(1, 17));
+                    // (1,17): error CS1003: Syntax error, ',' expected
+                    // void M(__arglist[]) { }
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "[").WithArguments(",", "[").WithLocation(1, 17),
+                    // (1,18): error CS1001: Identifier expected
+                    // void M(__arglist[]) { }
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, "]").WithLocation(1, 18),
+                    // (1,19): error CS1031: Type expected
+                    // void M(__arglist[]) { }
+                    Diagnostic(ErrorCode.ERR_TypeExpected, ")").WithLocation(1, 19),
+                    // (1,19): error CS1001: Identifier expected
+                    // void M(__arglist[]) { }
+                    Diagnostic(ErrorCode.ERR_IdentifierExpected, ")").WithLocation(1, 19));
             N(SyntaxKind.LocalFunctionStatement);
             {
                 N(SyntaxKind.PredefinedType);
@@ -7624,6 +7660,27 @@ public void TestArgListWithBrackets()
                     {
                         N(SyntaxKind.ArgListKeyword);
                     }
+                    M(SyntaxKind.CommaToken);
+                    N(SyntaxKind.Parameter);
+                    {
+                        N(SyntaxKind.AttributeList);
+                        {
+                            N(SyntaxKind.OpenBracketToken);
+                            M(SyntaxKind.Attribute);
+                            {
+                                M(SyntaxKind.IdentifierName);
+                                {
+                                    M(SyntaxKind.IdentifierToken);
+                                }
+                            }
+                            N(SyntaxKind.CloseBracketToken);
+                        }
+                        M(SyntaxKind.IdentifierName);
+                        {
+                            M(SyntaxKind.IdentifierToken);
+                        }
+                        M(SyntaxKind.IdentifierToken);
+                    }
                     N(SyntaxKind.CloseParenToken);
                 }
                 N(SyntaxKind.Block);
@@ -7639,9 +7696,9 @@ public void TestArgListWithBrackets()
         public void TestArgListWithDefaultValue()
         {
             UsingStatement(@"void M(__arglist = null) { }", options: TestOptions.RegularPreview,
-                    // (1,18): error CS1065: Default values are not valid in this context.
+                    // (1,18): error CS1003: Syntax error, ',' expected
                     // void M(__arglist = null) { }
-                    Diagnostic(ErrorCode.ERR_DefaultValueNotAllowed, "=").WithLocation(1, 18));
+                    Diagnostic(ErrorCode.ERR_SyntaxError, "=").WithArguments(",", "=").WithLocation(1, 18));
             N(SyntaxKind.LocalFunctionStatement);
             {
                 N(SyntaxKind.PredefinedType);

From f5819e832fa488f82780e24c3eafb27d15c04106 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Tue, 11 Jan 2022 11:34:42 -0800
Subject: [PATCH 307/444] Fix merge conflict

---
 .../CSharp/Portable/Parser/LanguageParser.cs  | 27 -------------------
 1 file changed, 27 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
index 019f887e3f390..bfe6488af215c 100644
--- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
+++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
@@ -4413,36 +4413,9 @@ private ParameterSyntax ParseParameter()
                 // If we didn't already consume an equals sign as part of !!=, then try to scan one out now.
                 equalsToken ??= TryEatToken(SyntaxKind.EqualsToken);
 
-<<<<<<< HEAD
                 var equalsValueClause = equalsToken == null
                     ? null
                     : CheckFeatureAvailability(_syntaxFactory.EqualsValueClause(equalsToken, this.ParseExpressionCore()), MessageID.IDS_FeatureOptionalParameter);
-=======
-                EqualsValueClauseSyntax equalsValueClause = null;
-                if (equalsToken != null)
-                    equalsValueClause = CheckFeatureAvailability(_syntaxFactory.EqualsValueClause(equalsToken, this.ParseExpressionCore()), MessageID.IDS_FeatureOptionalParameter);
-
-                if (type == null)
-                {
-                    // In the __arglist case, none of the other parameter pieces are legal, so attach anything else we get
-                    // to the identifier.
-                    if (exclamationExclamationToken != null)
-                    {
-                        if (!exclamationExclamationToken.ContainsDiagnostics)
-                            exclamationExclamationToken = AddError(exclamationExclamationToken, ErrorCode.ERR_UnexpectedToken, exclamationExclamationToken.ToString());
-
-                        identifier = AddTrailingSkippedSyntax(identifier, exclamationExclamationToken);
-                        exclamationExclamationToken = null;
-                    }
-
-                    if (equalsValueClause != null)
-                    {
-                        identifier = AddTrailingSkippedSyntax(identifier,
-                            AddErrorToFirstToken(equalsValueClause, ErrorCode.ERR_DefaultValueNotAllowed));
-                        equalsValueClause = null;
-                    }
-                }
->>>>>>> 349d9cc7d6a23ebb7c0c6319c37abb3a533494d5
 
                 return _syntaxFactory.Parameter(attributes, modifiers.ToList(), type, identifier, exclamationExclamationToken, equalsValueClause);
             }

From 7ee9280d04a3f5d269839351f9ca71e93f496c9e Mon Sep 17 00:00:00 2001
From: Charles Stoner <10732005+cston@users.noreply.github.com>
Date: Tue, 11 Jan 2022 11:53:44 -0800
Subject: [PATCH 308/444] Additional #line span directive tests (#58761)

---
 .../Portable/Syntax/SyntaxNormalizer.cs       |  7 +++
 .../Diagnostics/LineSpanDirectiveTests.cs     | 49 ++++++++++++++++++-
 .../Syntax/Syntax/SyntaxNormalizerTests.cs    | 23 +++++++++
 3 files changed, 78 insertions(+), 1 deletion(-)

diff --git a/src/Compilers/CSharp/Portable/Syntax/SyntaxNormalizer.cs b/src/Compilers/CSharp/Portable/Syntax/SyntaxNormalizer.cs
index 11e4d3eefbd11..c38a56fce2aef 100644
--- a/src/Compilers/CSharp/Portable/Syntax/SyntaxNormalizer.cs
+++ b/src/Compilers/CSharp/Portable/Syntax/SyntaxNormalizer.cs
@@ -845,6 +845,13 @@ private static bool NeedsSeparator(SyntaxToken token, SyntaxToken next)
                 return true;
             }
 
+            switch (token.Parent.Kind(), next.Parent.Kind())
+            {
+                case (SyntaxKind.LineSpanDirectiveTrivia, SyntaxKind.LineDirectivePosition):
+                case (SyntaxKind.LineDirectivePosition, SyntaxKind.LineSpanDirectiveTrivia):
+                    return true;
+            }
+
             return false;
         }
 
diff --git a/src/Compilers/CSharp/Test/Syntax/Diagnostics/LineSpanDirectiveTests.cs b/src/Compilers/CSharp/Test/Syntax/Diagnostics/LineSpanDirectiveTests.cs
index 511f88fc20c2e..467fed76f7360 100644
--- a/src/Compilers/CSharp/Test/Syntax/Diagnostics/LineSpanDirectiveTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Diagnostics/LineSpanDirectiveTests.cs
@@ -508,7 +508,7 @@ static int getTextPosition(TextLineCollection lines, LinePosition position)
         }
 
         [Fact]
-        public void Diagnostics()
+        public void Diagnostics_01()
         {
             var source =
 @"class Program
@@ -536,6 +536,53 @@ static void Main()
                 Diagnostic(ErrorCode.ERR_NameNotInContext, "B").WithArguments("B").WithLocation(8, 9));
         }
 
+        [Fact]
+        public void Diagnostics_02()
+        {
+            var source =
+@"class Program
+{
+    static void Main()
+    {
+#line (100, 1) - (100, ) 1 ""a.txt""
+        A();
+#line (200, 1) - (200, 100) 2 ""b.txt""
+        B();
+#line (300, 1) - (300, 100) x ""c.txt""
+        C();
+    }
+}".NormalizeLineEndings();
+
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (5,24): error CS8938: The #line directive value is missing or out of range
+                // #line (100, 1) - (100, ) 1 "a.txt"
+                Diagnostic(ErrorCode.ERR_LineSpanDirectiveInvalidValue, ")").WithLocation(5, 24),
+                // (6,9): error CS0103: The name 'A' does not exist in the current context
+                //         A();
+                Diagnostic(ErrorCode.ERR_NameNotInContext, "A").WithArguments("A").WithLocation(6, 9),
+                // (10,9): error CS0103: The name 'C' does not exist in the current context
+                //         C();
+                Diagnostic(ErrorCode.ERR_NameNotInContext, "C").WithArguments("C").WithLocation(10, 9),
+                // b.txt(200,8): error CS0103: The name 'B' does not exist in the current context
+                //         B();
+                Diagnostic(ErrorCode.ERR_NameNotInContext, "B").WithArguments("B").WithLocation(200, 8),
+                // b.txt(201,29): error CS1578: Quoted file name, single-line comment or end-of-line expected
+                // #line (300, 1) - (300, 100) x "c.txt"
+                Diagnostic(ErrorCode.ERR_MissingPPFile, "x").WithLocation(201, 29));
+
+            var tree = comp.SyntaxTrees[0];
+            var actualLineMappings = GetLineMappings(tree);
+            var expectedLineMappings = new[]
+            {
+                "(0,0)-(3,7) -> : (0,0)-(3,7)",
+                "(5,0)-(5,14) -> : (5,0)-(5,14)",
+                "(7,0)-(7,14),1 -> b.txt: (199,0)-(199,100)",
+                "(9,0)-(11,1) -> : (9,0)-(11,1)"
+            };
+            AssertEx.Equal(expectedLineMappings, actualLineMappings);
+        }
+
         [Fact]
         public void SequencePoints()
         {
diff --git a/src/Compilers/CSharp/Test/Syntax/Syntax/SyntaxNormalizerTests.cs b/src/Compilers/CSharp/Test/Syntax/Syntax/SyntaxNormalizerTests.cs
index 1861e0efeaf80..e85842637d214 100644
--- a/src/Compilers/CSharp/Test/Syntax/Syntax/SyntaxNormalizerTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Syntax/SyntaxNormalizerTests.cs
@@ -752,6 +752,29 @@ public void TestNormalizeLineDirectiveTrivia()
             // Note: the literal was formatted as a C# string literal, not as a directive string literal.
         }
 
+        [Fact]
+        public void TestNormalizeLineSpanDirectiveNode()
+        {
+            TestNormalize(
+                SyntaxFactory.LineSpanDirectiveTrivia(
+                    SyntaxFactory.Token(SyntaxKind.HashToken),
+                    SyntaxFactory.Token(SyntaxKind.LineKeyword),
+                    SyntaxFactory.LineDirectivePosition(SyntaxFactory.Literal(1), SyntaxFactory.Literal(2)),
+                    SyntaxFactory.Token(SyntaxKind.MinusToken),
+                    SyntaxFactory.LineDirectivePosition(SyntaxFactory.Literal(3), SyntaxFactory.Literal(4)),
+                    SyntaxFactory.Literal(5),
+                    SyntaxFactory.Literal("a.txt"),
+                    SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken),
+                    isActive: true),
+                "#line (1, 2) - (3, 4) 5 \"a.txt\"\r\n");
+        }
+
+        [Fact]
+        public void TestNormalizeLineSpanDirectiveTrivia()
+        {
+            TestNormalizeTrivia("  #  line( 1,2 )-(3,4)5\"a.txt\"", "#line (1, 2) - (3, 4) 5 \"a.txt\"\r\n");
+        }
+
         [WorkItem(538115, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538115")]
         [Fact]
         public void TestNormalizeWithinDirectives()

From 59c9b294803ed67f627d953b5dfca5f4095080b8 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: Tue, 11 Jan 2022 12:39:53 -0800
Subject: [PATCH 309/444] IDE code generator service refactoring (#58244)

* Remove dependency on Workspace

* Annotate codegen source, add missing CancellationTokens

* Eliminate optional params

* Pass language version instead of ParseOptions

* CodeGenerationContext

* LanguageVersion passing

* Remove CodeGenerator document-specific CodeGenerator helpers

* Cleanup

* CodeGenerationPreferences

* Fixes

* Feedback

* Generic CodeGenOptions

* Split file

* Update Public API

* Fix

* Fix

* Fixes

* Fix

* Fix
---
 ...ConvertTypeOfToNameOfDiagnosticAnalyzer.cs |   7 +-
 .../UseExpressionBodyForAccessorsHelper.cs    |  10 +-
 .../UseExpressionBodyForConstructorsHelper.cs |  10 +-
 ...ressionBodyForConversionOperatorsHelper.cs |  10 +-
 .../UseExpressionBodyForIndexersHelper.cs     |   8 +-
 .../UseExpressionBodyForPropertiesHelper.cs   |   6 +-
 .../Helpers/UseExpressionBodyHelper.cs        |   9 +-
 .../Helpers/UseExpressionBodyHelper`1.cs      | 128 +++---
 .../UseExpressionBodyDiagnosticAnalyzer.cs    |   5 +-
 ...arpConvertTypeOfToNameOfCodeFixProvider.cs |  15 +-
 .../CSharpInlineDeclarationCodeFixProvider.cs |   8 +-
 ...beddedStatementPlacementCodeFixProvider.cs |   2 +-
 ...moveConfusingSuppressionCodeFixProvider.cs |   2 +-
 .../CSharpUseDeconstructionCodeFixProvider.cs |   7 +-
 ...actConvertTypeOfToNameOfCodeFixProvider.cs |   3 +-
 ...stractRemoveUnusedValuesCodeFixProvider.cs |   4 +-
 ...actSimplifyInterpolationCodeFixProvider.cs |   5 +-
 ...UseCollectionInitializerCodeFixProvider.cs |   4 +-
 ...UseConditionalExpressionCodeFixProvider.cs |   2 +-
 .../UseExplicitTupleNameCodeFixProvider.cs    |   3 +
 ...ractUseObjectInitializerCodeFixProvider.cs |   4 +-
 ...icConvertGetTypeToNameOfCodeFixProvider.vb |   3 +-
 ...sicRemoveUnnecessaryCastCodeFixProvider.vb |  10 +-
 .../CSharp/Portable/PublicAPI.Unshipped.txt   |  24 +
 .../Syntax/ConstructorDeclarationSyntax.cs    |   6 +-
 .../Syntax/DestructorDeclarationSyntax.cs     |   2 +-
 .../Syntax/IndexerDeclarationSyntax.cs        |   4 +-
 .../Syntax/LocalFunctionStatementSyntax.cs    |   4 +-
 .../CSharp/Portable/Syntax/SyntaxFactory.cs   |   8 +-
 .../Portable/Syntax/TryStatementSyntax.cs     |   4 +-
 .../Core/Portable/PublicAPI.Unshipped.txt     |   2 +
 .../Portable/Syntax/SyntaxNodeExtensions.cs   |  13 +-
 ...utomaticLineEnderCommandHandler_Helpers.cs |   2 +-
 ...EventHookupCommandHandler_TabKeyCommand.cs |  13 +-
 .../CodeGenerationTests.CSharp.cs             |  35 +-
 .../CodeGenerationTests.Shared.cs             |  16 +-
 .../CodeGenerationTests.VisualBasic.cs        |  30 +-
 .../CodeGeneration/CodeGenerationTests.cs     | 227 +++++-----
 ...NavigationBarItemService_CodeGeneration.vb |  34 +-
 .../CSharpAddImportFeatureService.cs          |  20 +-
 ...FunctionToMethodCodeRefactoringProvider.cs |   5 +-
 .../AbstractUseTypeCodeRefactoringProvider.cs |   2 +-
 ...tyToFullPropertyCodeRefactoringProvider.cs |  28 +-
 ...vertForEachToForCodeRefactoringProvider.cs |   6 +-
 .../CSharpEncapsulateFieldService.cs          |   2 +-
 ...yModifiersNewDocumentFormattingProvider.cs |   2 +-
 .../CSharpGenerateVariableService.cs          |   2 +-
 ...lementImplicitlyCodeRefactoringProvider.cs |   2 +-
 .../MakeLocalFunctionStaticCodeFixHelper.cs   |  10 +-
 .../CSharpReplaceMethodWithPropertyService.cs |  27 +-
 ...CSharpReplacePropertyWithMethodsService.cs |  22 +-
 ...erseForStatementCodeRefactoringProvider.cs |   2 +-
 ...seExpressionBodyCodeRefactoringProvider.cs |   5 +-
 ...xpressionBodyForLambdaCodeStyleProvider.cs |  23 +-
 ...BodyForLambdaCodeStyleProvider_Analysis.cs |   3 +-
 ...yForLambdaCodeStyleProvider_Refactoring.cs |   3 +-
 .../CSharpUseLocalFunctionCodeFixProvider.cs  |   7 +-
 ...ider.AddConstructorParametersCodeAction.cs |  13 +-
 ...dDebuggerDisplayCodeRefactoringProvider.cs |   2 +-
 .../AbstractAddImportFeatureService.cs        |   3 +-
 .../References/MetadataSymbolReference.cs     |   5 +-
 .../References/ProjectSymbolReference.cs      |   5 +-
 .../AddImport/References/SymbolReference.cs   |  10 +-
 ...ractAddObsoleteAttributeCodeFixProvider.cs |   4 +
 .../AddParameter/AddParameterService.cs       |   2 +-
 ...stractAliasAmbiguousTypeCodeFixProvider.cs |   7 +-
 .../AbstractChangeNamespaceService.cs         |  13 +-
 ...stractMemberInsertingCompletionProvider.cs |  11 +-
 .../AbstractImportCompletionProvider.cs       |   5 +-
 ...ymousTypeToClassCodeRefactoringProvider.cs |  22 +-
 ...tyToFullPropertyCodeRefactoringProvider.cs |  26 +-
 ...vertForEachToForCodeRefactoringProvider.cs |  12 +-
 ...stractConvertForEachToLinqQueryProvider.cs |   2 +-
 ...ToInterpolatedStringRefactoringProvider.cs |   2 +-
 ...ertTupleToStructCodeRefactoringProvider.cs |  20 +-
 .../AbstractEncapsulateFieldService.cs        |   9 +-
 .../AbstractExtractInterfaceService.cs        |   2 +-
 .../MethodExtractor.CodeGenerator.cs          |  27 +-
 ...parisonOperatorsCodeRefactoringProvider.cs |  12 +-
 ...rovider.ConstructorDelegatingCodeAction.cs |   2 +-
 ...oringProvider.FieldDelegatingCodeAction.cs |   2 +-
 ...tConstructorsService.AbstractCodeAction.cs |   3 +-
 .../GenerateEqualsAndGetHashCodeAction.cs     |   7 +-
 ...bstractGenerateConstructorService.State.cs |   8 +-
 ...actGenerateEnumMemberService.CodeAction.cs |   2 +-
 ...teParameterizedMemberService.CodeAction.cs |   8 +-
 ...tractGenerateVariableService.CodeAction.cs |   9 +-
 ...VariableService.GenerateLocalCodeAction.cs |   9 +-
 .../AbstractGenerateVariableService.cs        |   2 +-
 .../GenerateOverridesWithDialogCodeAction.cs  |   5 +-
 .../AbstractGenerateTypeService.Editor.cs     |  10 +-
 .../ImplementAbstractClassData.cs             |  19 +-
 ...actImplementInterfaceService.CodeAction.cs |   8 +-
 ...terfaceService.DisposePatternCodeAction.cs |  35 +-
 ...ddParameterCheckCodeRefactoringProvider.cs |   2 +-
 ...erCodeRefactoringProviderMemberCreation.cs |  35 +-
 ...tractIntroduceParameterDocumentRewriter.cs |   6 +-
 ...nvertConditionalCodeRefactoringProvider.cs |   2 +-
 ...actMakeMethodSynchronousCodeFixProvider.cs |   2 +-
 .../AbstractMetadataAsSourceService.cs        |  20 +-
 .../Portable/PullMemberUp/MembersPuller.cs    |  55 ++-
 ...thodWithPropertyCodeRefactoringProvider.cs |   4 +-
 ...pertyWithMethodsCodeRefactoringProvider.cs |   4 +-
 .../Shared/Utilities/ExtractTypeHelpers.cs    |  20 +-
 .../AbstractUseAutoPropertyCodeFixProvider.cs |   2 +-
 .../VisualBasicAddImportFeatureService.vb     |   8 +-
 ...GenerateEventCodeFixProvider.CodeAction.vb |   7 +-
 .../GenerateEventCodeFixProvider.vb           |  13 +-
 ...lBasicConvertAutoPropertyToFullProperty.vb |   8 +-
 ...vertForEachToForCodeRefactoringProvider.vb |   2 +-
 .../VisualBasicGenerateVariableService.vb     |   2 +-
 .../Impl/Snippets/SnippetExpansionClient.cs   |   5 +-
 .../AbstractSnippetExpansionClient.cs         |   7 +-
 .../Venus/ContainedLanguageCodeSupport.cs     |  11 +-
 .../AbstractCodeModelObject_CodeGen.cs        | 102 ++---
 .../Impl/CodeModel/FileCodeModel_CodeGen.cs   |  11 +-
 .../CSharpSnippetExpansionClientTests.vb      |   6 +-
 .../Core/Test/Snippets/SnippetTestState.vb    |   3 +-
 .../VisualBasicSnippetExpansionClientTests.vb |   5 +-
 .../Impl/Snippets/SnippetExpansionClient.vb   |   5 +-
 .../CodeGeneration/AttributeGenerator.cs      |  10 +-
 .../CSharpCodeGenerationHelpers.cs            |  51 ++-
 .../CSharpCodeGenerationOptions.cs            |  36 ++
 .../CSharpCodeGenerationPreferences.cs        |  40 ++
 .../CSharpCodeGenerationService.cs            | 219 ++++-----
 .../CSharpCodeGenerationServiceFactory.cs     |   2 -
 .../CSharpDeclarationComparer.cs              |  25 +-
 .../CSharpFlagsEnumGenerator.cs               |   2 -
 .../CodeGeneration/CSharpSyntaxGenerator.cs   | 418 +++++++++---------
 .../CodeGeneration/ConstructorGenerator.cs    |  41 +-
 .../CodeGeneration/ConversionGenerator.cs     |  39 +-
 .../CodeGeneration/DestructorGenerator.cs     |  22 +-
 .../CodeGeneration/EnumMemberGenerator.cs     |  32 +-
 .../Portable/CodeGeneration/EventGenerator.cs |  49 +-
 .../CodeGeneration/ExpressionGenerator.cs     |  84 ++--
 .../Portable/CodeGeneration/FieldGenerator.cs |  27 +-
 .../CodeGeneration/MethodGenerator.cs         |  94 ++--
 .../CodeGeneration/NamedTypeGenerator.cs      |  44 +-
 .../CodeGeneration/NamespaceGenerator.cs      |  38 +-
 .../CodeGeneration/OperatorGenerator.cs       |  42 +-
 .../CodeGeneration/ParameterGenerator.cs      |  20 +-
 .../CodeGeneration/PropertyGenerator.cs       | 123 +++---
 .../CodeGeneration/StatementGenerator.cs      |   2 -
 .../CodeGeneration/TypeParameterGenerator.cs  |  11 +-
 .../AbstractCodeGenerationService.cs          | 248 ++++++-----
 ...ctCodeGenerationService_FindDeclaration.cs |  15 +-
 .../AbstractFlagsEnumGenerator.cs             |  34 +-
 .../CodeGeneration/CodeGenerationContext.cs   | 225 ++++++++++
 .../CodeGeneration/CodeGenerationHelpers.cs   | 117 +++--
 .../CodeGeneration/CodeGenerationOptions.cs   | 231 +---------
 .../Portable/CodeGeneration/CodeGenerator.cs  | 162 ++-----
 .../CodeGeneration/ICodeGenerationService.cs  |  78 ++--
 .../Core/Portable/Editing/DocumentEditor.cs   |   2 +-
 .../Portable/Editing/ImportAdderService.cs    |  17 +-
 .../Core/Portable/Editing/SyntaxEditor.cs     | 115 +++--
 .../Core/Portable/Editing/SyntaxGenerator.cs  | 320 +++++++-------
 .../Core/Portable/PublicAPI.Unshipped.txt     |   3 +
 .../Portable/Simplification/Simplifier.cs     |  39 +-
 .../Workspace/Solution/DocumentState.cs       |   2 +
 .../CoreTest/Editing/SyntaxEditorTests.cs     |   4 +-
 .../Extensions/BlockSyntaxExtensions.cs       |  42 +-
 .../CSharp/Extensions/SyntaxNodeExtensions.cs |   3 +
 .../CSharp/Utilities/SpeculationAnalyzer.cs   |   2 +-
 .../CSharpAddImportsService.cs                |  12 +-
 ...scardDeclarationsWithAssignmentsService.cs |   5 +-
 .../CSharpSyntaxGeneratorInternal.cs          |   4 +-
 .../SyntaxEditorBasedCodeFixProvider.cs       |   2 +-
 .../CodeGenerationPreferences.cs              |  44 ++
 .../AddImports/AbstractAddImportsService.cs   |  23 +-
 .../AddImports/IAddImportsService.cs          |  15 +-
 ...ractMoveDeclarationNearReferenceService.cs |   2 +-
 ...scardDeclarationsWithAssignmentsService.cs |   2 +-
 .../SyntaxGeneratorInternal.cs                |   4 +-
 .../Core/WorkspaceExtensions.projitems        |   1 +
 .../VisualBasicAddImportsService.vb           |   9 +-
 .../CodeGeneration/ConstructorGenerator.vb    |   2 +-
 .../CodeGeneration/ConversionGenerator.vb     |   2 +-
 .../Portable/CodeGeneration/EventGenerator.vb |   2 +-
 .../CodeGeneration/ExpressionGenerator.vb     |   2 +-
 .../CodeGeneration/MethodGenerator.vb         |   2 +-
 .../CodeGeneration/NamedTypeGenerator.vb      |   4 +-
 .../CodeGeneration/NamespaceGenerator.vb      |   3 +-
 .../CodeGeneration/OperatorGenerator.vb       |   2 +-
 .../CodeGeneration/PropertyGenerator.vb       |   2 +-
 .../VisualBasicCodeGenerationHelpers.vb       |  21 +-
 .../VisualBasicCodeGenerationOptions.vb       |  34 ++
 .../VisualBasicCodeGenerationPreferences.vb   |  26 ++
 .../VisualBasicCodeGenerationService.vb       |  85 ++--
 .../VisualBasicSyntaxGenerator.vb             |  50 +--
 189 files changed, 2647 insertions(+), 2393 deletions(-)
 create mode 100644 src/Workspaces/CSharp/Portable/CodeGeneration/CSharpCodeGenerationOptions.cs
 create mode 100644 src/Workspaces/CSharp/Portable/CodeGeneration/CSharpCodeGenerationPreferences.cs
 create mode 100644 src/Workspaces/Core/Portable/CodeGeneration/CodeGenerationContext.cs
 create mode 100644 src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/CodeGeneration/CodeGenerationPreferences.cs
 create mode 100644 src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicCodeGenerationOptions.vb
 create mode 100644 src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicCodeGenerationPreferences.vb

diff --git a/src/Analyzers/CSharp/Analyzers/ConvertTypeofToNameof/CSharpConvertTypeOfToNameOfDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/ConvertTypeofToNameof/CSharpConvertTypeOfToNameOfDiagnosticAnalyzer.cs
index a45977faac666..9f187df9f102a 100644
--- a/src/Analyzers/CSharp/Analyzers/ConvertTypeofToNameof/CSharpConvertTypeOfToNameOfDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/ConvertTypeofToNameof/CSharpConvertTypeOfToNameOfDiagnosticAnalyzer.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using Microsoft.CodeAnalysis.ConvertTypeOfToNameOf;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
@@ -23,9 +24,9 @@ public CSharpConvertTypeOfToNameOfDiagnosticAnalyzer() : base(s_title, LanguageN
         protected override bool IsValidTypeofAction(OperationAnalysisContext context)
         {
             var node = context.Operation.Syntax;
-            var syntaxTree = node.SyntaxTree;
+
             // nameof was added in CSharp 6.0, so don't offer it for any languages before that time
-            if (((CSharpParseOptions)syntaxTree.Options).LanguageVersion < LanguageVersion.CSharp6)
+            if (node.GetLanguageVersion() < LanguageVersion.CSharp6)
             {
                 return false;
             }
@@ -35,7 +36,7 @@ protected override bool IsValidTypeofAction(OperationAnalysisContext context)
             // expression that we want to analyze
             return node is TypeOfExpressionSyntax { Parent: MemberAccessExpressionSyntax } typeofExpression &&
                 // nameof(System.Void) isn't allowed in C#.
-                typeofExpression is not { Type: PredefinedTypeSyntax { Keyword: { RawKind: (int)SyntaxKind.VoidKeyword } } };
+                typeofExpression is not { Type: PredefinedTypeSyntax { Keyword.RawKind: (int)SyntaxKind.VoidKeyword } };
         }
     }
 }
diff --git a/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyForAccessorsHelper.cs b/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyForAccessorsHelper.cs
index 7bc3bac93c3ee..d44b9ec0414ea 100644
--- a/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyForAccessorsHelper.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyForAccessorsHelper.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -26,10 +24,10 @@ private UseExpressionBodyForAccessorsHelper()
         {
         }
 
-        protected override BlockSyntax GetBody(AccessorDeclarationSyntax declaration)
+        protected override BlockSyntax? GetBody(AccessorDeclarationSyntax declaration)
             => declaration.Body;
 
-        protected override ArrowExpressionClauseSyntax GetExpressionBody(AccessorDeclarationSyntax declaration)
+        protected override ArrowExpressionClauseSyntax? GetExpressionBody(AccessorDeclarationSyntax declaration)
             => declaration.ExpressionBody;
 
         protected override SyntaxToken GetSemicolonToken(AccessorDeclarationSyntax declaration)
@@ -38,10 +36,10 @@ protected override SyntaxToken GetSemicolonToken(AccessorDeclarationSyntax decla
         protected override AccessorDeclarationSyntax WithSemicolonToken(AccessorDeclarationSyntax declaration, SyntaxToken token)
             => declaration.WithSemicolonToken(token);
 
-        protected override AccessorDeclarationSyntax WithExpressionBody(AccessorDeclarationSyntax declaration, ArrowExpressionClauseSyntax expressionBody)
+        protected override AccessorDeclarationSyntax WithExpressionBody(AccessorDeclarationSyntax declaration, ArrowExpressionClauseSyntax? expressionBody)
             => declaration.WithExpressionBody(expressionBody);
 
-        protected override AccessorDeclarationSyntax WithBody(AccessorDeclarationSyntax declaration, BlockSyntax body)
+        protected override AccessorDeclarationSyntax WithBody(AccessorDeclarationSyntax declaration, BlockSyntax? body)
             => declaration.WithBody(body);
 
         protected override bool CreateReturnStatementForExpression(SemanticModel semanticModel, AccessorDeclarationSyntax declaration)
diff --git a/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyForConstructorsHelper.cs b/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyForConstructorsHelper.cs
index d0f03dc28fa92..1cc4dc3bb8219 100644
--- a/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyForConstructorsHelper.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyForConstructorsHelper.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -26,10 +24,10 @@ private UseExpressionBodyForConstructorsHelper()
         {
         }
 
-        protected override BlockSyntax GetBody(ConstructorDeclarationSyntax declaration)
+        protected override BlockSyntax? GetBody(ConstructorDeclarationSyntax declaration)
             => declaration.Body;
 
-        protected override ArrowExpressionClauseSyntax GetExpressionBody(ConstructorDeclarationSyntax declaration)
+        protected override ArrowExpressionClauseSyntax? GetExpressionBody(ConstructorDeclarationSyntax declaration)
             => declaration.ExpressionBody;
 
         protected override SyntaxToken GetSemicolonToken(ConstructorDeclarationSyntax declaration)
@@ -38,10 +36,10 @@ protected override SyntaxToken GetSemicolonToken(ConstructorDeclarationSyntax de
         protected override ConstructorDeclarationSyntax WithSemicolonToken(ConstructorDeclarationSyntax declaration, SyntaxToken token)
             => declaration.WithSemicolonToken(token);
 
-        protected override ConstructorDeclarationSyntax WithExpressionBody(ConstructorDeclarationSyntax declaration, ArrowExpressionClauseSyntax expressionBody)
+        protected override ConstructorDeclarationSyntax WithExpressionBody(ConstructorDeclarationSyntax declaration, ArrowExpressionClauseSyntax? expressionBody)
             => declaration.WithExpressionBody(expressionBody);
 
-        protected override ConstructorDeclarationSyntax WithBody(ConstructorDeclarationSyntax declaration, BlockSyntax body)
+        protected override ConstructorDeclarationSyntax WithBody(ConstructorDeclarationSyntax declaration, BlockSyntax? body)
             => declaration.WithBody(body);
 
         protected override bool CreateReturnStatementForExpression(SemanticModel semanticModel, ConstructorDeclarationSyntax declaration) => false;
diff --git a/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyForConversionOperatorsHelper.cs b/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyForConversionOperatorsHelper.cs
index fcb7b0965a914..fc12ad3102e70 100644
--- a/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyForConversionOperatorsHelper.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyForConversionOperatorsHelper.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -26,10 +24,10 @@ private UseExpressionBodyForConversionOperatorsHelper()
         {
         }
 
-        protected override BlockSyntax GetBody(ConversionOperatorDeclarationSyntax declaration)
+        protected override BlockSyntax? GetBody(ConversionOperatorDeclarationSyntax declaration)
             => declaration.Body;
 
-        protected override ArrowExpressionClauseSyntax GetExpressionBody(ConversionOperatorDeclarationSyntax declaration)
+        protected override ArrowExpressionClauseSyntax? GetExpressionBody(ConversionOperatorDeclarationSyntax declaration)
             => declaration.ExpressionBody;
 
         protected override SyntaxToken GetSemicolonToken(ConversionOperatorDeclarationSyntax declaration)
@@ -38,10 +36,10 @@ protected override SyntaxToken GetSemicolonToken(ConversionOperatorDeclarationSy
         protected override ConversionOperatorDeclarationSyntax WithSemicolonToken(ConversionOperatorDeclarationSyntax declaration, SyntaxToken token)
             => declaration.WithSemicolonToken(token);
 
-        protected override ConversionOperatorDeclarationSyntax WithExpressionBody(ConversionOperatorDeclarationSyntax declaration, ArrowExpressionClauseSyntax expressionBody)
+        protected override ConversionOperatorDeclarationSyntax WithExpressionBody(ConversionOperatorDeclarationSyntax declaration, ArrowExpressionClauseSyntax? expressionBody)
             => declaration.WithExpressionBody(expressionBody);
 
-        protected override ConversionOperatorDeclarationSyntax WithBody(ConversionOperatorDeclarationSyntax declaration, BlockSyntax body)
+        protected override ConversionOperatorDeclarationSyntax WithBody(ConversionOperatorDeclarationSyntax declaration, BlockSyntax? body)
             => declaration.WithBody(body);
 
         protected override bool CreateReturnStatementForExpression(SemanticModel semanticModel, ConversionOperatorDeclarationSyntax declaration)
diff --git a/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyForIndexersHelper.cs b/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyForIndexersHelper.cs
index 3f74871201a49..b5327f6e4bf1a 100644
--- a/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyForIndexersHelper.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyForIndexersHelper.cs
@@ -62,14 +62,12 @@ protected override IndexerDeclarationSyntax WithGenerateBody(SemanticModel seman
         protected override bool CreateReturnStatementForExpression(SemanticModel semanticModel, IndexerDeclarationSyntax declaration) => true;
 
         protected override bool TryConvertToExpressionBody(
-            IndexerDeclarationSyntax declaration, ParseOptions options,
+            IndexerDeclarationSyntax declaration,
             ExpressionBodyPreference conversionPreference,
             out ArrowExpressionClauseSyntax arrowExpression,
             out SyntaxToken semicolonToken)
         {
-            return TryConvertToExpressionBodyForBaseProperty(
-                declaration, options, conversionPreference,
-                out arrowExpression, out semicolonToken);
+            return TryConvertToExpressionBodyForBaseProperty(declaration, conversionPreference, out arrowExpression, out semicolonToken);
         }
 
         protected override Location GetDiagnosticLocation(IndexerDeclarationSyntax declaration)
@@ -77,7 +75,7 @@ protected override Location GetDiagnosticLocation(IndexerDeclarationSyntax decla
             var body = GetBody(declaration);
             if (body != null)
             {
-                return base.GetDiagnosticLocation(declaration);
+                return body.Statements[0].GetLocation();
             }
 
             var getAccessor = GetSingleGetAccessor(declaration.AccessorList);
diff --git a/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyForPropertiesHelper.cs b/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyForPropertiesHelper.cs
index 6e3db985cb772..53066d7605658 100644
--- a/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyForPropertiesHelper.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyForPropertiesHelper.cs
@@ -62,14 +62,12 @@ protected override PropertyDeclarationSyntax WithGenerateBody(SemanticModel sema
         protected override bool CreateReturnStatementForExpression(SemanticModel semanticModel, PropertyDeclarationSyntax declaration) => true;
 
         protected override bool TryConvertToExpressionBody(
-            PropertyDeclarationSyntax declaration, ParseOptions options,
+            PropertyDeclarationSyntax declaration,
             ExpressionBodyPreference conversionPreference,
             out ArrowExpressionClauseSyntax arrowExpression,
             out SyntaxToken semicolonToken)
         {
-            return TryConvertToExpressionBodyForBaseProperty(
-                declaration, options, conversionPreference,
-                out arrowExpression, out semicolonToken);
+            return TryConvertToExpressionBodyForBaseProperty(declaration, conversionPreference, out arrowExpression, out semicolonToken);
         }
 
         protected override Location GetDiagnosticLocation(PropertyDeclarationSyntax declaration)
diff --git a/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyHelper.cs b/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyHelper.cs
index 9326e2018065b..cb2b176770a5f 100644
--- a/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyHelper.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyHelper.cs
@@ -2,12 +2,11 @@
 // 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.Collections.Immutable;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System.Diagnostics.CodeAnalysis;
 
 #if CODE_STYLE
 using OptionSet = Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions;
@@ -24,11 +23,11 @@ internal abstract class UseExpressionBodyHelper
         public abstract EnforceOnBuild EnforceOnBuild { get; }
         public abstract ImmutableArray<SyntaxKind> SyntaxKinds { get; }
 
-        public abstract BlockSyntax GetBody(SyntaxNode declaration);
-        public abstract ArrowExpressionClauseSyntax GetExpressionBody(SyntaxNode declaration);
+        public abstract BlockSyntax? GetBody(SyntaxNode declaration);
+        public abstract ArrowExpressionClauseSyntax? GetExpressionBody(SyntaxNode declaration);
 
         public abstract bool CanOfferUseExpressionBody(OptionSet optionSet, SyntaxNode declaration, bool forAnalyzer);
-        public abstract (bool canOffer, bool fixesError) CanOfferUseBlockBody(OptionSet optionSet, SyntaxNode declaration, bool forAnalyzer);
+        public abstract bool CanOfferUseBlockBody(OptionSet optionSet, SyntaxNode declaration, bool forAnalyzer, out bool fixesError, [NotNullWhen(true)] out ArrowExpressionClauseSyntax? expressionBody);
         public abstract SyntaxNode Update(SemanticModel semanticModel, SyntaxNode declaration, bool useExpressionBody);
 
         public abstract Location GetDiagnosticLocation(SyntaxNode declaration);
diff --git a/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyHelper`1.cs b/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyHelper`1.cs
index 805e7d14807ab..d76971155b75b 100644
--- a/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyHelper`1.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyHelper`1.cs
@@ -2,16 +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.
 
-#nullable disable
-
 using System;
 using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Options;
+using Roslyn.Utilities;
 
 #if CODE_STYLE
 using OptionSet = Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions;
@@ -50,7 +50,7 @@ protected UseExpressionBodyHelper(
             SyntaxKinds = syntaxKinds;
         }
 
-        protected static AccessorDeclarationSyntax GetSingleGetAccessor(AccessorListSyntax accessorList)
+        protected static AccessorDeclarationSyntax? GetSingleGetAccessor(AccessorListSyntax? accessorList)
         {
             if (accessorList != null &&
                 accessorList.Accessors.Count == 1 &&
@@ -63,20 +63,20 @@ protected static AccessorDeclarationSyntax GetSingleGetAccessor(AccessorListSynt
             return null;
         }
 
-        protected static BlockSyntax GetBodyFromSingleGetAccessor(AccessorListSyntax accessorList)
+        protected static BlockSyntax? GetBodyFromSingleGetAccessor(AccessorListSyntax accessorList)
             => GetSingleGetAccessor(accessorList)?.Body;
 
-        public override BlockSyntax GetBody(SyntaxNode declaration)
+        public override BlockSyntax? GetBody(SyntaxNode declaration)
             => GetBody((TDeclaration)declaration);
 
-        public override ArrowExpressionClauseSyntax GetExpressionBody(SyntaxNode declaration)
+        public override ArrowExpressionClauseSyntax? GetExpressionBody(SyntaxNode declaration)
             => GetExpressionBody((TDeclaration)declaration);
 
         public override bool CanOfferUseExpressionBody(OptionSet optionSet, SyntaxNode declaration, bool forAnalyzer)
             => CanOfferUseExpressionBody(optionSet, (TDeclaration)declaration, forAnalyzer);
 
-        public override (bool canOffer, bool fixesError) CanOfferUseBlockBody(OptionSet optionSet, SyntaxNode declaration, bool forAnalyzer)
-            => CanOfferUseBlockBody(optionSet, (TDeclaration)declaration, forAnalyzer);
+        public override bool CanOfferUseBlockBody(OptionSet optionSet, SyntaxNode declaration, bool forAnalyzer, out bool fixesError, [NotNullWhen(true)] out ArrowExpressionClauseSyntax? expressionBody)
+            => CanOfferUseBlockBody(optionSet, (TDeclaration)declaration, forAnalyzer, out fixesError, out expressionBody);
 
         public sealed override SyntaxNode Update(SemanticModel semanticModel, SyntaxNode declaration, bool useExpressionBody)
             => Update(semanticModel, (TDeclaration)declaration, useExpressionBody);
@@ -85,7 +85,11 @@ public override Location GetDiagnosticLocation(SyntaxNode declaration)
             => GetDiagnosticLocation((TDeclaration)declaration);
 
         protected virtual Location GetDiagnosticLocation(TDeclaration declaration)
-            => GetBody(declaration).Statements[0].GetLocation();
+        {
+            var body = GetBody(declaration);
+            Contract.ThrowIfNull(body);
+            return body.Statements[0].GetLocation();
+        }
 
         public bool CanOfferUseExpressionBody(
             OptionSet optionSet, TDeclaration declaration, bool forAnalyzer)
@@ -106,10 +110,9 @@ public bool CanOfferUseExpressionBody(
                     // They don't have an expression body.  See if we could convert the block they
                     // have into one.
 
-                    var options = declaration.SyntaxTree.Options;
                     var conversionPreference = forAnalyzer ? preference : ExpressionBodyPreference.WhenPossible;
 
-                    return TryConvertToExpressionBody(declaration, options, conversionPreference,
+                    return TryConvertToExpressionBody(declaration, conversionPreference,
                         expressionWhenOnSingleLine: out _, semicolonWhenOnSingleLine: out _);
                 }
             }
@@ -119,35 +122,41 @@ public bool CanOfferUseExpressionBody(
 
         protected virtual bool TryConvertToExpressionBody(
             TDeclaration declaration,
-            ParseOptions options, ExpressionBodyPreference conversionPreference,
-            out ArrowExpressionClauseSyntax expressionWhenOnSingleLine,
+            ExpressionBodyPreference conversionPreference,
+            [NotNullWhen(true)] out ArrowExpressionClauseSyntax? expressionWhenOnSingleLine,
             out SyntaxToken semicolonWhenOnSingleLine)
         {
             return TryConvertToExpressionBodyWorker(
-                declaration, options, conversionPreference,
+                declaration, conversionPreference,
                 out expressionWhenOnSingleLine, out semicolonWhenOnSingleLine);
         }
 
         private bool TryConvertToExpressionBodyWorker(
-            SyntaxNode declaration, ParseOptions options, ExpressionBodyPreference conversionPreference,
-            out ArrowExpressionClauseSyntax expressionWhenOnSingleLine, out SyntaxToken semicolonWhenOnSingleLine)
+            SyntaxNode declaration, ExpressionBodyPreference conversionPreference,
+            [NotNullWhen(true)] out ArrowExpressionClauseSyntax? expressionWhenOnSingleLine, out SyntaxToken semicolonWhenOnSingleLine)
         {
             var body = GetBody(declaration);
+            if (body is null)
+            {
+                expressionWhenOnSingleLine = null;
+                semicolonWhenOnSingleLine = default;
+                return false;
+            }
+
+            var languageVersion = ((CSharpParseOptions)body.SyntaxTree.Options).LanguageVersion;
 
             return body.TryConvertToArrowExpressionBody(
-                declaration.Kind(), options, conversionPreference,
+                declaration.Kind(), languageVersion, conversionPreference,
                 out expressionWhenOnSingleLine, out semicolonWhenOnSingleLine);
         }
 
         protected bool TryConvertToExpressionBodyForBaseProperty(
-            BasePropertyDeclarationSyntax declaration, ParseOptions options,
+            BasePropertyDeclarationSyntax declaration,
             ExpressionBodyPreference conversionPreference,
-            out ArrowExpressionClauseSyntax arrowExpression,
+            [NotNullWhen(true)] out ArrowExpressionClauseSyntax? arrowExpression,
             out SyntaxToken semicolonToken)
         {
-            if (TryConvertToExpressionBodyWorker(
-                    declaration, options, conversionPreference,
-                    out arrowExpression, out semicolonToken))
+            if (TryConvertToExpressionBodyWorker(declaration, conversionPreference, out arrowExpression, out semicolonToken))
             {
                 return true;
             }
@@ -164,64 +173,69 @@ protected bool TryConvertToExpressionBodyForBaseProperty(
             return false;
         }
 
-        public (bool canOffer, bool fixesError) CanOfferUseBlockBody(
-            OptionSet optionSet, TDeclaration declaration, bool forAnalyzer)
+        public bool CanOfferUseBlockBody(
+            OptionSet optionSet,
+            TDeclaration declaration,
+            bool forAnalyzer,
+            out bool fixesError,
+            [NotNullWhen(true)] out ArrowExpressionClauseSyntax? expressionBody)
         {
             var currentOptionValue = optionSet.GetOption(Option);
             var preference = currentOptionValue.Value;
             var userPrefersBlockBodies = preference == ExpressionBodyPreference.Never;
             var analyzerDisabled = currentOptionValue.Notification.Severity == ReportDiagnostic.Suppress;
 
-            var expressionBodyOpt = GetExpressionBody(declaration);
-            var canOffer = expressionBodyOpt?.TryConvertToBlock(
-                SyntaxFactory.Token(SyntaxKind.SemicolonToken), false, block: out _) == true;
-            if (!canOffer)
+            expressionBody = GetExpressionBody(declaration);
+            if (expressionBody?.TryConvertToBlock(
+                SyntaxFactory.Token(SyntaxKind.SemicolonToken), false, block: out _) != true)
             {
-                return (canOffer, fixesError: false);
+                fixesError = false;
+                return false;
             }
 
-            var languageVersion = ((CSharpParseOptions)declaration.SyntaxTree.Options).LanguageVersion;
-            if (expressionBodyOpt.Expression.IsKind(SyntaxKind.ThrowExpression) &&
-                languageVersion < LanguageVersion.CSharp7)
+            var languageVersion = declaration.GetLanguageVersion();
+            if (languageVersion < LanguageVersion.CSharp7)
             {
-                // If they're using a throw expression in a declaration and it's prior to C# 7
-                // then always mark this as something that can be fixed by the analyzer.  This way
-                // we'll also get 'fix all' working to fix all these cases.
-                return (canOffer, fixesError: true);
-            }
+                if (expressionBody!.Expression.IsKind(SyntaxKind.ThrowExpression))
+                {
+                    // If they're using a throw expression in a declaration and it's prior to C# 7
+                    // then always mark this as something that can be fixed by the analyzer.  This way
+                    // we'll also get 'fix all' working to fix all these cases.
+                    fixesError = true;
+                    return true;
+                }
 
-            var isAccessorOrConstructor = declaration is AccessorDeclarationSyntax or
-                                          ConstructorDeclarationSyntax;
-            if (isAccessorOrConstructor &&
-                languageVersion < LanguageVersion.CSharp7)
-            {
-                // If they're using expression bodies for accessors/constructors and it's prior to C# 7
-                // then always mark this as something that can be fixed by the analyzer.  This way
-                // we'll also get 'fix all' working to fix all these cases.
-                return (canOffer, fixesError: true);
+                if (declaration is AccessorDeclarationSyntax or ConstructorDeclarationSyntax)
+                {
+                    // If they're using expression bodies for accessors/constructors and it's prior to C# 7
+                    // then always mark this as something that can be fixed by the analyzer.  This way
+                    // we'll also get 'fix all' working to fix all these cases.
+                    fixesError = true;
+                    return true;
+                }
             }
-            else if (languageVersion < LanguageVersion.CSharp6)
+
+            if (languageVersion < LanguageVersion.CSharp6)
             {
                 // If they're using expression bodies prior to C# 6, then always mark this as something
                 // that can be fixed by the analyzer.  This way we'll also get 'fix all' working to fix
                 // all these cases.
-                return (canOffer, fixesError: true);
+                fixesError = true;
+                return true;
             }
 
             // If the user likes block bodies, then we offer block bodies from the diagnostic analyzer.
             // If the user does not like block bodies then we offer block bodies from the refactoring provider.
             // If the analyzer is disabled completely, the refactoring is enabled in both directions.
-            canOffer = userPrefersBlockBodies == forAnalyzer || (!forAnalyzer && analyzerDisabled);
-            return (canOffer, fixesError: false);
+            fixesError = false;
+            return userPrefersBlockBodies == forAnalyzer || (!forAnalyzer && analyzerDisabled);
         }
 
         public TDeclaration Update(SemanticModel semanticModel, TDeclaration declaration, bool useExpressionBody)
         {
             if (useExpressionBody)
             {
-                TryConvertToExpressionBody(
-                    declaration, declaration.SyntaxTree.Options, ExpressionBodyPreference.WhenPossible,
-                    out var expressionBody, out var semicolonToken);
+                TryConvertToExpressionBody(declaration, ExpressionBodyPreference.WhenPossible, out var expressionBody, out var semicolonToken);
 
                 var trailingTrivia = semicolonToken.TrailingTrivia
                                                    .Where(t => t.Kind() != SyntaxKind.EndOfLineTrivia)
@@ -244,17 +258,17 @@ public TDeclaration Update(SemanticModel semanticModel, TDeclaration declaration
             }
         }
 
-        protected abstract BlockSyntax GetBody(TDeclaration declaration);
+        protected abstract BlockSyntax? GetBody(TDeclaration declaration);
 
-        protected abstract ArrowExpressionClauseSyntax GetExpressionBody(TDeclaration declaration);
+        protected abstract ArrowExpressionClauseSyntax? GetExpressionBody(TDeclaration declaration);
 
         protected abstract bool CreateReturnStatementForExpression(SemanticModel semanticModel, TDeclaration declaration);
 
         protected abstract SyntaxToken GetSemicolonToken(TDeclaration declaration);
 
         protected abstract TDeclaration WithSemicolonToken(TDeclaration declaration, SyntaxToken token);
-        protected abstract TDeclaration WithExpressionBody(TDeclaration declaration, ArrowExpressionClauseSyntax expressionBody);
-        protected abstract TDeclaration WithBody(TDeclaration declaration, BlockSyntax body);
+        protected abstract TDeclaration WithExpressionBody(TDeclaration declaration, ArrowExpressionClauseSyntax? expressionBody);
+        protected abstract TDeclaration WithBody(TDeclaration declaration, BlockSyntax? body);
 
         protected virtual TDeclaration WithGenerateBody(SemanticModel semanticModel, TDeclaration declaration)
         {
diff --git a/src/Analyzers/CSharp/Analyzers/UseExpressionBody/UseExpressionBodyDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseExpressionBody/UseExpressionBodyDiagnosticAnalyzer.cs
index 4de783867a2e4..f3de1871fe248 100644
--- a/src/Analyzers/CSharp/Analyzers/UseExpressionBody/UseExpressionBodyDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseExpressionBody/UseExpressionBodyDiagnosticAnalyzer.cs
@@ -108,14 +108,13 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
                     location, severity, additionalLocations: additionalLocations, properties: properties);
             }
 
-            var (canOffer, fixesError) = helper.CanOfferUseBlockBody(optionSet, declaration, forAnalyzer: true);
-            if (canOffer)
+            if (helper.CanOfferUseBlockBody(optionSet, declaration, forAnalyzer: true, out var fixesError, out var expressionBody))
             {
                 // They have an expression body.  Create a diagnostic to convert it to a block
                 // if they don't want expression bodies for this member.  
                 var location = severity.WithDefaultSeverity(DiagnosticSeverity.Hidden) == ReportDiagnostic.Hidden
                     ? declaration.GetLocation()
-                    : helper.GetExpressionBody(declaration).GetLocation();
+                    : expressionBody.GetLocation();
 
                 var properties = ImmutableDictionary<string, string?>.Empty;
                 if (fixesError)
diff --git a/src/Analyzers/CSharp/CodeFixes/ConvertTypeOfToNameOf/CSharpConvertTypeOfToNameOfCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/ConvertTypeOfToNameOf/CSharpConvertTypeOfToNameOfCodeFixProvider.cs
index 3575cbc25b6ff..c5e768869b142 100644
--- a/src/Analyzers/CSharp/CodeFixes/ConvertTypeOfToNameOf/CSharpConvertTypeOfToNameOfCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/ConvertTypeOfToNameOf/CSharpConvertTypeOfToNameOfCodeFixProvider.cs
@@ -10,6 +10,7 @@
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.ConvertTypeOfToNameOf
 {
@@ -25,15 +26,13 @@ public CSharpConvertTypeOfToNameOfCodeFixProvider()
         protected override string GetCodeFixTitle()
             => CSharpCodeFixesResources.Convert_typeof_to_nameof;
 
-        protected override SyntaxNode? GetSymbolTypeExpression(SemanticModel model, SyntaxNode node, CancellationToken cancellationToken)
+        protected override SyntaxNode GetSymbolTypeExpression(SemanticModel model, SyntaxNode node, CancellationToken cancellationToken)
         {
-            if (node is MemberAccessExpressionSyntax { Expression: TypeOfExpressionSyntax typeOfExpression })
-            {
-                var typeSymbol = model.GetSymbolInfo(typeOfExpression.Type, cancellationToken).Symbol.GetSymbolType();
-                return typeSymbol?.GenerateExpressionSyntax();
-            }
-
-            return null;
+            // The corresponding analyzer (CSharpConvertTypeOfToNameOfDiagnosticAnalyzer) validated the syntax
+            var typeOfExpression = (TypeOfExpressionSyntax)((MemberAccessExpressionSyntax)node).Expression;
+            var typeSymbol = model.GetSymbolInfo(typeOfExpression.Type, cancellationToken).Symbol.GetSymbolType();
+            Contract.ThrowIfNull(typeSymbol);
+            return typeSymbol.GenerateExpressionSyntax();
         }
     }
 }
diff --git a/src/Analyzers/CSharp/CodeFixes/InlineDeclaration/CSharpInlineDeclarationCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/InlineDeclaration/CSharpInlineDeclarationCodeFixProvider.cs
index dd2d15a0adaad..b7219ae686992 100644
--- a/src/Analyzers/CSharp/CodeFixes/InlineDeclaration/CSharpInlineDeclarationCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/InlineDeclaration/CSharpInlineDeclarationCodeFixProvider.cs
@@ -20,6 +20,7 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Formatting;
+using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Shared.Utilities;
@@ -97,7 +98,7 @@ await editor.ApplyExpressionLevelSemanticEditsAsync(
                 (semanticModel, currentRoot, t, currentNode)
                     => ReplaceIdentifierWithInlineDeclaration(
                         options, semanticModel, currentRoot, t.declarator,
-                        t.identifier, currentNode, declarationsToRemove, document.Project.Solution.Workspace,
+                        t.identifier, currentNode, declarationsToRemove, document.Project.Solution.Workspace.Services,
                         cancellationToken),
                 cancellationToken).ConfigureAwait(false);
         }
@@ -122,13 +123,14 @@ private static SyntaxNode ReplaceIdentifierWithInlineDeclaration(
             OptionSet options, SemanticModel semanticModel,
             SyntaxNode currentRoot, VariableDeclaratorSyntax declarator,
             IdentifierNameSyntax identifier, SyntaxNode currentNode,
-            HashSet<StatementSyntax> declarationsToRemove, Workspace workspace,
+            HashSet<StatementSyntax> declarationsToRemove,
+            HostWorkspaceServices services,
             CancellationToken cancellationToken)
         {
             declarator = currentRoot.GetCurrentNode(declarator);
             identifier = currentRoot.GetCurrentNode(identifier);
 
-            var editor = new SyntaxEditor(currentRoot, workspace);
+            var editor = new SyntaxEditor(currentRoot, services);
             var sourceText = currentRoot.GetText();
 
             var declaration = (VariableDeclarationSyntax)declarator.Parent;
diff --git a/src/Analyzers/CSharp/CodeFixes/NewLines/EmbeddedStatementPlacement/EmbeddedStatementPlacementCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/NewLines/EmbeddedStatementPlacement/EmbeddedStatementPlacementCodeFixProvider.cs
index 5cd909b3e3a4a..e64daef64661a 100644
--- a/src/Analyzers/CSharp/CodeFixes/NewLines/EmbeddedStatementPlacement/EmbeddedStatementPlacementCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/NewLines/EmbeddedStatementPlacement/EmbeddedStatementPlacementCodeFixProvider.cs
@@ -48,7 +48,7 @@ private static Task<Document> UpdateDocumentAsync(Document document, Diagnostic
         public static async Task<Document> FixAllAsync(Document document, ImmutableArray<Diagnostic> diagnostics, CancellationToken cancellationToken)
         {
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-            var editor = new SyntaxEditor(root, document.Project.Solution.Workspace);
+            var editor = new SyntaxEditor(root, document.Project.Solution.Workspace.Services);
 
 #if CODE_STYLE
             var options = document.Project.AnalyzerOptions.GetAnalyzerOptionSet(editor.OriginalRoot.SyntaxTree, cancellationToken);
diff --git a/src/Analyzers/CSharp/CodeFixes/RemoveConfusingSuppression/CSharpRemoveConfusingSuppressionCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/RemoveConfusingSuppression/CSharpRemoveConfusingSuppressionCodeFixProvider.cs
index be16457931985..f22d1c740f438 100644
--- a/src/Analyzers/CSharp/CodeFixes/RemoveConfusingSuppression/CSharpRemoveConfusingSuppressionCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/RemoveConfusingSuppression/CSharpRemoveConfusingSuppressionCodeFixProvider.cs
@@ -64,7 +64,7 @@ private static async Task<Document> FixAllAsync(
         {
             var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-            var editor = new SyntaxEditor(root, document.Project.Solution.Workspace);
+            var editor = new SyntaxEditor(root, document.Project.Solution.Workspace.Services);
             var generator = editor.Generator;
             var generatorInternal = document.GetRequiredLanguageService<SyntaxGeneratorInternal>();
 
diff --git a/src/Analyzers/CSharp/CodeFixes/UseDeconstruction/CSharpUseDeconstructionCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/UseDeconstruction/CSharpUseDeconstructionCodeFixProvider.cs
index 08938c6f630c8..f3cbd2965bf58 100644
--- a/src/Analyzers/CSharp/CodeFixes/UseDeconstruction/CSharpUseDeconstructionCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/UseDeconstruction/CSharpUseDeconstructionCodeFixProvider.cs
@@ -17,6 +17,7 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 
 namespace Microsoft.CodeAnalysis.CSharp.UseDeconstruction
@@ -59,13 +60,13 @@ protected override Task FixAllAsync(
             return editor.ApplyMethodBodySemanticEditsAsync(
                 document, nodesToProcess,
                 (semanticModel, node) => true,
-                (semanticModel, currentRoot, node) => UpdateRoot(semanticModel, currentRoot, node, document.Project.Solution.Workspace, cancellationToken),
+                (semanticModel, currentRoot, node) => UpdateRoot(semanticModel, currentRoot, node, document.Project.Solution.Workspace.Services, cancellationToken),
                 cancellationToken);
         }
 
-        private SyntaxNode UpdateRoot(SemanticModel semanticModel, SyntaxNode root, SyntaxNode node, Workspace workspace, CancellationToken cancellationToken)
+        private SyntaxNode UpdateRoot(SemanticModel semanticModel, SyntaxNode root, SyntaxNode node, HostWorkspaceServices services, CancellationToken cancellationToken)
         {
-            var editor = new SyntaxEditor(root, workspace);
+            var editor = new SyntaxEditor(root, services);
 
             // We use the callback form of ReplaceNode because we may have nested code that
             // needs to be updated in fix-all situations.  For example, nested foreach statements.
diff --git a/src/Analyzers/Core/CodeFixes/ConvertTypeOfToNameOf/AbstractConvertTypeOfToNameOfCodeFixProvider.cs b/src/Analyzers/Core/CodeFixes/ConvertTypeOfToNameOf/AbstractConvertTypeOfToNameOfCodeFixProvider.cs
index 7652971eb9e0f..e5874726f07de 100644
--- a/src/Analyzers/Core/CodeFixes/ConvertTypeOfToNameOf/AbstractConvertTypeOfToNameOfCodeFixProvider.cs
+++ b/src/Analyzers/Core/CodeFixes/ConvertTypeOfToNameOf/AbstractConvertTypeOfToNameOfCodeFixProvider.cs
@@ -12,6 +12,7 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.ConvertTypeOfToNameOf
 {
@@ -52,7 +53,7 @@ public void ConvertTypeOfToNameOf(SemanticModel semanticModel, SyntaxEditor edit
             editor.ReplaceNode(nodeToReplace, nameOfSyntax);
         }
 
-        protected abstract SyntaxNode? GetSymbolTypeExpression(SemanticModel model, SyntaxNode node, CancellationToken cancellationToken);
+        protected abstract SyntaxNode GetSymbolTypeExpression(SemanticModel model, SyntaxNode node, CancellationToken cancellationToken);
 
         protected abstract string GetCodeFixTitle();
 
diff --git a/src/Analyzers/Core/CodeFixes/RemoveUnusedParametersAndValues/AbstractRemoveUnusedValuesCodeFixProvider.cs b/src/Analyzers/Core/CodeFixes/RemoveUnusedParametersAndValues/AbstractRemoveUnusedValuesCodeFixProvider.cs
index 7bdf8900e18fe..0b133d8db6d5f 100644
--- a/src/Analyzers/Core/CodeFixes/RemoveUnusedParametersAndValues/AbstractRemoveUnusedValuesCodeFixProvider.cs
+++ b/src/Analyzers/Core/CodeFixes/RemoveUnusedParametersAndValues/AbstractRemoveUnusedValuesCodeFixProvider.cs
@@ -284,7 +284,7 @@ private async Task<SyntaxNode> GetNewRootAsync(
             var semanticFacts = document.GetRequiredLanguageService<ISemanticFactsService>();
             var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
 
-            var editor = new SyntaxEditor(root, document.Project.Solution.Workspace);
+            var editor = new SyntaxEditor(root, document.Project.Solution.Workspace.Services);
 
             // We compute the code fix in two passes:
             //   1. The first pass groups the diagnostics to fix by containing member declaration and
@@ -785,7 +785,7 @@ private async Task<SyntaxNode> ReplaceDiscardDeclarationsWithAssignmentsAsync(Sy
             }
 
             var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
-            return await service.ReplaceAsync(memberDeclaration, semanticModel, document.Project.Solution.Workspace, cancellationToken).ConfigureAwait(false);
+            return await service.ReplaceAsync(memberDeclaration, semanticModel, document.Project.Solution.Workspace.Services, cancellationToken).ConfigureAwait(false);
         }
 
         /// <summary>
diff --git a/src/Analyzers/Core/CodeFixes/SimplifyInterpolation/AbstractSimplifyInterpolationCodeFixProvider.cs b/src/Analyzers/Core/CodeFixes/SimplifyInterpolation/AbstractSimplifyInterpolationCodeFixProvider.cs
index 47d4aa9417fa8..11826a68d818b 100644
--- a/src/Analyzers/Core/CodeFixes/SimplifyInterpolation/AbstractSimplifyInterpolationCodeFixProvider.cs
+++ b/src/Analyzers/Core/CodeFixes/SimplifyInterpolation/AbstractSimplifyInterpolationCodeFixProvider.cs
@@ -74,7 +74,10 @@ protected override async Task FixAllAsync(
                     if (unwrapped == null)
                         continue;
 
-                    alignment = negate ? (TExpressionSyntax)generator.NegateExpression(alignment) : alignment;
+                    if (alignment != null && negate)
+                    {
+                        alignment = (TExpressionSyntax)generator.NegateExpression(alignment);
+                    }
 
                     editor.ReplaceNode(
                         interpolationSyntax,
diff --git a/src/Analyzers/Core/CodeFixes/UseCollectionInitializer/AbstractUseCollectionInitializerCodeFixProvider.cs b/src/Analyzers/Core/CodeFixes/UseCollectionInitializer/AbstractUseCollectionInitializerCodeFixProvider.cs
index ca6a417aff88a..ca768f3bbb160 100644
--- a/src/Analyzers/Core/CodeFixes/UseCollectionInitializer/AbstractUseCollectionInitializerCodeFixProvider.cs
+++ b/src/Analyzers/Core/CodeFixes/UseCollectionInitializer/AbstractUseCollectionInitializerCodeFixProvider.cs
@@ -66,7 +66,7 @@ protected override async Task FixAllAsync(
             // feature to keep track of all the object creation nodes as we make edits to
             // the tree.  If we didn't do this, then we wouldn't be able to find the 
             // second object-creation-node after we make the edit for the first one.
-            var workspace = document.Project.Solution.Workspace;
+            var services = document.Project.Solution.Workspace.Services;
             var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
             var originalRoot = editor.OriginalRoot;
 
@@ -103,7 +103,7 @@ protected override async Task FixAllAsync(
                 var newStatement = GetNewStatement(statement, objectCreation, matches.Value)
                     .WithAdditionalAnnotations(Formatter.Annotation);
 
-                var subEditor = new SyntaxEditor(currentRoot, workspace);
+                var subEditor = new SyntaxEditor(currentRoot, services);
 
                 subEditor.ReplaceNode(statement, newStatement);
                 foreach (var match in matches)
diff --git a/src/Analyzers/Core/CodeFixes/UseConditionalExpression/AbstractUseConditionalExpressionCodeFixProvider.cs b/src/Analyzers/Core/CodeFixes/UseConditionalExpression/AbstractUseConditionalExpressionCodeFixProvider.cs
index 6fc99fac7febf..385a3eae9ab3d 100644
--- a/src/Analyzers/Core/CodeFixes/UseConditionalExpression/AbstractUseConditionalExpressionCodeFixProvider.cs
+++ b/src/Analyzers/Core/CodeFixes/UseConditionalExpression/AbstractUseConditionalExpressionCodeFixProvider.cs
@@ -55,7 +55,7 @@ protected override async Task FixAllAsync(
             // will return 'true' if it made a multi-line conditional expression. In that case,
             // we'll need to explicitly format this node so we can get our special multi-line
             // formatting in VB and C#.
-            var nestedEditor = new SyntaxEditor(root, document.Project.Solution.Workspace);
+            var nestedEditor = new SyntaxEditor(root, document.Project.Solution.Workspace.Services);
             foreach (var diagnostic in diagnostics)
             {
                 await FixOneAsync(
diff --git a/src/Analyzers/Core/CodeFixes/UseExplicitTupleName/UseExplicitTupleNameCodeFixProvider.cs b/src/Analyzers/Core/CodeFixes/UseExplicitTupleName/UseExplicitTupleNameCodeFixProvider.cs
index 58e51ac34c255..f38c06d61765b 100644
--- a/src/Analyzers/Core/CodeFixes/UseExplicitTupleName/UseExplicitTupleNameCodeFixProvider.cs
+++ b/src/Analyzers/Core/CodeFixes/UseExplicitTupleName/UseExplicitTupleNameCodeFixProvider.cs
@@ -13,6 +13,7 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.UseExplicitTupleName
 {
@@ -50,6 +51,8 @@ protected override Task FixAllAsync(
                     getInnermostNodeForTie: true, cancellationToken: cancellationToken);
 
                 var preferredName = diagnostic.Properties[nameof(UseExplicitTupleNameDiagnosticAnalyzer.ElementName)];
+                Contract.ThrowIfNull(preferredName);
+
                 var newNameNode = generator.IdentifierName(preferredName).WithTriviaFrom(oldNameNode);
 
                 editor.ReplaceNode(oldNameNode, newNameNode);
diff --git a/src/Analyzers/Core/CodeFixes/UseObjectInitializer/AbstractUseObjectInitializerCodeFixProvider.cs b/src/Analyzers/Core/CodeFixes/UseObjectInitializer/AbstractUseObjectInitializerCodeFixProvider.cs
index 8361ab13b3794..c0ffaad144840 100644
--- a/src/Analyzers/Core/CodeFixes/UseObjectInitializer/AbstractUseObjectInitializerCodeFixProvider.cs
+++ b/src/Analyzers/Core/CodeFixes/UseObjectInitializer/AbstractUseObjectInitializerCodeFixProvider.cs
@@ -64,7 +64,7 @@ protected override async Task FixAllAsync(
             // feature to keep track of all the object creation nodes as we make edits to
             // the tree.  If we didn't do this, then we wouldn't be able to find the 
             // second object-creation-node after we make the edit for the first one.
-            var workspace = document.Project.Solution.Workspace;
+            var services = document.Project.Solution.Workspace.Services;
             var syntaxFacts = document.GetLanguageService<ISyntaxFactsService>();
 
             var originalRoot = editor.OriginalRoot;
@@ -102,7 +102,7 @@ protected override async Task FixAllAsync(
                 var newStatement = GetNewStatement(statement, objectCreation, matches.Value)
                     .WithAdditionalAnnotations(Formatter.Annotation);
 
-                var subEditor = new SyntaxEditor(currentRoot, workspace);
+                var subEditor = new SyntaxEditor(currentRoot, services);
 
                 subEditor.ReplaceNode(statement, newStatement);
                 foreach (var match in matches)
diff --git a/src/Analyzers/VisualBasic/CodeFixes/ConvertTypeOfToNameOf/VisualBasicConvertGetTypeToNameOfCodeFixProvider.vb b/src/Analyzers/VisualBasic/CodeFixes/ConvertTypeOfToNameOf/VisualBasicConvertGetTypeToNameOfCodeFixProvider.vb
index e797cbe784e0d..ebd78b84bde41 100644
--- a/src/Analyzers/VisualBasic/CodeFixes/ConvertTypeOfToNameOf/VisualBasicConvertGetTypeToNameOfCodeFixProvider.vb
+++ b/src/Analyzers/VisualBasic/CodeFixes/ConvertTypeOfToNameOf/VisualBasicConvertGetTypeToNameOfCodeFixProvider.vb
@@ -43,7 +43,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ConvertTypeOfToNameOf
                     .WithAdditionalAnnotations(Simplifier.Annotation)
             End If
 
-            Return Nothing
+            ' Corresponding analyzer VisualBasicConvertTypeOfToNameOfDiagnosticAnalyzer validated the above syntax
+            Throw ExceptionUtilities.Unreachable
         End Function
     End Class
 End Namespace
diff --git a/src/Analyzers/VisualBasic/CodeFixes/RemoveUnnecessaryCast/VisualBasicRemoveUnnecessaryCastCodeFixProvider.vb b/src/Analyzers/VisualBasic/CodeFixes/RemoveUnnecessaryCast/VisualBasicRemoveUnnecessaryCastCodeFixProvider.vb
index 1a3347ddc78c0..9b168e1c56811 100644
--- a/src/Analyzers/VisualBasic/CodeFixes/RemoveUnnecessaryCast/VisualBasicRemoveUnnecessaryCastCodeFixProvider.vb
+++ b/src/Analyzers/VisualBasic/CodeFixes/RemoveUnnecessaryCast/VisualBasicRemoveUnnecessaryCastCodeFixProvider.vb
@@ -105,7 +105,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.RemoveUnnecessaryCast
             ' Now, find the cast nodes again in the expanded document
             Dim currentCastNodes = root.GetCurrentNodes(originalCastNodes)
 
-            Dim innerEditor = New SyntaxEditor(root, document.Project.Solution.Workspace)
+            Dim innerEditor = New SyntaxEditor(root, document.Project.Solution.Workspace.Services)
             Await innerEditor.ApplyExpressionLevelSemanticEditsAsync(
                 document, currentCastNodes.ToImmutableArray(),
                 Function(semanticModel, castExpression) IsUnnecessaryCast(castExpression, semanticModel, cancellationToken),
@@ -122,7 +122,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.RemoveUnnecessaryCast
                 document As Document, originalNodes As ImmutableArray(Of ExpressionSyntax),
                 cancellationToken As CancellationToken) As Task(Of SyntaxNode)
 
-            Dim semanticModel = Await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(False)
             Dim root = Await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(False)
 
             ' Note: we not only get the containing statement, but also the next statement after
@@ -140,13 +139,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.RemoveUnnecessaryCast
                         {containingStatement, nextStatement})
                 End Function).Distinct()
 
-            Dim workspace = document.Project.Solution.Workspace
-            Dim editor = New SyntaxEditor(root, workspace)
+            Dim editor = New SyntaxEditor(root, document.Project.Solution.Workspace.Services)
 
             For Each containingStatement In containingAndNextStatements
-                Dim expandedStatement = Simplifier.Expand(
-                    containingStatement, semanticModel, workspace,
-                    cancellationToken:=cancellationToken)
+                Dim expandedStatement = Await Simplifier.ExpandAsync(containingStatement, document, cancellationToken:=cancellationToken).ConfigureAwait(False)
                 editor.ReplaceNode(containingStatement, expandedStatement)
             Next
 
diff --git a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt
index b5c745565d45f..2f98edd93ba78 100644
--- a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt
+++ b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt
@@ -141,15 +141,39 @@ static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeDataFlow(this Micro
 override Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor! visitor) -> void
 override Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult>! visitor) -> TResult?
 static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax! declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.INamespaceSymbol?
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax? initializer, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+*REMOVED*static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax! initializer, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! body) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax? initializer, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+*REMOVED*static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConstructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax! initializer, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
+*REMOVED*static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ConversionOperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken tildeToken, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
+*REMOVED*static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DestructorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken tildeToken, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumMemberDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax? equalsValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax!
+*REMOVED*static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EnumMemberDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax! equalsValue) -> Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax!
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax!
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax!
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.SyntaxToken namespaceKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax! name, Microsoft.CodeAnalysis.SyntaxToken semicolonToken, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax!> externs, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax!> usings, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax!> members) -> Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax? accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax!
+*REMOVED*static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IndexerDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax! explicitInterfaceSpecifier, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax! accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+*REMOVED*static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax! typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax! expressionBody) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+*REMOVED*static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.LocalFunctionStatement(Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax! typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax!> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax! expressionBody, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
+*REMOVED*static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.OperatorDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! returnType, Microsoft.CodeAnalysis.SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax! parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! body, Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax!
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Parameter(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.SyntaxToken exclamationExclamationToken, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax? default) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax!
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ListPattern(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax!> patterns = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax!>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax!
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ListPattern(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax!> patterns, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax? designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax!
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ListPattern(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax!> patterns, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax? designation) -> Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax! accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax!
+*REMOVED*static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.PropertyDeclaration(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax!> attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax! explicitInterfaceSpecifier, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax! accessorList) -> Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax!
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SlicePattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax? pattern = null) -> Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax!
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SlicePattern(Microsoft.CodeAnalysis.SyntaxToken dotDotToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax? pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!> catches, Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax? finally) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax!
+*REMOVED*static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!> catches, Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax! finally) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax!
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.SyntaxToken tryKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!> catches, Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax? finally) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax!
+*REMOVED*static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TryStatement(Microsoft.CodeAnalysis.SyntaxToken tryKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax! block, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax!> catches, Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax! finally) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax!
 virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax! node) -> void
 virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitListPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax! node) -> void
 virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitSlicePattern(Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax! node) -> void
diff --git a/src/Compilers/CSharp/Portable/Syntax/ConstructorDeclarationSyntax.cs b/src/Compilers/CSharp/Portable/Syntax/ConstructorDeclarationSyntax.cs
index bc5f77fa7fd0d..324e4a1967b4d 100644
--- a/src/Compilers/CSharp/Portable/Syntax/ConstructorDeclarationSyntax.cs
+++ b/src/Compilers/CSharp/Portable/Syntax/ConstructorDeclarationSyntax.cs
@@ -39,7 +39,7 @@ public static ConstructorDeclarationSyntax ConstructorDeclaration(
             SyntaxTokenList modifiers,
             SyntaxToken identifier,
             ParameterListSyntax parameterList,
-            ConstructorInitializerSyntax initializer,
+            ConstructorInitializerSyntax? initializer,
             BlockSyntax body)
             => ConstructorDeclaration(
                 attributeLists,
@@ -56,8 +56,8 @@ public static ConstructorDeclarationSyntax ConstructorDeclaration(
             SyntaxTokenList modifiers,
             SyntaxToken identifier,
             ParameterListSyntax parameterList,
-            ConstructorInitializerSyntax initializer,
-            BlockSyntax body,
+            ConstructorInitializerSyntax? initializer,
+            BlockSyntax? body,
             SyntaxToken semicolonToken)
             => ConstructorDeclaration(
                 attributeLists,
diff --git a/src/Compilers/CSharp/Portable/Syntax/DestructorDeclarationSyntax.cs b/src/Compilers/CSharp/Portable/Syntax/DestructorDeclarationSyntax.cs
index b6a1ffc1ec00e..4140104da4b4c 100644
--- a/src/Compilers/CSharp/Portable/Syntax/DestructorDeclarationSyntax.cs
+++ b/src/Compilers/CSharp/Portable/Syntax/DestructorDeclarationSyntax.cs
@@ -56,7 +56,7 @@ public static DestructorDeclarationSyntax DestructorDeclaration(
             SyntaxToken tildeToken,
             SyntaxToken identifier,
             ParameterListSyntax parameterList,
-            BlockSyntax body,
+            BlockSyntax? body,
             SyntaxToken semicolonToken)
             => DestructorDeclaration(
                 attributeLists,
diff --git a/src/Compilers/CSharp/Portable/Syntax/IndexerDeclarationSyntax.cs b/src/Compilers/CSharp/Portable/Syntax/IndexerDeclarationSyntax.cs
index c87269a9fe8bc..783602f0ffd65 100644
--- a/src/Compilers/CSharp/Portable/Syntax/IndexerDeclarationSyntax.cs
+++ b/src/Compilers/CSharp/Portable/Syntax/IndexerDeclarationSyntax.cs
@@ -37,9 +37,9 @@ public static IndexerDeclarationSyntax IndexerDeclaration(
             SyntaxList<AttributeListSyntax> attributeLists,
             SyntaxTokenList modifiers,
             TypeSyntax type,
-            ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier,
+            ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier,
             BracketedParameterListSyntax parameterList,
-            AccessorListSyntax accessorList)
+            AccessorListSyntax? accessorList)
         {
             return SyntaxFactory.IndexerDeclaration(
                 attributeLists: attributeLists,
diff --git a/src/Compilers/CSharp/Portable/Syntax/LocalFunctionStatementSyntax.cs b/src/Compilers/CSharp/Portable/Syntax/LocalFunctionStatementSyntax.cs
index be7e4cfc5ac64..4cb9a352a0052 100644
--- a/src/Compilers/CSharp/Portable/Syntax/LocalFunctionStatementSyntax.cs
+++ b/src/Compilers/CSharp/Portable/Syntax/LocalFunctionStatementSyntax.cs
@@ -21,13 +21,13 @@ namespace Microsoft.CodeAnalysis.CSharp
     public partial class SyntaxFactory
     {
         // Preserved as shipped public API for binary compatibility
-        public static LocalFunctionStatementSyntax LocalFunctionStatement(SyntaxTokenList modifiers, TypeSyntax returnType, SyntaxToken identifier, TypeParameterListSyntax typeParameterList, ParameterListSyntax parameterList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, BlockSyntax body, ArrowExpressionClauseSyntax expressionBody)
+        public static LocalFunctionStatementSyntax LocalFunctionStatement(SyntaxTokenList modifiers, TypeSyntax returnType, SyntaxToken identifier, TypeParameterListSyntax? typeParameterList, ParameterListSyntax parameterList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody)
         {
             return LocalFunctionStatement(attributeLists: default, modifiers, returnType, identifier, typeParameterList, parameterList, constraintClauses, body, expressionBody, semicolonToken: default);
         }
 
         // Preserved as shipped public API for binary compatibility
-        public static LocalFunctionStatementSyntax LocalFunctionStatement(SyntaxTokenList modifiers, TypeSyntax returnType, SyntaxToken identifier, TypeParameterListSyntax typeParameterList, ParameterListSyntax parameterList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, BlockSyntax body, ArrowExpressionClauseSyntax expressionBody, SyntaxToken semicolonToken)
+        public static LocalFunctionStatementSyntax LocalFunctionStatement(SyntaxTokenList modifiers, TypeSyntax returnType, SyntaxToken identifier, TypeParameterListSyntax? typeParameterList, ParameterListSyntax parameterList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken semicolonToken)
         {
             return LocalFunctionStatement(attributeLists: default, modifiers, returnType, identifier, typeParameterList, parameterList, constraintClauses, body, expressionBody, semicolonToken);
         }
diff --git a/src/Compilers/CSharp/Portable/Syntax/SyntaxFactory.cs b/src/Compilers/CSharp/Portable/Syntax/SyntaxFactory.cs
index e376a328ebd23..49a4d992f79ae 100644
--- a/src/Compilers/CSharp/Portable/Syntax/SyntaxFactory.cs
+++ b/src/Compilers/CSharp/Portable/Syntax/SyntaxFactory.cs
@@ -2434,7 +2434,7 @@ public static PropertyDeclarationSyntax PropertyDeclaration(
             SyntaxList<AttributeListSyntax> attributeLists,
             SyntaxTokenList modifiers,
             TypeSyntax type,
-            ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier,
+            ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier,
             SyntaxToken identifier,
             AccessorListSyntax accessorList)
         {
@@ -2456,7 +2456,7 @@ public static ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(
             SyntaxToken operatorKeyword,
             TypeSyntax type,
             ParameterListSyntax parameterList,
-            BlockSyntax body,
+            BlockSyntax? body,
             SyntaxToken semicolonToken)
         {
             return SyntaxFactory.ConversionOperatorDeclaration(
@@ -2522,7 +2522,7 @@ public static OperatorDeclarationSyntax OperatorDeclaration(
             SyntaxToken operatorKeyword,
             SyntaxToken operatorToken,
             ParameterListSyntax parameterList,
-            BlockSyntax body,
+            BlockSyntax? body,
             SyntaxToken semicolonToken)
         {
             return SyntaxFactory.OperatorDeclaration(
@@ -2615,7 +2615,7 @@ public static AccessorDeclarationSyntax AccessorDeclaration(SyntaxKind kind, Syn
         public static AccessorDeclarationSyntax AccessorDeclaration(SyntaxKind kind, SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken keyword, ArrowExpressionClauseSyntax expressionBody, SyntaxToken semicolonToken)
                 => SyntaxFactory.AccessorDeclaration(kind, attributeLists, modifiers, keyword, body: null, expressionBody, semicolonToken);
 
-        public static EnumMemberDeclarationSyntax EnumMemberDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken identifier, EqualsValueClauseSyntax equalsValue)
+        public static EnumMemberDeclarationSyntax EnumMemberDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxToken identifier, EqualsValueClauseSyntax? equalsValue)
             => EnumMemberDeclaration(attributeLists, modifiers: default,
                 identifier, equalsValue);
 
diff --git a/src/Compilers/CSharp/Portable/Syntax/TryStatementSyntax.cs b/src/Compilers/CSharp/Portable/Syntax/TryStatementSyntax.cs
index ff95cd467ee33..9f3012ba122f9 100644
--- a/src/Compilers/CSharp/Portable/Syntax/TryStatementSyntax.cs
+++ b/src/Compilers/CSharp/Portable/Syntax/TryStatementSyntax.cs
@@ -17,10 +17,10 @@ namespace Microsoft.CodeAnalysis.CSharp
 {
     public partial class SyntaxFactory
     {
-        public static TryStatementSyntax TryStatement(BlockSyntax block, SyntaxList<CatchClauseSyntax> catches, FinallyClauseSyntax @finally)
+        public static TryStatementSyntax TryStatement(BlockSyntax block, SyntaxList<CatchClauseSyntax> catches, FinallyClauseSyntax? @finally)
             => TryStatement(attributeLists: default, block, catches, @finally);
 
-        public static TryStatementSyntax TryStatement(SyntaxToken tryKeyword, BlockSyntax block, SyntaxList<CatchClauseSyntax> catches, FinallyClauseSyntax @finally)
+        public static TryStatementSyntax TryStatement(SyntaxToken tryKeyword, BlockSyntax block, SyntaxList<CatchClauseSyntax> catches, FinallyClauseSyntax? @finally)
             => TryStatement(attributeLists: default, tryKeyword, block, catches, @finally);
     }
 }
diff --git a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
index ad76fcb80cd4d..d77fc95e2bc14 100644
--- a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
+++ b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
@@ -199,6 +199,8 @@ static Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Where<TSource>(
 static Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.WithComparer<TSource>(this Microsoft.CodeAnalysis.IncrementalValueProvider<TSource> source, System.Collections.Generic.IEqualityComparer<TSource>! comparer) -> Microsoft.CodeAnalysis.IncrementalValueProvider<TSource>
 static Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.WithComparer<TSource>(this Microsoft.CodeAnalysis.IncrementalValuesProvider<TSource> source, System.Collections.Generic.IEqualityComparer<TSource>! comparer) -> Microsoft.CodeAnalysis.IncrementalValuesProvider<TSource>
 static Microsoft.CodeAnalysis.Operations.OperationExtensions.GetFunctionPointerSignature(this Microsoft.CodeAnalysis.Operations.IFunctionPointerInvocationOperation! functionPointer) -> Microsoft.CodeAnalysis.IMethodSymbol!
+*REMOVED*static Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceSyntax<TRoot>(this TRoot! root, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxNode!>! nodes, System.Func<Microsoft.CodeAnalysis.SyntaxNode!, Microsoft.CodeAnalysis.SyntaxNode!, Microsoft.CodeAnalysis.SyntaxNode!>! computeReplacementNode, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxToken>! tokens, System.Func<Microsoft.CodeAnalysis.SyntaxToken, Microsoft.CodeAnalysis.SyntaxToken, Microsoft.CodeAnalysis.SyntaxToken>! computeReplacementToken, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxTrivia>! trivia, System.Func<Microsoft.CodeAnalysis.SyntaxTrivia, Microsoft.CodeAnalysis.SyntaxTrivia, Microsoft.CodeAnalysis.SyntaxTrivia>! computeReplacementTrivia) -> TRoot!
+static Microsoft.CodeAnalysis.SyntaxNodeExtensions.ReplaceSyntax<TRoot>(this TRoot! root, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxNode!>? nodes, System.Func<Microsoft.CodeAnalysis.SyntaxNode!, Microsoft.CodeAnalysis.SyntaxNode!, Microsoft.CodeAnalysis.SyntaxNode!>? computeReplacementNode, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxToken>? tokens, System.Func<Microsoft.CodeAnalysis.SyntaxToken, Microsoft.CodeAnalysis.SyntaxToken, Microsoft.CodeAnalysis.SyntaxToken>? computeReplacementToken, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxTrivia>? trivia, System.Func<Microsoft.CodeAnalysis.SyntaxTrivia, Microsoft.CodeAnalysis.SyntaxTrivia, Microsoft.CodeAnalysis.SyntaxTrivia>? computeReplacementTrivia) -> TRoot!
 virtual Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.GetGenerators(string! language) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.ISourceGenerator!>
 virtual Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference.GetGeneratorsForAllLanguages() -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.ISourceGenerator!>
 abstract Microsoft.CodeAnalysis.Compilation.GetUsedAssemblyReferences(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.MetadataReference!>
diff --git a/src/Compilers/Core/Portable/Syntax/SyntaxNodeExtensions.cs b/src/Compilers/Core/Portable/Syntax/SyntaxNodeExtensions.cs
index fee4ae0e0de3a..0003cf12531a5 100644
--- a/src/Compilers/Core/Portable/Syntax/SyntaxNodeExtensions.cs
+++ b/src/Compilers/Core/Portable/Syntax/SyntaxNodeExtensions.cs
@@ -29,12 +29,12 @@ public static partial class SyntaxNodeExtensions
         /// the same trivia with potentially rewritten sub structure.</param>
         public static TRoot ReplaceSyntax<TRoot>(
             this TRoot root,
-            IEnumerable<SyntaxNode> nodes,
-            Func<SyntaxNode, SyntaxNode, SyntaxNode> computeReplacementNode,
-            IEnumerable<SyntaxToken> tokens,
-            Func<SyntaxToken, SyntaxToken, SyntaxToken> computeReplacementToken,
-            IEnumerable<SyntaxTrivia> trivia,
-            Func<SyntaxTrivia, SyntaxTrivia, SyntaxTrivia> computeReplacementTrivia)
+            IEnumerable<SyntaxNode>? nodes,
+            Func<SyntaxNode, SyntaxNode, SyntaxNode>? computeReplacementNode,
+            IEnumerable<SyntaxToken>? tokens,
+            Func<SyntaxToken, SyntaxToken, SyntaxToken>? computeReplacementToken,
+            IEnumerable<SyntaxTrivia>? trivia,
+            Func<SyntaxTrivia, SyntaxTrivia, SyntaxTrivia>? computeReplacementTrivia)
             where TRoot : SyntaxNode
         {
             return (TRoot)root.ReplaceCore(
@@ -259,6 +259,7 @@ public static TRoot ReplaceTrivia<TRoot>(this TRoot root, SyntaxTrivia trivia, S
         /// <param name="root">The root node from which to remove a descendant node from.</param>
         /// <param name="node">The node to remove.</param>
         /// <param name="options">Options that determine how the node's trivia is treated.</param>
+        /// <returns>New root or null if the root node itself is removed.</returns>
         public static TRoot? RemoveNode<TRoot>(this TRoot root,
             SyntaxNode node,
             SyntaxRemoveOptions options)
diff --git a/src/EditorFeatures/CSharp/AutomaticCompletion/AutomaticLineEnderCommandHandler_Helpers.cs b/src/EditorFeatures/CSharp/AutomaticCompletion/AutomaticLineEnderCommandHandler_Helpers.cs
index 3e1503a8cba27..8584f95d56e60 100644
--- a/src/EditorFeatures/CSharp/AutomaticCompletion/AutomaticLineEnderCommandHandler_Helpers.cs
+++ b/src/EditorFeatures/CSharp/AutomaticCompletion/AutomaticLineEnderCommandHandler_Helpers.cs
@@ -29,7 +29,7 @@ private static (SyntaxNode newRoot, int nextCaretPosition) ReplaceStatementOwner
             ImmutableArray<StatementSyntax> nodesToInsert,
             CancellationToken cancellationToken)
         {
-            var rootEditor = new SyntaxEditor(root, document.Project.Solution.Workspace);
+            var rootEditor = new SyntaxEditor(root, document.Project.Solution.Workspace.Services);
 
             // 1. Insert the node before anchor node
             rootEditor.InsertAfter(anchorNode, nodesToInsert);
diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
index a66120dc6f69e..dc6f89353e7cc 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
@@ -10,6 +10,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeGeneration;
+using Microsoft.CodeAnalysis.CSharp.CodeGeneration;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Editing;
@@ -18,6 +19,7 @@
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.LanguageServices;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Simplification;
 using Microsoft.CodeAnalysis.Text;
@@ -156,7 +158,8 @@ private Solution CreateSolutionWithEventHandler(
 
             var documentWithNameAndAnnotationsAdded = AddMethodNameAndAnnotationsToSolution(document, eventHandlerMethodName, position, plusEqualsTokenAnnotation, cancellationToken);
             var semanticDocument = SemanticDocument.CreateAsync(documentWithNameAndAnnotationsAdded, cancellationToken).WaitAndGetResult(cancellationToken);
-            var updatedRoot = AddGeneratedHandlerMethodToSolution(semanticDocument, eventHandlerMethodName, plusEqualsTokenAnnotation, cancellationToken);
+            var preferences = CSharpCodeGenerationPreferences.FromDocumentAsync(semanticDocument.Document, cancellationToken).WaitAndGetResult(cancellationToken);
+            var updatedRoot = AddGeneratedHandlerMethodToSolution(semanticDocument, preferences, eventHandlerMethodName, plusEqualsTokenAnnotation, cancellationToken);
 
             if (updatedRoot == null)
             {
@@ -216,6 +219,7 @@ private static Document AddMethodNameAndAnnotationsToSolution(
 
         private static SyntaxNode AddGeneratedHandlerMethodToSolution(
             SemanticDocument document,
+            CSharpCodeGenerationPreferences preferences,
             string eventHandlerMethodName,
             SyntaxAnnotation plusEqualsTokenAnnotation,
             CancellationToken cancellationToken)
@@ -234,7 +238,12 @@ private static SyntaxNode AddGeneratedHandlerMethodToSolution(
 
             var container = (SyntaxNode)typeDecl ?? eventHookupExpression.GetAncestor<CompilationUnitSyntax>();
 
-            var newContainer = CodeGenerator.AddMethodDeclaration(container, generatedMethodSymbol, document.Project.Solution.Workspace, new CodeGenerationOptions(afterThisLocation: eventHookupExpression.GetLocation()));
+            var codeGenerator = document.Document.GetRequiredLanguageService<ICodeGenerationService>();
+
+            var codeGenOptions = preferences.GetOptions(
+                new CodeGenerationContext(afterThisLocation: eventHookupExpression.GetLocation()));
+
+            var newContainer = codeGenerator.AddMethod(container, generatedMethodSymbol, codeGenOptions, cancellationToken);
 
             return root.ReplaceNode(container, newContainer);
         }
diff --git a/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.CSharp.cs b/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.CSharp.cs
index c569be4d95dcd..e7706f9195b6b 100644
--- a/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.CSharp.cs
+++ b/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.CSharp.cs
@@ -123,7 +123,7 @@ public async Task AddConstructorWithoutBody()
     public C();
 }";
                 await TestAddConstructorAsync(input, expected,
-                    codeGenerationOptions: new CodeGenerationOptions(generateMethodBodies: false));
+                    context: new CodeGenerationContext(generateMethodBodies: false));
             }
 
             [Fact, Trait(Traits.Feature, Traits.Features.CodeGeneration)]
@@ -365,7 +365,7 @@ public async Task AddEvent()
     public event System.Action E;
 }";
                 await TestAddEventAsync(input, expected,
-                    codeGenerationOptions: new CodeGenerationOptions(addImports: false));
+                    context: new CodeGenerationContext(addImports: false));
             }
 
             [Fact, Trait(Traits.Feature, Traits.Features.CodeGeneration)]
@@ -400,8 +400,8 @@ event EventHandler Click
         }
     }
 }";
-                var options = new CodeGenerationOptions(reuseSyntax: true);
-                await TestGenerateFromSourceSymbolAsync(sourceGenerated, input, expected, onlyGenerateMembers: true, codeGenerationOptions: options);
+                var context = new CodeGenerationContext(reuseSyntax: true);
+                await TestGenerateFromSourceSymbolAsync(sourceGenerated, input, expected, onlyGenerateMembers: true, context: context);
             }
 
             [Fact, Trait(Traits.Feature, Traits.Features.CodeGeneration)]
@@ -414,7 +414,7 @@ public async Task AddUnsafeEvent()
 }";
                 await TestAddEventAsync(input, expected,
                     modifiers: new Editing.DeclarationModifiers(isUnsafe: true),
-                    codeGenerationOptions: new CodeGenerationOptions(addImports: false));
+                    context: new CodeGenerationContext(addImports: false));
             }
 
             [Fact, Trait(Traits.Feature, Traits.Features.CodeGeneration)]
@@ -437,7 +437,7 @@ public event System.Action E
                 await TestAddEventAsync(input, expected,
                     addMethod: CodeGenerationSymbolFactory.CreateAccessorSymbol(ImmutableArray<AttributeData>.Empty, Accessibility.NotApplicable, ImmutableArray<SyntaxNode>.Empty),
                     removeMethod: CodeGenerationSymbolFactory.CreateAccessorSymbol(ImmutableArray<AttributeData>.Empty, Accessibility.NotApplicable, ImmutableArray<SyntaxNode>.Empty),
-                    codeGenerationOptions: new CodeGenerationOptions(addImports: false));
+                    context: new CodeGenerationContext(addImports: false));
             }
 
             [Fact, Trait(Traits.Feature, Traits.Features.CodeGeneration)]
@@ -472,8 +472,8 @@ public int FInt()
         return 0;
     }
 }";
-                var options = new CodeGenerationOptions(reuseSyntax: true);
-                await TestGenerateFromSourceSymbolAsync(sourceGenerated, input, expected, onlyGenerateMembers: true, codeGenerationOptions: options);
+                var context = new CodeGenerationContext(reuseSyntax: true);
+                await TestGenerateFromSourceSymbolAsync(sourceGenerated, input, expected, onlyGenerateMembers: true, context: context);
             }
 
             [Fact, Trait(Traits.Feature, Traits.Features.CodeGeneration)]
@@ -551,7 +551,7 @@ public async Task AddMethodWithoutBody()
 }";
                 await TestAddMethodAsync(input, expected,
                     returnType: typeof(int),
-                    codeGenerationOptions: new CodeGenerationOptions(generateMethodBodies: false));
+                    context: new CodeGenerationContext(generateMethodBodies: false));
             }
 
             [Fact, Trait(Traits.Feature, Traits.Features.CodeGeneration)]
@@ -1003,8 +1003,8 @@ public int P
         }
     }
 }";
-                var options = new CodeGenerationOptions(reuseSyntax: true);
-                await TestGenerateFromSourceSymbolAsync(sourceGenerated, input, expected, onlyGenerateMembers: true, codeGenerationOptions: options);
+                var context = new CodeGenerationContext(reuseSyntax: true);
+                await TestGenerateFromSourceSymbolAsync(sourceGenerated, input, expected, onlyGenerateMembers: true, context: context);
             }
 
             [Fact, Trait(Traits.Feature, Traits.Features.CodeGeneration)]
@@ -1016,8 +1016,7 @@ await TestAddPropertyAsync(input, expected,
                     type: typeof(string),
                     parameters: Parameters(Parameter(typeof(int), "i")),
                     getStatements: "return String.Empty;",
-                    isIndexer: true,
-                    codeGenerationOptions: new CodeGenerationOptions(parseOptions: CSharpParseOptions.Default));
+                    isIndexer: true);
             }
 
             [Fact, Trait(Traits.Feature, Traits.Features.CodeGeneration)]
@@ -1538,7 +1537,7 @@ public class C
 }";
                 await TestGenerateFromSourceSymbolAsync(generationSource, initial, expected,
                     forceLanguage: LanguageNames.CSharp,
-                    codeGenerationOptions: new CodeGenerationOptions(generateMethodBodies: false));
+                    context: new CodeGenerationContext(generateMethodBodies: false));
             }
         }
 
@@ -1557,7 +1556,7 @@ public static void ExtMethod1(this string s, int y, string z) {}
     public static void ExtMethod1(this string s, int y, string z);
 }";
             await TestGenerateFromSourceSymbolAsync(generationSource, initial, expected,
-                codeGenerationOptions: new CodeGenerationOptions(generateMethodBodies: false),
+                context: new CodeGenerationContext(generateMethodBodies: false),
                 onlyGenerateMembers: true);
         }
 
@@ -1589,7 +1588,7 @@ public class C
     }
 }";
             await TestGenerateFromSourceSymbolAsync(generationSource, initial, expected,
-                codeGenerationOptions: new CodeGenerationOptions(generateMethodBodies: false));
+                context: new CodeGenerationContext(generateMethodBodies: false));
         }
 
         [WorkItem(812738, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/812738")]
@@ -1607,7 +1606,7 @@ End Sub
     public void Goo(int x, ref int y, ref object z);
 }";
             await TestGenerateFromSourceSymbolAsync(generationSource, initial, expected,
-                codeGenerationOptions: new CodeGenerationOptions(generateMethodBodies: false),
+                context: new CodeGenerationContext(generateMethodBodies: false),
                 onlyGenerateMembers: true);
         }
 
@@ -1642,7 +1641,7 @@ public delegate void D<T, U>(T t, U u)
     }
 }";
             await TestGenerateFromSourceSymbolAsync(generationSource, initial, expected,
-                codeGenerationOptions: new CodeGenerationOptions(generateMethodBodies: false),
+                context: new CodeGenerationContext(generateMethodBodies: false),
                 onlyGenerateMembers: true);
         }
     }
diff --git a/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.Shared.cs b/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.Shared.cs
index 40cbb9df11e6a..6dd04f223f12f 100644
--- a/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.Shared.cs
+++ b/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.Shared.cs
@@ -343,7 +343,7 @@ private class CAccessA
     }
 }";
                 await TestGenerateFromSourceSymbolAsync(generationSource, initial, expected,
-                    codeGenerationOptions: new CodeGenerationOptions(generateMethodBodies: false),
+                    context: new CodeGenerationContext(generateMethodBodies: false),
                     forceLanguage: LanguageNames.CSharp);
 
                 initial = "Namespace [|N|] \n End Namespace";
@@ -510,7 +510,7 @@ Private Delegate Sub DAccessA()
     End Class
 End Namespace";
                 await TestGenerateFromSourceSymbolAsync(generationSource, initial, expected,
-                    codeGenerationOptions: new CodeGenerationOptions(generateMethodBodies: false),
+                    context: new CodeGenerationContext(generateMethodBodies: false),
                     forceLanguage: LanguageNames.VisualBasic);
             }
 
@@ -562,7 +562,7 @@ Private B As String
             [Fact, Trait(Traits.Feature, Traits.Features.CodeGenerationSortDeclarations)]
             public async Task TestDefaultTypeMemberAccessibility2()
             {
-                var codeGenOptionNoBody = new CodeGenerationOptions(generateMethodBodies: false);
+                var codeGenOptionNoBody = new CodeGenerationContext(generateMethodBodies: false);
 
                 var generationSource = "public class [|C|] { private void B(){} public void C(){}  }";
                 var initial = "public interface [|I|] { void A(); }";
@@ -570,7 +570,7 @@ public async Task TestDefaultTypeMemberAccessibility2()
     void B();
     void C();
 }";
-                await TestGenerateFromSourceSymbolAsync(generationSource, initial, expected, onlyGenerateMembers: true, codeGenerationOptions: codeGenOptionNoBody);
+                await TestGenerateFromSourceSymbolAsync(generationSource, initial, expected, onlyGenerateMembers: true, context: codeGenOptionNoBody);
 
                 initial = "Public Interface [|I|] \n Sub A() \n End Interface";
                 expected = @"Public Interface I 
@@ -578,7 +578,7 @@ Sub A()
     Sub B()
     Sub C()
 End Interface";
-                await TestGenerateFromSourceSymbolAsync(generationSource, initial, expected, onlyGenerateMembers: true, codeGenerationOptions: codeGenOptionNoBody);
+                await TestGenerateFromSourceSymbolAsync(generationSource, initial, expected, onlyGenerateMembers: true, context: codeGenOptionNoBody);
 
                 initial = "Public Class [|C|] \n Sub A() \n End Sub \n End Class";
                 expected = @"Public Class C 
@@ -670,7 +670,7 @@ public C() { }
     public C();
 }";
                 await TestGenerateFromSourceSymbolAsync(generationSource, initial, expected,
-                    codeGenerationOptions: new CodeGenerationOptions(generateMethodBodies: false, generateDocumentationComments: true),
+                    context: new CodeGenerationContext(generateMethodBodies: false, generateDocumentationComments: true),
                     onlyGenerateMembers: true);
             }
 
@@ -718,7 +718,7 @@ public class C
     }
 }";
                 await TestGenerateFromSourceSymbolAsync(generationSource, initial, expected,
-                    codeGenerationOptions: new CodeGenerationOptions(generateMethodBodies: false));
+                    context: new CodeGenerationContext(generateMethodBodies: false));
 
                 var initialVB = "Namespace [|N|] End Namespace";
                 var expectedVB = @"Namespace N End NamespaceNamespace N
@@ -735,7 +735,7 @@ Public NotOverridable Overrides Sub Method1()
         End Class
     End Namespace";
                 await TestGenerateFromSourceSymbolAsync(generationSource, initialVB, expectedVB,
-                    codeGenerationOptions: new CodeGenerationOptions(generateMethodBodies: false));
+                    context: new CodeGenerationContext(generateMethodBodies: false));
             }
         }
     }
diff --git a/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.VisualBasic.cs b/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.VisualBasic.cs
index 0f4ae26c5ed3d..33169949eae08 100644
--- a/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.VisualBasic.cs
+++ b/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.VisualBasic.cs
@@ -117,7 +117,7 @@ public async Task AddConstructorWithoutBody()
     Public Sub New()
 End Class";
                 await TestAddConstructorAsync(input, expected,
-                    codeGenerationOptions: new CodeGenerationOptions(generateMethodBodies: false));
+                    context: new CodeGenerationContext(generateMethodBodies: false));
             }
 
             [Fact, Trait(Traits.Feature, Traits.Features.CodeGeneration)]
@@ -355,7 +355,7 @@ Class C
     Public Event E As Action
 End Class";
                 await TestAddEventAsync(input, expected,
-                    codeGenerationOptions: new CodeGenerationOptions(addImports: false));
+                    context: new CodeGenerationContext(addImports: false));
             }
 
             [Fact, Trait(Traits.Feature, Traits.Features.CodeGeneration)]
@@ -388,8 +388,8 @@ End RemoveHandler
         End RaiseEvent
     End Event
 End Class";
-                var options = new CodeGenerationOptions(reuseSyntax: true);
-                await TestGenerateFromSourceSymbolAsync(sourceGenerated, input, expected, onlyGenerateMembers: true, codeGenerationOptions: options);
+                var context = new CodeGenerationContext(reuseSyntax: true);
+                await TestGenerateFromSourceSymbolAsync(sourceGenerated, input, expected, onlyGenerateMembers: true, context: context);
             }
 
             [Fact, Trait(Traits.Feature, Traits.Features.CodeGeneration)]
@@ -425,7 +425,7 @@ await TestAddEventAsync(input, expected,
                         ImmutableArray<AttributeData>.Empty, Accessibility.NotApplicable, ImmutableArray<SyntaxNode>.Empty),
                         getExplicitInterfaceImplementations: GetExplicitInterfaceEvent,
                         type: typeof(System.ComponentModel.PropertyChangedEventHandler),
-                        codeGenerationOptions: new CodeGenerationOptions(addImports: false));
+                        context: new CodeGenerationContext(addImports: false));
             }
 
             [Fact, Trait(Traits.Feature, Traits.Features.CodeGeneration)]
@@ -447,7 +447,7 @@ End Event
 End Class";
                 await TestAddEventAsync(input, expected,
                     addMethod: CodeGenerationSymbolFactory.CreateAccessorSymbol(ImmutableArray<AttributeData>.Empty, Accessibility.NotApplicable, ImmutableArray<SyntaxNode>.Empty),
-                    codeGenerationOptions: new CodeGenerationOptions(addImports: false));
+                    context: new CodeGenerationContext(addImports: false));
             }
 
             [Fact, Trait(Traits.Feature, Traits.Features.CodeGeneration)]
@@ -480,7 +480,7 @@ await TestAddEventAsync(input, expected,
                         ImmutableArray<AttributeData>.Empty, Accessibility.NotApplicable, removeStatements),
                     raiseMethod: CodeGenerationSymbolFactory.CreateAccessorSymbol(
                         ImmutableArray<AttributeData>.Empty, Accessibility.NotApplicable, raiseStatements),
-                    codeGenerationOptions: new CodeGenerationOptions(addImports: false));
+                    context: new CodeGenerationContext(addImports: false));
             }
 
             [Fact, Trait(Traits.Feature, Traits.Features.CodeGeneration)]
@@ -509,8 +509,8 @@ Public Function FInt() As Integer
         Return 0
     End Function
 End Class";
-                var options = new CodeGenerationOptions(reuseSyntax: true);
-                await TestGenerateFromSourceSymbolAsync(sourceGenerated, input, expected, onlyGenerateMembers: true, codeGenerationOptions: options);
+                var context = new CodeGenerationContext(reuseSyntax: true);
+                await TestGenerateFromSourceSymbolAsync(sourceGenerated, input, expected, onlyGenerateMembers: true, context: context);
             }
 
             [Fact, Trait(Traits.Feature, Traits.Features.CodeGeneration)]
@@ -577,7 +577,7 @@ Public Sub M()
 End Class";
                 await TestAddMethodAsync(input, expected,
                     returnType: typeof(void),
-                    codeGenerationOptions: new CodeGenerationOptions(generateMethodBodies: false));
+                    context: new CodeGenerationContext(generateMethodBodies: false));
             }
 
             [Fact, Trait(Traits.Feature, Traits.Features.CodeGeneration)]
@@ -1035,8 +1035,8 @@ Return 0
         End Get
     End Property
 End Class";
-                var options = new CodeGenerationOptions(reuseSyntax: true);
-                await TestGenerateFromSourceSymbolAsync(sourceGenerated, input, expected, onlyGenerateMembers: true, codeGenerationOptions: options);
+                var context = new CodeGenerationContext(reuseSyntax: true);
+                await TestGenerateFromSourceSymbolAsync(sourceGenerated, input, expected, onlyGenerateMembers: true, context: context);
             }
 
             [Fact, Trait(Traits.Feature, Traits.Features.CodeGeneration)]
@@ -1050,7 +1050,7 @@ await TestAddPropertyAsync(input, expected,
                     type: typeof(int),
                     getStatements: "Return 0",
                     setStatements: "Me.P = Value",
-                    codeGenerationOptions: new CodeGenerationOptions(generateMethodBodies: false));
+                    context: new CodeGenerationContext(generateMethodBodies: false));
             }
 
             [Fact, Trait(Traits.Feature, Traits.Features.CodeGeneration)]
@@ -1677,7 +1677,7 @@ End Class
 End Namespace";
                 await TestGenerateFromSourceSymbolAsync(generationSource, initial, expected,
                     forceLanguage: LanguageNames.VisualBasic,
-                    codeGenerationOptions: new CodeGenerationOptions(generateMethodBodies: false));
+                    context: new CodeGenerationContext(generateMethodBodies: false));
             }
 
             [WorkItem(848357, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/848357")]
@@ -1701,7 +1701,7 @@ Public Delegate Sub D(Of T1 As Structure, T2 As Class)(t As T1, u As T2)
     End Class
 End Namespace";
                 await TestGenerateFromSourceSymbolAsync(generationSource, initial, expected,
-                    codeGenerationOptions: new CodeGenerationOptions(generateMethodBodies: false),
+                    context: new CodeGenerationContext(generateMethodBodies: false),
                     onlyGenerateMembers: true);
             }
         }
diff --git a/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.cs b/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.cs
index 4941a5b65e3a3..d5d81a09d7eb8 100644
--- a/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.cs
+++ b/src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.cs
@@ -8,6 +8,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeGeneration;
@@ -15,6 +16,7 @@
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Simplification;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Text;
@@ -35,11 +37,11 @@ internal static async Task TestAddNamespaceAsync(
             string name = "N",
             IList<ISymbol> imports = null,
             IList<INamespaceOrTypeSymbol> members = null,
-            CodeGenerationOptions codeGenerationOptions = null)
+            CodeGenerationContext context = null)
         {
-            using var context = await TestContext.CreateAsync(initial, expected);
+            using var testContext = await TestContext.CreateAsync(initial, expected);
             var @namespace = CodeGenerationSymbolFactory.CreateNamespaceSymbol(name, imports, members);
-            context.Result = await context.Service.AddNamespaceAsync(context.Solution, (INamespaceSymbol)context.GetDestination(), @namespace, codeGenerationOptions);
+            testContext.Result = await testContext.Service.AddNamespaceAsync(testContext.Solution, (INamespaceSymbol)testContext.GetDestination(), @namespace, context ?? CodeGenerationContext.Default, CancellationToken.None);
         }
 
         internal static async Task TestAddFieldAsync(
@@ -49,13 +51,13 @@ internal static async Task TestAddFieldAsync(
             string name = "F",
             Accessibility accessibility = Accessibility.Public,
             Editing.DeclarationModifiers modifiers = default,
-            CodeGenerationOptions codeGenerationOptions = null,
+            CodeGenerationContext context = null,
             bool hasConstantValue = false,
             object constantValue = null,
             bool addToCompilationUnit = false)
         {
-            using var context = await TestContext.CreateAsync(initial, expected);
-            var typeSymbol = type != null ? type(context.SemanticModel) : null;
+            using var testContext = await TestContext.CreateAsync(initial, expected);
+            var typeSymbol = type != null ? type(testContext.SemanticModel) : null;
             var field = CodeGenerationSymbolFactory.CreateFieldSymbol(
                 attributes: default,
                 accessibility,
@@ -64,14 +66,16 @@ internal static async Task TestAddFieldAsync(
                 name,
                 hasConstantValue,
                 constantValue);
+
             if (!addToCompilationUnit)
             {
-                context.Result = await context.Service.AddFieldAsync(context.Solution, (INamedTypeSymbol)context.GetDestination(), field, codeGenerationOptions);
+                testContext.Result = await testContext.Service.AddFieldAsync(testContext.Solution, (INamedTypeSymbol)testContext.GetDestination(), field, context ?? CodeGenerationContext.Default, CancellationToken.None);
             }
             else
             {
-                var newRoot = context.Service.AddField(await context.Document.GetSyntaxRootAsync(), field, codeGenerationOptions);
-                context.Result = context.Document.WithSyntaxRoot(newRoot);
+                var options = await CodeGenerationOptions.FromDocumentAsync(context ?? CodeGenerationContext.Default, testContext.Document, CancellationToken.None);
+                var newRoot = testContext.Service.AddField(await testContext.Document.GetSyntaxRootAsync(), field, options, CancellationToken.None);
+                testContext.Result = testContext.Document.WithSyntaxRoot(newRoot);
             }
         }
 
@@ -85,10 +89,10 @@ internal static async Task TestAddConstructorAsync(
             ImmutableArray<SyntaxNode> statements = default,
             ImmutableArray<SyntaxNode> baseArguments = default,
             ImmutableArray<SyntaxNode> thisArguments = default,
-            CodeGenerationOptions codeGenerationOptions = null)
+            CodeGenerationContext context = null)
         {
-            using var context = await TestContext.CreateAsync(initial, expected);
-            var parameterSymbols = GetParameterSymbols(parameters, context);
+            using var testContext = await TestContext.CreateAsync(initial, expected);
+            var parameterSymbols = GetParameterSymbols(parameters, testContext);
             var ctor = CodeGenerationSymbolFactory.CreateConstructorSymbol(
                 attributes: default,
                 accessibility,
@@ -98,7 +102,8 @@ internal static async Task TestAddConstructorAsync(
                 statements,
                 baseConstructorArguments: baseArguments,
                 thisConstructorArguments: thisArguments);
-            context.Result = await context.Service.AddMethodAsync(context.Solution, (INamedTypeSymbol)context.GetDestination(), ctor, codeGenerationOptions);
+
+            testContext.Result = await testContext.Service.AddMethodAsync(testContext.Solution, (INamedTypeSymbol)testContext.GetDestination(), ctor, context ?? CodeGenerationContext.Default, CancellationToken.None);
         }
 
         internal static async Task TestAddMethodAsync(
@@ -113,22 +118,22 @@ internal static async Task TestAddMethodAsync(
             ImmutableArray<Func<SemanticModel, IParameterSymbol>> parameters = default,
             string statements = null,
             ImmutableArray<SyntaxNode> handlesExpressions = default,
-            CodeGenerationOptions codeGenerationOptions = null)
+            CodeGenerationContext context = null)
         {
             if (statements != null)
             {
                 expected = expected.Replace("$$", statements);
             }
 
-            using var context = await TestContext.CreateAsync(initial, expected);
-            var parameterSymbols = GetParameterSymbols(parameters, context);
-            var parsedStatements = context.ParseStatements(statements);
-            var explicitInterfaceImplementations = GetMethodSymbols(getExplicitInterfaces, context);
+            using var testContext = await TestContext.CreateAsync(initial, expected);
+            var parameterSymbols = GetParameterSymbols(parameters, testContext);
+            var parsedStatements = testContext.ParseStatements(statements);
+            var explicitInterfaceImplementations = GetMethodSymbols(getExplicitInterfaces, testContext);
             var method = CodeGenerationSymbolFactory.CreateMethodSymbol(
                 attributes: default,
                 accessibility,
                 modifiers,
-                GetTypeSymbol(returnType)(context.SemanticModel),
+                GetTypeSymbol(returnType)(testContext.SemanticModel),
                 RefKind.None,
                 explicitInterfaceImplementations,
                 name,
@@ -136,7 +141,8 @@ internal static async Task TestAddMethodAsync(
                 parameterSymbols,
                 parsedStatements,
                 handlesExpressions: handlesExpressions);
-            context.Result = await context.Service.AddMethodAsync(context.Solution, (INamedTypeSymbol)context.GetDestination(), method, codeGenerationOptions);
+
+            testContext.Result = await testContext.Service.AddMethodAsync(testContext.Solution, (INamedTypeSymbol)testContext.GetDestination(), method, context ?? CodeGenerationContext.Default, CancellationToken.None);
         }
 
         internal static async Task TestAddOperatorsAsync(
@@ -148,7 +154,7 @@ internal static async Task TestAddOperatorsAsync(
             Type returnType = null,
             ImmutableArray<Func<SemanticModel, IParameterSymbol>> parameters = default,
             string statements = null,
-            CodeGenerationOptions codeGenerationOptions = null)
+            CodeGenerationContext context = null)
         {
             if (statements != null)
             {
@@ -158,20 +164,20 @@ internal static async Task TestAddOperatorsAsync(
                 }
             }
 
-            using var context = await TestContext.CreateAsync(initial, expected);
-            var parameterSymbols = GetParameterSymbols(parameters, context);
-            var parsedStatements = context.ParseStatements(statements);
+            using var testContext = await TestContext.CreateAsync(initial, expected);
+            var parameterSymbols = GetParameterSymbols(parameters, testContext);
+            var parsedStatements = testContext.ParseStatements(statements);
 
             var methods = operatorKinds.Select(kind => CodeGenerationSymbolFactory.CreateOperatorSymbol(
                 attributes: default,
                 accessibility,
                 modifiers,
-                GetTypeSymbol(returnType)(context.SemanticModel),
+                GetTypeSymbol(returnType)(testContext.SemanticModel),
                 kind,
                 parameterSymbols,
                 parsedStatements));
 
-            context.Result = await context.Service.AddMembersAsync(context.Solution, (INamedTypeSymbol)context.GetDestination(), methods.ToArray(), codeGenerationOptions);
+            testContext.Result = await testContext.Service.AddMembersAsync(testContext.Solution, (INamedTypeSymbol)testContext.GetDestination(), methods.ToArray(), context ?? CodeGenerationContext.Default, CancellationToken.None);
         }
 
         internal static async Task TestAddUnsupportedOperatorAsync(
@@ -182,17 +188,17 @@ internal static async Task TestAddUnsupportedOperatorAsync(
             Type returnType = null,
             ImmutableArray<Func<SemanticModel, IParameterSymbol>> parameters = default,
             string statements = null,
-            CodeGenerationOptions codeGenerationOptions = null)
+            CodeGenerationContext context = null)
         {
-            using var context = await TestContext.CreateAsync(initial, initial, ignoreResult: true);
-            var parameterSymbols = GetParameterSymbols(parameters, context);
-            var parsedStatements = context.ParseStatements(statements);
+            using var testContext = await TestContext.CreateAsync(initial, initial, ignoreResult: true);
+            var parameterSymbols = GetParameterSymbols(parameters, testContext);
+            var parsedStatements = testContext.ParseStatements(statements);
 
             var method = CodeGenerationSymbolFactory.CreateOperatorSymbol(
                 attributes: default,
                 accessibility,
                 modifiers,
-                GetTypeSymbol(returnType)(context.SemanticModel),
+                GetTypeSymbol(returnType)(testContext.SemanticModel),
                 operatorKind,
                 parameterSymbols,
                 parsedStatements);
@@ -200,7 +206,7 @@ internal static async Task TestAddUnsupportedOperatorAsync(
             ArgumentException exception = null;
             try
             {
-                await context.Service.AddMethodAsync(context.Solution, (INamedTypeSymbol)context.GetDestination(), method, codeGenerationOptions);
+                await testContext.Service.AddMethodAsync(testContext.Solution, (INamedTypeSymbol)testContext.GetDestination(), method, context ?? CodeGenerationContext.Default, CancellationToken.None);
             }
             catch (ArgumentException e)
             {
@@ -221,57 +227,60 @@ internal static async Task TestAddConversionAsync(
             Accessibility accessibility = Accessibility.Public,
             Editing.DeclarationModifiers modifiers = default,
             string statements = null,
-            CodeGenerationOptions codeGenerationOptions = null)
+            CodeGenerationContext context = null)
         {
             if (statements != null)
             {
                 expected = expected.Replace("$$", statements);
             }
 
-            using var context = await TestContext.CreateAsync(initial, expected);
-            var parsedStatements = context.ParseStatements(statements);
+            using var testContext = await TestContext.CreateAsync(initial, expected);
+            var parsedStatements = testContext.ParseStatements(statements);
             var method = CodeGenerationSymbolFactory.CreateConversionSymbol(
                 attributes: default,
                 accessibility,
                 modifiers,
-                GetTypeSymbol(toType)(context.SemanticModel),
-                fromType(context.SemanticModel),
+                GetTypeSymbol(toType)(testContext.SemanticModel),
+                fromType(testContext.SemanticModel),
                 containingType: null,
                 isImplicit,
                 parsedStatements);
 
-            context.Result = await context.Service.AddMethodAsync(context.Solution, (INamedTypeSymbol)context.GetDestination(), method, codeGenerationOptions);
+            testContext.Result = await testContext.Service.AddMethodAsync(testContext.Solution, (INamedTypeSymbol)testContext.GetDestination(), method, context ?? CodeGenerationContext.Default, CancellationToken.None);
         }
 
         internal static async Task TestAddStatementsAsync(
             string initial,
             string expected,
             string statements,
-            CodeGenerationOptions codeGenerationOptions = null)
+            CodeGenerationContext context = null)
         {
             if (statements != null)
             {
                 expected = expected.Replace("$$", statements);
             }
 
-            using var context = await TestContext.CreateAsync(initial, expected);
-            var parsedStatements = context.ParseStatements(statements);
-            var oldSyntax = context.GetSelectedSyntax<SyntaxNode>(true);
-            var newSyntax = context.Service.AddStatements(oldSyntax, parsedStatements, codeGenerationOptions);
-            context.Result = context.Document.WithSyntaxRoot((await context.Document.GetSyntaxRootAsync()).ReplaceNode(oldSyntax, newSyntax));
+            using var testContext = await TestContext.CreateAsync(initial, expected);
+            var parsedStatements = testContext.ParseStatements(statements);
+            var oldSyntax = testContext.GetSelectedSyntax<SyntaxNode>(true);
+            var options = await CodeGenerationOptions.FromDocumentAsync(context ?? CodeGenerationContext.Default, testContext.Document, CancellationToken.None);
+            var newSyntax = testContext.Service.AddStatements(oldSyntax, parsedStatements, options, CancellationToken.None);
+            testContext.Result = testContext.Document.WithSyntaxRoot((await testContext.Document.GetSyntaxRootAsync()).ReplaceNode(oldSyntax, newSyntax));
         }
 
         internal static async Task TestAddParametersAsync(
             string initial,
             string expected,
             ImmutableArray<Func<SemanticModel, IParameterSymbol>> parameters,
-            CodeGenerationOptions codeGenerationOptions = null)
+            CodeGenerationContext context = null)
         {
-            using var context = await TestContext.CreateAsync(initial, expected);
-            var parameterSymbols = GetParameterSymbols(parameters, context);
-            var oldMemberSyntax = context.GetSelectedSyntax<SyntaxNode>(true);
-            var newMemberSyntax = context.Service.AddParameters(oldMemberSyntax, parameterSymbols, codeGenerationOptions);
-            context.Result = context.Document.WithSyntaxRoot((await context.Document.GetSyntaxRootAsync()).ReplaceNode(oldMemberSyntax, newMemberSyntax));
+            using var testContext = await TestContext.CreateAsync(initial, expected);
+            var parameterSymbols = GetParameterSymbols(parameters, testContext);
+            var oldMemberSyntax = testContext.GetSelectedSyntax<SyntaxNode>(true);
+            var options = await CodeGenerationOptions.FromDocumentAsync(context ?? CodeGenerationContext.Default, testContext.Document, CancellationToken.None);
+
+            var newMemberSyntax = testContext.Service.AddParameters(oldMemberSyntax, parameterSymbols, options, CancellationToken.None);
+            testContext.Result = testContext.Document.WithSyntaxRoot((await testContext.Document.GetSyntaxRootAsync()).ReplaceNode(oldMemberSyntax, newMemberSyntax));
         }
 
         internal static async Task TestAddDelegateTypeAsync(
@@ -283,20 +292,21 @@ internal static async Task TestAddDelegateTypeAsync(
             Type returnType = null,
             ImmutableArray<ITypeParameterSymbol> typeParameters = default,
             ImmutableArray<Func<SemanticModel, IParameterSymbol>> parameters = default,
-            CodeGenerationOptions codeGenerationOptions = null)
+            CodeGenerationContext context = null)
         {
-            using var context = await TestContext.CreateAsync(initial, expected);
-            var parameterSymbols = GetParameterSymbols(parameters, context);
+            using var testContext = await TestContext.CreateAsync(initial, expected);
+            var parameterSymbols = GetParameterSymbols(parameters, testContext);
             var type = CodeGenerationSymbolFactory.CreateDelegateTypeSymbol(
                 attributes: default,
                 accessibility,
                 modifiers,
-                GetTypeSymbol(returnType)(context.SemanticModel),
+                GetTypeSymbol(returnType)(testContext.SemanticModel),
                 RefKind.None,
                 name,
                 typeParameters,
                 parameterSymbols);
-            context.Result = await context.Service.AddNamedTypeAsync(context.Solution, (INamedTypeSymbol)context.GetDestination(), type, codeGenerationOptions);
+
+            testContext.Result = await testContext.Service.AddNamedTypeAsync(testContext.Solution, (INamedTypeSymbol)testContext.GetDestination(), type, context ?? CodeGenerationContext.Default, CancellationToken.None);
         }
 
         internal static async Task TestAddEventAsync(
@@ -312,24 +322,25 @@ internal static async Task TestAddEventAsync(
             IMethodSymbol addMethod = null,
             IMethodSymbol removeMethod = null,
             IMethodSymbol raiseMethod = null,
-            CodeGenerationOptions codeGenerationOptions = null)
+            CodeGenerationContext context = null)
         {
-            using var context = await TestContext.CreateAsync(initial, expected);
+            using var testContext = await TestContext.CreateAsync(initial, expected);
             type ??= typeof(Action);
 
-            var parameterSymbols = GetParameterSymbols(parameters, context);
-            var typeSymbol = GetTypeSymbol(type)(context.SemanticModel);
+            var parameterSymbols = GetParameterSymbols(parameters, testContext);
+            var typeSymbol = GetTypeSymbol(type)(testContext.SemanticModel);
             var @event = CodeGenerationSymbolFactory.CreateEventSymbol(
                 attributes,
                 accessibility,
                 modifiers,
                 typeSymbol,
-                getExplicitInterfaceImplementations?.Invoke(context.SemanticModel) ?? default,
+                getExplicitInterfaceImplementations?.Invoke(testContext.SemanticModel) ?? default,
                 name,
                 addMethod,
                 removeMethod,
                 raiseMethod);
-            context.Result = await context.Service.AddEventAsync(context.Solution, (INamedTypeSymbol)context.GetDestination(), @event, codeGenerationOptions);
+
+            testContext.Result = await testContext.Service.AddEventAsync(testContext.Solution, (INamedTypeSymbol)testContext.GetDestination(), @event, context ?? CodeGenerationContext.Default, CancellationToken.None);
         }
 
         internal static async Task TestAddPropertyAsync(
@@ -345,7 +356,7 @@ internal static async Task TestAddPropertyAsync(
             ImmutableArray<IPropertySymbol> explicitInterfaceImplementations = default,
             ImmutableArray<Func<SemanticModel, IParameterSymbol>> parameters = default,
             bool isIndexer = false,
-            CodeGenerationOptions codeGenerationOptions = null,
+            CodeGenerationContext context = null,
             IDictionary<OptionKey2, object> options = null)
         {
             // This assumes that tests will not use place holders for get/set statements at the same time
@@ -359,8 +370,8 @@ internal static async Task TestAddPropertyAsync(
                 expected = expected.Replace("$$", setStatements);
             }
 
-            using var context = await TestContext.CreateAsync(initial, expected);
-            var workspace = context.Workspace;
+            using var testContext = await TestContext.CreateAsync(initial, expected);
+            var workspace = testContext.Workspace;
             if (options != null)
             {
                 var optionSet = workspace.Options;
@@ -370,11 +381,11 @@ internal static async Task TestAddPropertyAsync(
                 workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(optionSet));
             }
 
-            var typeSymbol = GetTypeSymbol(type)(context.SemanticModel);
-            var getParameterSymbols = GetParameterSymbols(parameters, context);
+            var typeSymbol = GetTypeSymbol(type)(testContext.SemanticModel);
+            var getParameterSymbols = GetParameterSymbols(parameters, testContext);
             var setParameterSymbols = getParameterSymbols == null
                 ? default
-                : getParameterSymbols.Add(Parameter(type, "value")(context.SemanticModel));
+                : getParameterSymbols.Add(Parameter(type, "value")(testContext.SemanticModel));
             var getAccessor = CodeGenerationSymbolFactory.CreateMethodSymbol(
                 attributes: default,
                 defaultAccessibility,
@@ -385,18 +396,18 @@ internal static async Task TestAddPropertyAsync(
                 "get_" + name,
                 typeParameters: default,
                 getParameterSymbols,
-                statements: context.ParseStatements(getStatements));
+                statements: testContext.ParseStatements(getStatements));
             var setAccessor = CodeGenerationSymbolFactory.CreateMethodSymbol(
                 attributes: default,
                 setterAccessibility,
                 new Editing.DeclarationModifiers(isAbstract: setStatements == null),
-                GetTypeSymbol(typeof(void))(context.SemanticModel),
+                GetTypeSymbol(typeof(void))(testContext.SemanticModel),
                 RefKind.None,
                 explicitInterfaceImplementations: default,
                 "set_" + name,
                 typeParameters: default,
                 setParameterSymbols,
-                statements: context.ParseStatements(setStatements));
+                statements: testContext.ParseStatements(setStatements));
 
             // If get is provided but set isn't, we don't want an accessor for set
             if (getStatements != null && setStatements == null)
@@ -423,9 +434,7 @@ internal static async Task TestAddPropertyAsync(
                 setAccessor,
                 isIndexer);
 
-            codeGenerationOptions ??= new CodeGenerationOptions();
-            codeGenerationOptions = codeGenerationOptions.With(options: codeGenerationOptions.Options ?? workspace.Options);
-            context.Result = await context.Service.AddPropertyAsync(context.Solution, (INamedTypeSymbol)context.GetDestination(), property, codeGenerationOptions);
+            testContext.Result = await testContext.Service.AddPropertyAsync(testContext.Solution, (INamedTypeSymbol)testContext.GetDestination(), property, context ?? CodeGenerationContext.Default, CancellationToken.None);
         }
 
         internal static async Task TestAddNamedTypeAsync(
@@ -440,14 +449,15 @@ internal static async Task TestAddNamedTypeAsync(
             ImmutableArray<INamedTypeSymbol> interfaces = default,
             SpecialType specialType = SpecialType.None,
             ImmutableArray<Func<SemanticModel, ISymbol>> members = default,
-            CodeGenerationOptions codeGenerationOptions = null)
+            CodeGenerationContext context = null)
         {
-            using var context = await TestContext.CreateAsync(initial, expected);
-            var memberSymbols = GetSymbols(members, context);
+            using var testContext = await TestContext.CreateAsync(initial, expected);
+            var memberSymbols = GetSymbols(members, testContext);
             var type = CodeGenerationSymbolFactory.CreateNamedTypeSymbol(
                 attributes: default, accessibility, modifiers, typeKind, name,
                 typeParameters, baseType, interfaces, specialType, memberSymbols);
-            context.Result = await context.Service.AddNamedTypeAsync(context.Solution, (INamespaceSymbol)context.GetDestination(), type, codeGenerationOptions);
+
+            testContext.Result = await testContext.Service.AddNamedTypeAsync(testContext.Solution, (INamespaceSymbol)testContext.GetDestination(), type, context ?? CodeGenerationContext.Default, CancellationToken.None);
         }
 
         internal static async Task TestAddAttributeAsync(
@@ -456,12 +466,14 @@ internal static async Task TestAddAttributeAsync(
             Type attributeClass,
             SyntaxToken? target = null)
         {
-            using var context = await TestContext.CreateAsync(initial, expected);
-            var attr = CodeGenerationSymbolFactory.CreateAttributeData(GetTypeSymbol(attributeClass)(context.SemanticModel));
-            var oldNode = context.GetDestinationNode();
-            var newNode = CodeGenerator.AddAttributes(oldNode, context.Document.Project.Solution.Workspace, new[] { attr }, target)
+            using var testContext = await TestContext.CreateAsync(initial, expected);
+            var attr = CodeGenerationSymbolFactory.CreateAttributeData(GetTypeSymbol(attributeClass)(testContext.SemanticModel));
+            var oldNode = testContext.GetDestinationNode();
+            var codeGenerator = testContext.Document.GetRequiredLanguageService<ICodeGenerationService>();
+            var options = await CodeGenerationOptions.FromDocumentAsync(CodeGenerationContext.Default, testContext.Document, CancellationToken.None);
+            var newNode = codeGenerator.AddAttributes(oldNode, new[] { attr }, target, options, CancellationToken.None)
                                        .WithAdditionalAnnotations(Formatter.Annotation);
-            context.Result = context.Document.WithSyntaxRoot(context.SemanticModel.SyntaxTree.GetRoot().ReplaceNode(oldNode, newNode));
+            testContext.Result = testContext.Document.WithSyntaxRoot(testContext.SemanticModel.SyntaxTree.GetRoot().ReplaceNode(oldNode, newNode));
         }
 
         internal static async Task TestRemoveAttributeAsync<T>(
@@ -469,15 +481,17 @@ internal static async Task TestRemoveAttributeAsync<T>(
             string expected,
             Type attributeClass) where T : SyntaxNode
         {
-            using var context = await TestContext.CreateAsync(initial, expected);
-            var attributeType = GetTypeSymbol(attributeClass)(context.SemanticModel);
-            var taggedNode = context.GetDestinationNode();
-            var attributeTarget = context.SemanticModel.GetDeclaredSymbol(taggedNode);
+            using var testContext = await TestContext.CreateAsync(initial, expected);
+            var attributeType = GetTypeSymbol(attributeClass)(testContext.SemanticModel);
+            var taggedNode = testContext.GetDestinationNode();
+            var attributeTarget = testContext.SemanticModel.GetDeclaredSymbol(taggedNode);
             var attribute = attributeTarget.GetAttributes().Single(attr => Equals(attr.AttributeClass, attributeType));
             var declarationNode = taggedNode.FirstAncestorOrSelf<T>();
-            var newNode = CodeGenerator.RemoveAttribute(declarationNode, context.Document.Project.Solution.Workspace, attribute)
+            var codeGenerator = testContext.Document.GetRequiredLanguageService<ICodeGenerationService>();
+            var options = await CodeGenerationOptions.FromDocumentAsync(CodeGenerationContext.Default, testContext.Document, CancellationToken.None);
+            var newNode = codeGenerator.RemoveAttribute(declarationNode, attribute, options, CancellationToken.None)
                                        .WithAdditionalAnnotations(Formatter.Annotation);
-            context.Result = context.Document.WithSyntaxRoot(context.SemanticModel.SyntaxTree.GetRoot().ReplaceNode(declarationNode, newNode));
+            testContext.Result = testContext.Document.WithSyntaxRoot(testContext.SemanticModel.SyntaxTree.GetRoot().ReplaceNode(declarationNode, newNode));
         }
 
         internal static async Task TestUpdateDeclarationAsync<T>(
@@ -490,27 +504,28 @@ internal static async Task TestUpdateDeclarationAsync<T>(
             bool? declareNewMembersAtTop = null,
             string retainedMembersKey = "RetainedMember") where T : SyntaxNode
         {
-            using var context = await TestContext.CreateAsync(initial, expected);
-            var declarationNode = context.GetDestinationNode().FirstAncestorOrSelf<T>();
+            using var testContext = await TestContext.CreateAsync(initial, expected);
+            var declarationNode = testContext.GetDestinationNode().FirstAncestorOrSelf<T>();
             var updatedDeclarationNode = declarationNode;
-            var workspace = context.Document.Project.Solution.Workspace;
 
+            var codeGenerator = testContext.Document.GetRequiredLanguageService<ICodeGenerationService>();
+            var options = await CodeGenerationOptions.FromDocumentAsync(new CodeGenerationContext(reuseSyntax: true), testContext.Document, CancellationToken.None);
             if (accessibility.HasValue)
             {
-                updatedDeclarationNode = CodeGenerator.UpdateDeclarationAccessibility(declarationNode, workspace, accessibility.Value);
+                updatedDeclarationNode = codeGenerator.UpdateDeclarationAccessibility(declarationNode, accessibility.Value, options, CancellationToken.None);
             }
             else if (modifiers != null)
             {
-                updatedDeclarationNode = CodeGenerator.UpdateDeclarationModifiers(declarationNode, workspace, modifiers);
+                updatedDeclarationNode = codeGenerator.UpdateDeclarationModifiers(declarationNode, modifiers, options, CancellationToken.None);
             }
             else if (getType != null)
             {
-                updatedDeclarationNode = CodeGenerator.UpdateDeclarationType(declarationNode, workspace, getType(context.SemanticModel));
+                updatedDeclarationNode = codeGenerator.UpdateDeclarationType(declarationNode, getType(testContext.SemanticModel), options, CancellationToken.None);
             }
             else if (getNewMembers != null)
             {
-                var retainedMembers = context.GetAnnotatedDeclaredSymbols(retainedMembersKey, context.SemanticModel);
-                var newMembersToAdd = GetSymbols(getNewMembers, context);
+                var retainedMembers = testContext.GetAnnotatedDeclaredSymbols(retainedMembersKey, testContext.SemanticModel);
+                var newMembersToAdd = GetSymbols(getNewMembers, testContext);
                 var allMembers = new List<ISymbol>();
                 if (declareNewMembersAtTop.HasValue && declareNewMembersAtTop.Value)
                 {
@@ -523,11 +538,11 @@ internal static async Task TestUpdateDeclarationAsync<T>(
                     allMembers.AddRange(newMembersToAdd);
                 }
 
-                updatedDeclarationNode = CodeGenerator.UpdateDeclarationMembers(declarationNode, workspace, allMembers);
+                updatedDeclarationNode = codeGenerator.UpdateDeclarationMembers(declarationNode, allMembers, options, CancellationToken.None);
             }
 
             updatedDeclarationNode = updatedDeclarationNode.WithAdditionalAnnotations(Formatter.Annotation);
-            context.Result = context.Document.WithSyntaxRoot(context.SemanticModel.SyntaxTree.GetRoot().ReplaceNode(declarationNode, updatedDeclarationNode));
+            testContext.Result = testContext.Document.WithSyntaxRoot(testContext.SemanticModel.SyntaxTree.GetRoot().ReplaceNode(declarationNode, updatedDeclarationNode));
         }
 
         internal static async Task TestGenerateFromSourceSymbolAsync(
@@ -535,36 +550,34 @@ internal static async Task TestGenerateFromSourceSymbolAsync(
             string initial,
             string expected,
             bool onlyGenerateMembers = false,
-            CodeGenerationOptions codeGenerationOptions = null,
+            CodeGenerationContext context = null,
             string forceLanguage = null)
         {
-            using var context = await TestContext.CreateAsync(initial, expected, forceLanguage);
+            using var testContext = await TestContext.CreateAsync(initial, expected, forceLanguage);
             var destSpan = new TextSpan();
             MarkupTestFile.GetSpan(symbolSource.NormalizeLineEndings(), out symbolSource, out destSpan);
 
             var projectId = ProjectId.CreateNewId();
             var documentId = DocumentId.CreateNewId(projectId);
 
-            var semanticModel = await context.Solution
+            var semanticModel = await testContext.Solution
                 .AddProject(projectId, "GenerationSource", "GenerationSource", TestContext.GetLanguage(symbolSource))
                 .AddDocument(documentId, "Source.cs", symbolSource)
                 .GetDocument(documentId)
                 .GetSemanticModelAsync();
 
-            var docOptions = await context.Document.GetOptionsAsync();
-            codeGenerationOptions ??= new CodeGenerationOptions();
-            codeGenerationOptions = codeGenerationOptions.With(options: codeGenerationOptions.Options ?? docOptions);
+            context ??= CodeGenerationContext.Default;
 
             var symbol = TestContext.GetSelectedSymbol<INamespaceOrTypeSymbol>(destSpan, semanticModel);
-            var destination = context.GetDestination();
+            var destination = testContext.GetDestination();
             if (destination.IsType)
             {
                 var members = onlyGenerateMembers ? symbol.GetMembers().ToArray() : new[] { symbol };
-                context.Result = await context.Service.AddMembersAsync(context.Solution, (INamedTypeSymbol)destination, members, codeGenerationOptions);
+                testContext.Result = await testContext.Service.AddMembersAsync(testContext.Solution, (INamedTypeSymbol)destination, members, context, CancellationToken.None);
             }
             else
             {
-                context.Result = await context.Service.AddNamespaceOrTypeAsync(context.Solution, (INamespaceSymbol)destination, symbol, codeGenerationOptions);
+                testContext.Result = await testContext.Service.AddNamespaceOrTypeAsync(testContext.Solution, (INamespaceSymbol)destination, symbol, context, CancellationToken.None);
             }
         }
 
diff --git a/src/EditorFeatures/VisualBasic/NavigationBar/VisualBasicEditorNavigationBarItemService_CodeGeneration.vb b/src/EditorFeatures/VisualBasic/NavigationBar/VisualBasicEditorNavigationBarItemService_CodeGeneration.vb
index 8b1ddd6f02b20..0599324081b8b 100644
--- a/src/EditorFeatures/VisualBasic/NavigationBar/VisualBasicEditorNavigationBarItemService_CodeGeneration.vb
+++ b/src/EditorFeatures/VisualBasic/NavigationBar/VisualBasicEditorNavigationBarItemService_CodeGeneration.vb
@@ -50,9 +50,10 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.NavigationBar
         Public Shared Async Function GetGeneratedDocumentAsync(document As Document, generateCodeItem As RoslynNavigationBarItem, cancellationToken As CancellationToken) As Task(Of Document)
             Dim syntaxTree = Await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(False)
             Dim contextLocation = syntaxTree.GetLocation(New TextSpan(0, 0))
-            Dim codeGenerationOptions As New CodeGenerationOptions(contextLocation, generateMethodBodies:=True)
 
-            Dim newDocument = Await GetGeneratedDocumentCoreAsync(document, generateCodeItem, codeGenerationOptions, cancellationToken).ConfigureAwait(False)
+            Dim codeGenerationContext = New CodeGenerationContext(contextLocation, generateMethodBodies:=True)
+
+            Dim newDocument = Await GetGeneratedDocumentCoreAsync(document, generateCodeItem, codeGenerationContext, cancellationToken).ConfigureAwait(False)
             If newDocument Is Nothing Then
                 Return document
             End If
@@ -64,7 +65,8 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.NavigationBar
                 formatterRules = LineAdjustmentFormattingRule.Instance.Concat(formatterRules)
             End If
 
-            Dim documentOptions = Await newDocument.GetOptionsAsync(cancellationToken).ConfigureAwait(False)
+            Dim documentOptions = Await document.GetOptionsAsync(cancellationToken).ConfigureAwait(False)
+
             Return Await Formatter.FormatAsync(
                 newDocument,
                 Formatter.Annotation,
@@ -77,26 +79,26 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.NavigationBar
             Return generateCodeItem.Kind <> RoslynNavigationBarItemKind.GenerateFinalizer
         End Function
 
-        Private Shared Function GetGeneratedDocumentCoreAsync(document As Document, generateCodeItem As RoslynNavigationBarItem, codeGenerationOptions As CodeGenerationOptions, cancellationToken As CancellationToken) As Task(Of Document)
+        Private Shared Function GetGeneratedDocumentCoreAsync(document As Document, generateCodeItem As RoslynNavigationBarItem, codeGenerationContext As CodeGenerationContext, cancellationToken As CancellationToken) As Task(Of Document)
             Select Case generateCodeItem.Kind
                 Case RoslynNavigationBarItemKind.GenerateDefaultConstructor
-                    Return GenerateDefaultConstructorAsync(document, DirectCast(generateCodeItem, GenerateDefaultConstructor), codeGenerationOptions, cancellationToken)
+                    Return GenerateDefaultConstructorAsync(document, DirectCast(generateCodeItem, GenerateDefaultConstructor), codeGenerationContext, cancellationToken)
 
                 Case RoslynNavigationBarItemKind.GenerateEventHandler
-                    Return GenerateEventHandlerAsync(document, DirectCast(generateCodeItem, GenerateEventHandler), codeGenerationOptions, cancellationToken)
+                    Return GenerateEventHandlerAsync(document, DirectCast(generateCodeItem, GenerateEventHandler), codeGenerationContext, cancellationToken)
 
                 Case RoslynNavigationBarItemKind.GenerateFinalizer
-                    Return GenerateFinalizerAsync(document, DirectCast(generateCodeItem, GenerateFinalizer), codeGenerationOptions, cancellationToken)
+                    Return GenerateFinalizerAsync(document, DirectCast(generateCodeItem, GenerateFinalizer), codeGenerationContext, cancellationToken)
 
                 Case RoslynNavigationBarItemKind.GenerateMethod
-                    Return GenerateMethodAsync(document, DirectCast(generateCodeItem, GenerateMethod), codeGenerationOptions, cancellationToken)
+                    Return GenerateMethodAsync(document, DirectCast(generateCodeItem, GenerateMethod), codeGenerationContext, cancellationToken)
 
                 Case Else
                     Throw ExceptionUtilities.UnexpectedValue(generateCodeItem.Kind)
             End Select
         End Function
 
-        Private Shared Async Function GenerateDefaultConstructorAsync(document As Document, generateCodeItem As GenerateDefaultConstructor, codeGenerationOptions As CodeGenerationOptions, cancellationToken As CancellationToken) As Task(Of Document)
+        Private Shared Async Function GenerateDefaultConstructorAsync(document As Document, generateCodeItem As GenerateDefaultConstructor, codeGenerationContext As CodeGenerationContext, cancellationToken As CancellationToken) As Task(Of Document)
             Dim compilation = Await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(False)
             Dim destinationType = TryCast(generateCodeItem.DestinationTypeSymbolKey.Resolve(compilation, cancellationToken:=cancellationToken).Symbol, INamedTypeSymbol)
 
@@ -129,11 +131,11 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.NavigationBar
             Return Await CodeGenerator.AddMethodDeclarationAsync(document.Project.Solution,
                                                                  destinationType,
                                                                  methodSymbol,
-                                                                 codeGenerationOptions,
+                                                                 codeGenerationContext,
                                                                  cancellationToken).ConfigureAwait(False)
         End Function
 
-        Private Shared Async Function GenerateEventHandlerAsync(document As Document, generateCodeItem As GenerateEventHandler, codeGenerationOptions As CodeGenerationOptions, cancellationToken As CancellationToken) As Task(Of Document)
+        Private Shared Async Function GenerateEventHandlerAsync(document As Document, generateCodeItem As GenerateEventHandler, codeGenerationContext As CodeGenerationContext, cancellationToken As CancellationToken) As Task(Of Document)
             Dim compilation = Await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(False)
             Dim eventSymbol = TryCast(generateCodeItem.EventSymbolKey.Resolve(compilation, cancellationToken:=cancellationToken).GetAnySymbol(), IEventSymbol)
             Dim destinationType = TryCast(generateCodeItem.DestinationTypeSymbolKey.Resolve(compilation, cancellationToken:=cancellationToken).GetAnySymbol(), INamedTypeSymbol)
@@ -177,11 +179,11 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.NavigationBar
             Return Await CodeGenerator.AddMethodDeclarationAsync(document.Project.Solution,
                                                                  destinationType,
                                                                  methodSymbol,
-                                                                 codeGenerationOptions,
+                                                                 codeGenerationContext,
                                                                  cancellationToken).ConfigureAwait(False)
         End Function
 
-        Private Shared Async Function GenerateFinalizerAsync(document As Document, generateCodeItem As GenerateFinalizer, codeGenerationOptions As CodeGenerationOptions, cancellationToken As CancellationToken) As Task(Of Document)
+        Private Shared Async Function GenerateFinalizerAsync(document As Document, generateCodeItem As GenerateFinalizer, codeGenerationContext As CodeGenerationContext, cancellationToken As CancellationToken) As Task(Of Document)
             Dim compilation = Await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(False)
             Dim destinationType = TryCast(generateCodeItem.DestinationTypeSymbolKey.Resolve(compilation, cancellationToken:=cancellationToken).Symbol, INamedTypeSymbol)
 
@@ -214,11 +216,11 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.NavigationBar
             Return Await CodeGenerator.AddMethodDeclarationAsync(document.Project.Solution,
                                                                  destinationType,
                                                                  finalizerMethodSymbol,
-                                                                 codeGenerationOptions,
+                                                                 codeGenerationContext,
                                                                  cancellationToken).ConfigureAwait(False)
         End Function
 
-        Private Shared Async Function GenerateMethodAsync(document As Document, generateCodeItem As GenerateMethod, codeGenerationOptions As CodeGenerationOptions, cancellationToken As CancellationToken) As Task(Of Document)
+        Private Shared Async Function GenerateMethodAsync(document As Document, generateCodeItem As GenerateMethod, codeGenerationContext As CodeGenerationContext, cancellationToken As CancellationToken) As Task(Of Document)
             Dim compilation = Await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(False)
             Dim destinationType = TryCast(generateCodeItem.DestinationTypeSymbolKey.Resolve(compilation, cancellationToken:=cancellationToken).Symbol, INamedTypeSymbol)
             Dim methodToReplicate = TryCast(generateCodeItem.MethodToReplicateSymbolKey.Resolve(compilation, cancellationToken:=cancellationToken).Symbol, IMethodSymbol)
@@ -234,7 +236,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.NavigationBar
             Return Await CodeGenerator.AddMethodDeclarationAsync(document.Project.Solution,
                                                                  destinationType,
                                                                  codeGenerationSymbol,
-                                                                 codeGenerationOptions,
+                                                                 codeGenerationContext,
                                                                  cancellationToken).ConfigureAwait(False)
         End Function
     End Class
diff --git a/src/Features/CSharp/Portable/AddImport/CSharpAddImportFeatureService.cs b/src/Features/CSharp/Portable/AddImport/CSharpAddImportFeatureService.cs
index 4809db6993b38..38968bc5ea9e8 100644
--- a/src/Features/CSharp/Portable/AddImport/CSharpAddImportFeatureService.cs
+++ b/src/Features/CSharp/Portable/AddImport/CSharpAddImportFeatureService.cs
@@ -14,6 +14,8 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.AddImport;
 using Microsoft.CodeAnalysis.AddImports;
+using Microsoft.CodeAnalysis.CodeGeneration;
+using Microsoft.CodeAnalysis.CSharp.CodeGeneration;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
@@ -288,7 +290,7 @@ protected override string GetDescription(IReadOnlyList<string> nameParts)
 
         protected override (string description, bool hasExistingImport) GetDescription(
             Document document,
-            OptionSet options,
+            CodeGenerationPreferences preferences,
             INamespaceOrTypeSymbol namespaceOrTypeSymbol,
             SemanticModel semanticModel,
             SyntaxNode contextNode,
@@ -303,7 +305,7 @@ protected override (string description, bool hasExistingImport) GetDescription(
                 namespaceOrTypeSymbol, semanticModel, contextNode);
 
             var (usingDirective, hasExistingUsing) = GetUsingDirective(
-                document, options, namespaceOrTypeSymbol, semanticModel, root, contextNode);
+                document, (CSharpCodeGenerationPreferences)preferences, namespaceOrTypeSymbol, semanticModel, root, contextNode);
 
             var externAliasString = externAlias != null ? $"extern alias {externAlias.Identifier.ValueText};" : null;
             var usingDirectiveString = usingDirective != null ? GetUsingDirectiveString(namespaceOrTypeSymbol) : null;
@@ -352,14 +354,14 @@ private async Task<CompilationUnitSyntax> AddImportWorkerAsync(
             Document document, CompilationUnitSyntax root, SyntaxNode contextNode, INamespaceOrTypeSymbol namespaceOrTypeSymbol,
             bool allowInHiddenRegions, CancellationToken cancellationToken)
         {
-            var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
+            var preferences = await CSharpCodeGenerationPreferences.FromDocumentAsync(document, cancellationToken).ConfigureAwait(false);
             var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
 
             var (externAliasDirective, hasExistingExtern) = GetExternAliasDirective(
                 namespaceOrTypeSymbol, semanticModel, contextNode);
 
             var (usingDirective, hasExistingUsing) = GetUsingDirective(
-                document, options, namespaceOrTypeSymbol, semanticModel, root, contextNode);
+                document, preferences, namespaceOrTypeSymbol, semanticModel, root, contextNode);
 
             using var _ = ArrayBuilder<SyntaxNode>.GetInstance(out var newImports);
 
@@ -381,7 +383,7 @@ private async Task<CompilationUnitSyntax> AddImportWorkerAsync(
             var addImportService = document.GetLanguageService<IAddImportsService>();
             var generator = SyntaxGenerator.GetGenerator(document);
             var newRoot = addImportService.AddImports(
-                semanticModel.Compilation, root, contextNode, newImports, generator, options, allowInHiddenRegions, cancellationToken);
+                semanticModel.Compilation, root, contextNode, newImports, generator, preferences, allowInHiddenRegions, cancellationToken);
             return (CompilationUnitSyntax)newRoot;
         }
 
@@ -389,8 +391,8 @@ protected override async Task<Document> AddImportAsync(
             SyntaxNode contextNode, IReadOnlyList<string> namespaceParts,
             Document document, bool allowInHiddenRegions, CancellationToken cancellationToken)
         {
-            var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
             var root = GetCompilationUnitSyntaxNode(contextNode, cancellationToken);
+            var preferences = await CSharpCodeGenerationPreferences.FromDocumentAsync(document, cancellationToken).ConfigureAwait(false);
 
             var usingDirective = SyntaxFactory.UsingDirective(
                 CreateNameSyntax(namespaceParts, namespaceParts.Count - 1));
@@ -399,7 +401,7 @@ protected override async Task<Document> AddImportAsync(
             var service = document.GetLanguageService<IAddImportsService>();
             var generator = SyntaxGenerator.GetGenerator(document);
             var newRoot = service.AddImport(
-                compilation, root, contextNode, usingDirective, generator, options, allowInHiddenRegions, cancellationToken);
+                compilation, root, contextNode, usingDirective, generator, preferences, allowInHiddenRegions, cancellationToken);
 
             return document.WithSyntaxRoot(newRoot);
         }
@@ -436,7 +438,7 @@ private static (ExternAliasDirectiveSyntax, bool hasExistingImport) GetExternAli
 
         private (UsingDirectiveSyntax, bool hasExistingImport) GetUsingDirective(
             Document document,
-            OptionSet options,
+            CSharpCodeGenerationPreferences preferences,
             INamespaceOrTypeSymbol namespaceOrTypeSymbol,
             SemanticModel semanticModel,
             CompilationUnitSyntax root,
@@ -455,7 +457,7 @@ private static (ExternAliasDirectiveSyntax, bool hasExistingImport) GetExternAli
             // help create the final using.
             var dummyUsing = SyntaxFactory.UsingDirective(nameSyntax);
 
-            var container = addImportService.GetImportContainer(root, contextNode, dummyUsing, options);
+            var container = addImportService.GetImportContainer(root, contextNode, dummyUsing, preferences);
             var namespaceToAddTo = container as BaseNamespaceDeclarationSyntax;
 
             // Replace the alias that GenerateTypeSyntax added if we want this to be looked
diff --git a/src/Features/CSharp/Portable/CodeRefactorings/ConvertLocalFunctionToMethod/CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/CodeRefactorings/ConvertLocalFunctionToMethod/CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs
index 8b3f95398ff49..1124b7323fc53 100644
--- a/src/Features/CSharp/Portable/CodeRefactorings/ConvertLocalFunctionToMethod/CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs
+++ b/src/Features/CSharp/Portable/CodeRefactorings/ConvertLocalFunctionToMethod/CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs
@@ -125,9 +125,8 @@ private static async Task<Document> UpdateDocumentAsync(
                 typeParameters: typeParameters.ToImmutableArray(),
                 parameters: parameters.AddRange(capturesAsParameters));
 
-            var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
-            var defaultOptions = new CodeGenerationOptions(options: options);
-            var method = MethodGenerator.GenerateMethodDeclaration(methodSymbol, CodeGenerationDestination.Unspecified, defaultOptions, root.SyntaxTree.Options);
+            var defaultOptions = await CSharpCodeGenerationOptions.FromDocumentAsync(CodeGenerationContext.Default, document, cancellationToken).ConfigureAwait(false);
+            var method = MethodGenerator.GenerateMethodDeclaration(methodSymbol, CodeGenerationDestination.Unspecified, defaultOptions, cancellationToken);
 
             var generator = s_generator;
             var editor = new SyntaxEditor(root, generator);
diff --git a/src/Features/CSharp/Portable/CodeRefactorings/UseExplicitOrImplicitType/AbstractUseTypeCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/CodeRefactorings/UseExplicitOrImplicitType/AbstractUseTypeCodeRefactoringProvider.cs
index e8abbbb2b2cf2..24be9b03fd663 100644
--- a/src/Features/CSharp/Portable/CodeRefactorings/UseExplicitOrImplicitType/AbstractUseTypeCodeRefactoringProvider.cs
+++ b/src/Features/CSharp/Portable/CodeRefactorings/UseExplicitOrImplicitType/AbstractUseTypeCodeRefactoringProvider.cs
@@ -121,7 +121,7 @@ private static async Task<SyntaxNode> GetDeclarationAsync(CodeRefactoringContext
         private async Task<Document> UpdateDocumentAsync(Document document, TypeSyntax type, CancellationToken cancellationToken)
         {
             var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-            var editor = new SyntaxEditor(root, document.Project.Solution.Workspace);
+            var editor = new SyntaxEditor(root, document.Project.Solution.Workspace.Services);
 
             await HandleDeclarationAsync(document, editor, type, cancellationToken).ConfigureAwait(false);
 
diff --git a/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs
index c42c8b9fd343f..4390eb9b11771 100644
--- a/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs
+++ b/src/Features/CSharp/Portable/ConvertAutoPropertyToFullProperty/CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs
@@ -12,12 +12,12 @@
 using Microsoft.CodeAnalysis.CodeRefactorings;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.ConvertAutoPropertyToFullProperty;
+using Microsoft.CodeAnalysis.CSharp.CodeGeneration;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Formatting;
-using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Shared.Utilities;
 using static Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles.SymbolSpecification;
@@ -25,7 +25,7 @@
 namespace Microsoft.CodeAnalysis.CSharp.ConvertAutoPropertyToFullProperty
 {
     [ExportCodeRefactoringProvider(LanguageNames.CSharp, Name = PredefinedCodeRefactoringProviderNames.ConvertAutoPropertyToFullProperty), Shared]
-    internal class CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider : AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider<PropertyDeclarationSyntax, TypeDeclarationSyntax>
+    internal class CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider : AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider<PropertyDeclarationSyntax, TypeDeclarationSyntax, CSharpCodeGenerationPreferences>
     {
         [ImportingConstructor]
         [SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")]
@@ -46,7 +46,7 @@ internal override async Task<string> GetFieldNameAsync(Document document, IPrope
         }
 
         internal override (SyntaxNode newGetAccessor, SyntaxNode newSetAccessor) GetNewAccessors(
-            DocumentOptionSet options, SyntaxNode property,
+            CSharpCodeGenerationPreferences preferences, SyntaxNode property,
             string fieldName, SyntaxGenerator generator)
         {
             // C# might have trivia with the accessors that needs to be preserved.  
@@ -55,7 +55,7 @@ internal override (SyntaxNode newGetAccessor, SyntaxNode newSetAccessor) GetNewA
             var (getAccessor, setAccessor) = GetExistingAccessors(accessorListSyntax);
 
             var getAccessorStatement = generator.ReturnStatement(generator.IdentifierName(fieldName));
-            var newGetter = GetUpdatedAccessor(options, getAccessor, getAccessorStatement);
+            var newGetter = GetUpdatedAccessor(preferences, getAccessor, getAccessorStatement);
 
             SyntaxNode newSetter = null;
             if (setAccessor != null)
@@ -63,7 +63,7 @@ internal override (SyntaxNode newGetAccessor, SyntaxNode newSetAccessor) GetNewA
                 var setAccessorStatement = generator.ExpressionStatement(generator.AssignmentStatement(
                     generator.IdentifierName(fieldName),
                     generator.IdentifierName("value")));
-                newSetter = GetUpdatedAccessor(options, setAccessor, setAccessorStatement);
+                newSetter = GetUpdatedAccessor(preferences, setAccessor, setAccessorStatement);
             }
 
             return (newGetAccessor: newGetter, newSetAccessor: newSetter);
@@ -75,20 +75,20 @@ private static (AccessorDeclarationSyntax getAccessor, AccessorDeclarationSyntax
                 accessorListSyntax.Accessors.FirstOrDefault(a => a.IsKind(SyntaxKind.SetAccessorDeclaration) ||
                                                                  a.IsKind(SyntaxKind.InitAccessorDeclaration)));
 
-        private static SyntaxNode GetUpdatedAccessor(DocumentOptionSet options,
+        private static SyntaxNode GetUpdatedAccessor(CSharpCodeGenerationPreferences preferences,
             SyntaxNode accessor, SyntaxNode statement)
         {
             var newAccessor = AddStatement(accessor, statement);
             var accessorDeclarationSyntax = (AccessorDeclarationSyntax)newAccessor;
 
-            var preference = GetAccessorExpressionBodyPreference(options);
+            var preference = GetAccessorExpressionBodyPreference(preferences);
             if (preference == ExpressionBodyPreference.Never)
             {
                 return accessorDeclarationSyntax.WithSemicolonToken(default);
             }
 
             if (!accessorDeclarationSyntax.Body.TryConvertToArrowExpressionBody(
-                    accessorDeclarationSyntax.Kind(), accessor.SyntaxTree.Options, preference,
+                    accessorDeclarationSyntax.Kind(), preferences.LanguageVersion, preference,
                     out var arrowExpression, out _))
             {
                 return accessorDeclarationSyntax.WithSemicolonToken(default);
@@ -113,11 +113,11 @@ internal static SyntaxNode AddStatement(SyntaxNode accessor, SyntaxNode statemen
         }
 
         internal override SyntaxNode ConvertPropertyToExpressionBodyIfDesired(
-            DocumentOptionSet options, SyntaxNode property)
+            CSharpCodeGenerationPreferences preferences, SyntaxNode property)
         {
             var propertyDeclaration = (PropertyDeclarationSyntax)property;
 
-            var preference = GetPropertyExpressionBodyPreference(options);
+            var preference = GetPropertyExpressionBodyPreference(preferences);
             if (preference == ExpressionBodyPreference.Never)
             {
                 return propertyDeclaration.WithSemicolonToken(default);
@@ -139,11 +139,11 @@ internal override SyntaxNode ConvertPropertyToExpressionBodyIfDesired(
             return propertyDeclaration.WithSemicolonToken(default);
         }
 
-        internal static ExpressionBodyPreference GetAccessorExpressionBodyPreference(DocumentOptionSet options)
-            => options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors).Value;
+        internal static ExpressionBodyPreference GetAccessorExpressionBodyPreference(CSharpCodeGenerationPreferences preferences)
+            => preferences.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors).Value;
 
-        internal static ExpressionBodyPreference GetPropertyExpressionBodyPreference(DocumentOptionSet options)
-            => options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties).Value;
+        internal static ExpressionBodyPreference GetPropertyExpressionBodyPreference(CSharpCodeGenerationPreferences preferences)
+            => preferences.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties).Value;
 
         internal override SyntaxNode GetTypeBlock(SyntaxNode syntaxNode)
             => syntaxNode;
diff --git a/src/Features/CSharp/Portable/ConvertForEachToFor/CSharpConvertForEachToForCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ConvertForEachToFor/CSharpConvertForEachToForCodeRefactoringProvider.cs
index 8a0c865552593..51dbc9cdcfa5b 100644
--- a/src/Features/CSharp/Portable/ConvertForEachToFor/CSharpConvertForEachToForCodeRefactoringProvider.cs
+++ b/src/Features/CSharp/Portable/ConvertForEachToFor/CSharpConvertForEachToForCodeRefactoringProvider.cs
@@ -64,9 +64,9 @@ protected override void ConvertToForStatement(
             var collectionVariable = GetCollectionVariableName(
                 model, generator, foreachInfo, foreachCollectionExpression, cancellationToken);
 
-            var typeSymbol = foreachInfo.RequireExplicitCastInterface
-                ? foreachInfo.ExplicitCastInterface
-                : model.GetTypeInfo(foreachCollectionExpression, cancellationToken).Type ?? model.Compilation.GetSpecialType(SpecialType.System_Object);
+            var typeSymbol = foreachInfo.ExplicitCastInterface ??
+                model.GetTypeInfo(foreachCollectionExpression, cancellationToken).Type ??
+                model.Compilation.GetSpecialType(SpecialType.System_Object);
 
             var collectionStatementType = typeSymbol.GenerateTypeSyntax();
 
diff --git a/src/Features/CSharp/Portable/EncapsulateField/CSharpEncapsulateFieldService.cs b/src/Features/CSharp/Portable/EncapsulateField/CSharpEncapsulateFieldService.cs
index 4bef21b437383..5bbec277915c9 100644
--- a/src/Features/CSharp/Portable/EncapsulateField/CSharpEncapsulateFieldService.cs
+++ b/src/Features/CSharp/Portable/EncapsulateField/CSharpEncapsulateFieldService.cs
@@ -106,7 +106,7 @@ protected override async Task<SyntaxNode> RewriteFieldNameAndAccessibilityAsync(
                     field.ConstantValue,
                     declarator.Initializer));
 
-                var withField = await codeGenService.AddFieldAsync(document.Project.Solution, field.ContainingType, fieldToAdd, new CodeGenerationOptions(), cancellationToken).ConfigureAwait(false);
+                var withField = await codeGenService.AddFieldAsync(document.Project.Solution, field.ContainingType, fieldToAdd, CodeGenerationContext.Default, cancellationToken).ConfigureAwait(false);
                 root = await withField.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
                 declarator = root.GetAnnotatedNodes<VariableDeclaratorSyntax>(tempAnnotation).First();
diff --git a/src/Features/CSharp/Portable/Formatting/CSharpAccessibilityModifiersNewDocumentFormattingProvider.cs b/src/Features/CSharp/Portable/Formatting/CSharpAccessibilityModifiersNewDocumentFormattingProvider.cs
index e28e9714f4f1c..c0256ecb8e2c2 100644
--- a/src/Features/CSharp/Portable/Formatting/CSharpAccessibilityModifiersNewDocumentFormattingProvider.cs
+++ b/src/Features/CSharp/Portable/Formatting/CSharpAccessibilityModifiersNewDocumentFormattingProvider.cs
@@ -39,7 +39,7 @@ public async Task<Document> FormatNewDocumentAsync(Document document, Document?
             var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
             var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
             var typeDeclarations = root.DescendantNodes().Where(node => syntaxFacts.IsTypeDeclaration(node));
-            var editor = new SyntaxEditor(root, document.Project.Solution.Workspace);
+            var editor = new SyntaxEditor(root, document.Project.Solution.Workspace.Services);
 
             var service = document.GetRequiredLanguageService<IAddAccessibilityModifiersService>();
 
diff --git a/src/Features/CSharp/Portable/GenerateMember/GenerateVariable/CSharpGenerateVariableService.cs b/src/Features/CSharp/Portable/GenerateMember/GenerateVariable/CSharpGenerateVariableService.cs
index ea562fe7ba1a3..6fdd1ec442403 100644
--- a/src/Features/CSharp/Portable/GenerateMember/GenerateVariable/CSharpGenerateVariableService.cs
+++ b/src/Features/CSharp/Portable/GenerateMember/GenerateVariable/CSharpGenerateVariableService.cs
@@ -174,7 +174,7 @@ private static bool IsLegal(
             return expression.CanReplaceWithLValue(document.SemanticModel, cancellationToken);
         }
 
-        protected override bool TryConvertToLocalDeclaration(ITypeSymbol type, SyntaxToken identifierToken, OptionSet options, SemanticModel semanticModel, CancellationToken cancellationToken, out SyntaxNode newRoot)
+        protected override bool TryConvertToLocalDeclaration(ITypeSymbol type, SyntaxToken identifierToken, SemanticModel semanticModel, CancellationToken cancellationToken, out SyntaxNode newRoot)
         {
             var token = identifierToken;
             var node = identifierToken.Parent as IdentifierNameSyntax;
diff --git a/src/Features/CSharp/Portable/ImplementInterface/CSharpImplementImplicitlyCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ImplementInterface/CSharpImplementImplicitlyCodeRefactoringProvider.cs
index f8e19fee155f0..65d3a05a417bb 100644
--- a/src/Features/CSharp/Portable/ImplementInterface/CSharpImplementImplicitlyCodeRefactoringProvider.cs
+++ b/src/Features/CSharp/Portable/ImplementInterface/CSharpImplementImplicitlyCodeRefactoringProvider.cs
@@ -53,7 +53,7 @@ protected override Task UpdateReferencesAsync(Project project, SolutionEditor so
         protected override SyntaxNode ChangeImplementation(SyntaxGenerator generator, SyntaxNode decl, ISymbol _)
             => generator.WithAccessibility(WithoutExplicitImpl(decl), Accessibility.Public);
 
-        private static SyntaxNode? WithoutExplicitImpl(SyntaxNode decl)
+        private static SyntaxNode WithoutExplicitImpl(SyntaxNode decl)
             => decl switch
             {
                 MethodDeclarationSyntax member => member.WithExplicitInterfaceSpecifier(null),
diff --git a/src/Features/CSharp/Portable/MakeLocalFunctionStatic/MakeLocalFunctionStaticCodeFixHelper.cs b/src/Features/CSharp/Portable/MakeLocalFunctionStatic/MakeLocalFunctionStaticCodeFixHelper.cs
index ab930386c5651..4c637bbff1f57 100644
--- a/src/Features/CSharp/Portable/MakeLocalFunctionStatic/MakeLocalFunctionStaticCodeFixHelper.cs
+++ b/src/Features/CSharp/Portable/MakeLocalFunctionStatic/MakeLocalFunctionStaticCodeFixHelper.cs
@@ -28,7 +28,7 @@ public static async Task<Document> MakeLocalFunctionStaticAsync(
             CancellationToken cancellationToken)
         {
             var root = (await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false))!;
-            var syntaxEditor = new SyntaxEditor(root, document.Project.Solution.Workspace);
+            var syntaxEditor = new SyntaxEditor(root, document.Project.Solution.Workspace.Services);
             await MakeLocalFunctionStaticAsync(document, localFunction, captures, syntaxEditor, cancellationToken).ConfigureAwait(false);
             return document.WithSyntaxRoot(syntaxEditor.GetChangedRoot());
         }
@@ -138,15 +138,19 @@ public static async Task MakeLocalFunctionStaticAsync(
                 }
             }
 
+            var codeGenerator = document.GetRequiredLanguageService<ICodeGenerationService>();
+            var options = await CodeGenerationOptions.FromDocumentAsync(CodeGenerationContext.Default, document, cancellationToken).ConfigureAwait(false);
+
             // Updates the local function declaration with variables passed in as parameters
             syntaxEditor.ReplaceNode(
                 localFunction,
                 (node, generator) =>
                 {
-                    var localFunctionWithNewParameters = CodeGenerator.AddParameterDeclarations(
+                    var localFunctionWithNewParameters = codeGenerator.AddParameters(
                         node,
                         parameterAndCapturedSymbols.SelectAsArray(p => p.symbol),
-                        document.Project.Solution.Workspace);
+                        options,
+                        cancellationToken);
 
                     if (shouldWarn)
                     {
diff --git a/src/Features/CSharp/Portable/ReplaceMethodWithProperty/CSharpReplaceMethodWithPropertyService.cs b/src/Features/CSharp/Portable/ReplaceMethodWithProperty/CSharpReplaceMethodWithPropertyService.cs
index fa4a1ecc15d44..da26f70bf49cf 100644
--- a/src/Features/CSharp/Portable/ReplaceMethodWithProperty/CSharpReplaceMethodWithPropertyService.cs
+++ b/src/Features/CSharp/Portable/ReplaceMethodWithProperty/CSharpReplaceMethodWithPropertyService.cs
@@ -45,8 +45,9 @@ public void ReplaceGetMethodWithProperty(
                 return;
             }
 
+            var languageVersion = ((CSharpParseOptions)parseOptions).LanguageVersion;
             var newProperty = ConvertMethodsToProperty(
-                documentOptions, parseOptions,
+                documentOptions, languageVersion,
                 semanticModel, editor.Generator,
                 getAndSetMethods, propertyName, nameChanged);
 
@@ -54,12 +55,12 @@ public void ReplaceGetMethodWithProperty(
         }
 
         public static SyntaxNode ConvertMethodsToProperty(
-            DocumentOptionSet documentOptions, ParseOptions parseOptions,
+            DocumentOptionSet documentOptions, LanguageVersion languageVersion,
             SemanticModel semanticModel, SyntaxGenerator generator, GetAndSetMethods getAndSetMethods,
             string propertyName, bool nameChanged)
         {
             var propertyDeclaration = ConvertMethodsToPropertyWorker(
-                documentOptions, parseOptions, semanticModel,
+                documentOptions, languageVersion, semanticModel,
                 generator, getAndSetMethods, propertyName, nameChanged);
 
             var expressionBodyPreference = documentOptions.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties).Value;
@@ -77,7 +78,7 @@ public static SyntaxNode ConvertMethodsToProperty(
                     }
                     else if (getAccessor.Body != null &&
                              getAccessor.Body.TryConvertToArrowExpressionBody(
-                                 propertyDeclaration.Kind(), parseOptions, expressionBodyPreference,
+                                 propertyDeclaration.Kind(), languageVersion, expressionBodyPreference,
                                  out var arrowExpression, out var semicolonToken))
                     {
                         return propertyDeclaration.WithExpressionBody(arrowExpression)
@@ -109,14 +110,14 @@ public static SyntaxNode ConvertMethodsToProperty(
         }
 
         public static PropertyDeclarationSyntax ConvertMethodsToPropertyWorker(
-            DocumentOptionSet documentOptions, ParseOptions parseOptions,
+            DocumentOptionSet documentOptions, LanguageVersion languageVersion,
             SemanticModel semanticModel, SyntaxGenerator generator, GetAndSetMethods getAndSetMethods,
             string propertyName, bool nameChanged)
         {
             var getMethodDeclaration = (MethodDeclarationSyntax)getAndSetMethods.GetMethodDeclaration;
             var setMethodDeclaration = getAndSetMethods.SetMethodDeclaration as MethodDeclarationSyntax;
-            var getAccessor = CreateGetAccessor(getAndSetMethods, documentOptions, parseOptions);
-            var setAccessor = CreateSetAccessor(semanticModel, generator, getAndSetMethods, documentOptions, parseOptions);
+            var getAccessor = CreateGetAccessor(getAndSetMethods, documentOptions, languageVersion);
+            var setAccessor = CreateSetAccessor(semanticModel, generator, getAndSetMethods, documentOptions, languageVersion);
 
             var nameToken = GetPropertyName(getMethodDeclaration.Identifier, propertyName, nameChanged);
             var warning = GetWarning(getAndSetMethods);
@@ -159,23 +160,23 @@ private static SyntaxToken GetPropertyName(SyntaxToken identifier, string proper
         }
 
         private static AccessorDeclarationSyntax CreateGetAccessor(
-            GetAndSetMethods getAndSetMethods, DocumentOptionSet documentOptions, ParseOptions parseOptions)
+            GetAndSetMethods getAndSetMethods, DocumentOptionSet documentOptions, LanguageVersion languageVersion)
         {
             var accessorDeclaration = CreateGetAccessorWorker(getAndSetMethods);
 
             return UseExpressionOrBlockBodyIfDesired(
-                documentOptions, parseOptions, accessorDeclaration);
+                documentOptions, languageVersion, accessorDeclaration);
         }
 
         private static AccessorDeclarationSyntax UseExpressionOrBlockBodyIfDesired(
-            DocumentOptionSet documentOptions, ParseOptions parseOptions,
+            DocumentOptionSet documentOptions, LanguageVersion languageVersion,
             AccessorDeclarationSyntax accessorDeclaration)
         {
             var expressionBodyPreference = documentOptions.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors).Value;
             if (accessorDeclaration?.Body != null && expressionBodyPreference != ExpressionBodyPreference.Never)
             {
                 if (accessorDeclaration.Body.TryConvertToArrowExpressionBody(
-                        accessorDeclaration.Kind(), parseOptions, expressionBodyPreference,
+                        accessorDeclaration.Kind(), languageVersion, expressionBodyPreference,
                         out var arrowExpression, out var semicolonToken))
                 {
                     return accessorDeclaration.WithBody(null)
@@ -228,10 +229,10 @@ private static AccessorDeclarationSyntax CreateGetAccessorWorker(GetAndSetMethod
 
         private static AccessorDeclarationSyntax CreateSetAccessor(
             SemanticModel semanticModel, SyntaxGenerator generator, GetAndSetMethods getAndSetMethods,
-            DocumentOptionSet documentOptions, ParseOptions parseOptions)
+            DocumentOptionSet documentOptions, LanguageVersion languageVersion)
         {
             var accessorDeclaration = CreateSetAccessorWorker(semanticModel, generator, getAndSetMethods);
-            return UseExpressionOrBlockBodyIfDesired(documentOptions, parseOptions, accessorDeclaration);
+            return UseExpressionOrBlockBodyIfDesired(documentOptions, languageVersion, accessorDeclaration);
         }
 
         private static AccessorDeclarationSyntax CreateSetAccessorWorker(
diff --git a/src/Features/CSharp/Portable/ReplacePropertyWithMethods/CSharpReplacePropertyWithMethodsService.cs b/src/Features/CSharp/Portable/ReplacePropertyWithMethods/CSharpReplacePropertyWithMethodsService.cs
index 2eeda8968d211..c28050f74a896 100644
--- a/src/Features/CSharp/Portable/ReplacePropertyWithMethods/CSharpReplacePropertyWithMethodsService.cs
+++ b/src/Features/CSharp/Portable/ReplacePropertyWithMethods/CSharpReplacePropertyWithMethodsService.cs
@@ -47,10 +47,10 @@ public override async Task<ImmutableArray<SyntaxNode>> GetReplacementMembersAsyn
 
             var documentOptions = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
             var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
-            var parseOptions = syntaxTree.Options;
+            var languageVersion = ((CSharpParseOptions)syntaxTree.Options).LanguageVersion;
 
             return ConvertPropertyToMembers(
-                documentOptions, parseOptions,
+                documentOptions, languageVersion,
                 SyntaxGenerator.GetGenerator(document), property,
                 propertyDeclaration, propertyBackingField,
                 desiredGetMethodName, desiredSetMethodName,
@@ -59,7 +59,7 @@ public override async Task<ImmutableArray<SyntaxNode>> GetReplacementMembersAsyn
 
         private static ImmutableArray<SyntaxNode> ConvertPropertyToMembers(
             DocumentOptionSet documentOptions,
-            ParseOptions parseOptions,
+            LanguageVersion languageVersion,
             SyntaxGenerator generator,
             IPropertySymbol property,
             PropertyDeclarationSyntax propertyDeclaration,
@@ -80,7 +80,7 @@ private static ImmutableArray<SyntaxNode> ConvertPropertyToMembers(
             if (getMethod != null)
             {
                 result.Add(GetGetMethod(
-                    documentOptions, parseOptions,
+                    documentOptions, languageVersion,
                     generator, propertyDeclaration, propertyBackingField,
                     getMethod, desiredGetMethodName,
                     cancellationToken: cancellationToken));
@@ -90,7 +90,7 @@ private static ImmutableArray<SyntaxNode> ConvertPropertyToMembers(
             if (setMethod != null)
             {
                 result.Add(GetSetMethod(
-                    documentOptions, parseOptions,
+                    documentOptions, languageVersion,
                     generator, propertyDeclaration, propertyBackingField,
                     setMethod, desiredSetMethodName,
                     cancellationToken: cancellationToken));
@@ -101,7 +101,7 @@ private static ImmutableArray<SyntaxNode> ConvertPropertyToMembers(
 
         private static SyntaxNode GetSetMethod(
             DocumentOptionSet documentOptions,
-            ParseOptions parseOptions,
+            LanguageVersion languageVersion,
             SyntaxGenerator generator,
             PropertyDeclarationSyntax propertyDeclaration,
             IFieldSymbol? propertyBackingField,
@@ -118,7 +118,7 @@ private static SyntaxNode GetSetMethod(
             methodDeclaration = CopyLeadingTrivia(propertyDeclaration, methodDeclaration, ConvertValueToParamRewriter.Instance);
 
             return UseExpressionOrBlockBodyIfDesired(
-                documentOptions, parseOptions, methodDeclaration,
+                documentOptions, languageVersion, methodDeclaration,
                 createReturnStatementForExpression: false);
         }
 
@@ -165,7 +165,7 @@ private static MethodDeclarationSyntax GetSetMethodWorker(
 
         private static SyntaxNode GetGetMethod(
             DocumentOptionSet documentOptions,
-            ParseOptions parseOptions,
+            LanguageVersion languageVersion,
             SyntaxGenerator generator,
             PropertyDeclarationSyntax propertyDeclaration,
             IFieldSymbol? propertyBackingField,
@@ -180,7 +180,7 @@ private static SyntaxNode GetGetMethod(
             methodDeclaration = CopyLeadingTrivia(propertyDeclaration, methodDeclaration, ConvertValueToReturnsRewriter.Instance);
 
             return UseExpressionOrBlockBodyIfDesired(
-                documentOptions, parseOptions, methodDeclaration,
+                documentOptions, languageVersion, methodDeclaration,
                 createReturnStatementForExpression: true);
         }
 
@@ -213,14 +213,14 @@ private static SyntaxTrivia ConvertDocumentationComment(SyntaxTrivia trivia, CSh
         }
 
         private static SyntaxNode UseExpressionOrBlockBodyIfDesired(
-            DocumentOptionSet documentOptions, ParseOptions parseOptions,
+            DocumentOptionSet documentOptions, LanguageVersion languageVersion,
             MethodDeclarationSyntax methodDeclaration, bool createReturnStatementForExpression)
         {
             var expressionBodyPreference = documentOptions.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedMethods).Value;
             if (methodDeclaration.Body != null && expressionBodyPreference != ExpressionBodyPreference.Never)
             {
                 if (methodDeclaration.Body.TryConvertToArrowExpressionBody(
-                        methodDeclaration.Kind(), parseOptions, expressionBodyPreference,
+                        methodDeclaration.Kind(), languageVersion, expressionBodyPreference,
                         out var arrowExpression, out var semicolonToken))
                 {
                     return methodDeclaration.WithBody(null)
diff --git a/src/Features/CSharp/Portable/ReverseForStatement/CSharpReverseForStatementCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ReverseForStatement/CSharpReverseForStatementCodeRefactoringProvider.cs
index 1e487cd90b844..9a8c32a78477c 100644
--- a/src/Features/CSharp/Portable/ReverseForStatement/CSharpReverseForStatementCodeRefactoringProvider.cs
+++ b/src/Features/CSharp/Portable/ReverseForStatement/CSharpReverseForStatementCodeRefactoringProvider.cs
@@ -264,7 +264,7 @@ private async Task<Document> ReverseForStatementAsync(
 
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
-            var editor = new SyntaxEditor(root, document.Project.Solution.Workspace);
+            var editor = new SyntaxEditor(root, document.Project.Solution.Workspace.Services);
             var generator = editor.Generator;
             if (MatchesIncrementPattern(
                     variable, condition, after,
diff --git a/src/Features/CSharp/Portable/UseExpressionBody/UseExpressionBodyCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/UseExpressionBody/UseExpressionBodyCodeRefactoringProvider.cs
index ddd030b16e87f..7c18d147aada6 100644
--- a/src/Features/CSharp/Portable/UseExpressionBody/UseExpressionBodyCodeRefactoringProvider.cs
+++ b/src/Features/CSharp/Portable/UseExpressionBody/UseExpressionBodyCodeRefactoringProvider.cs
@@ -106,8 +106,7 @@ private static bool TryComputeRefactoring(
                 succeeded = true;
             }
 
-            var (canOffer, _) = helper.CanOfferUseBlockBody(optionSet, declaration, forAnalyzer: false);
-            if (canOffer)
+            if (helper.CanOfferUseBlockBody(optionSet, declaration, forAnalyzer: false, out _, out _))
             {
                 context.RegisterRefactoring(
                     new MyCodeAction(
@@ -138,7 +137,7 @@ private static async Task<Document> UpdateDocumentAsync(
             UseExpressionBodyHelper helper, bool useExpressionBody,
             CancellationToken cancellationToken)
         {
-            var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
             var updatedDeclaration = helper.Update(semanticModel, declaration, useExpressionBody);
 
             var parent = declaration is AccessorDeclarationSyntax
diff --git a/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider.cs b/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider.cs
index a592fb6d5ce95..7fab4e7d0636c 100644
--- a/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider.cs
+++ b/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider.cs
@@ -46,7 +46,7 @@ private static ExpressionSyntax GetBodyAsExpression(LambdaExpressionSyntax decla
             => declaration.Body as ExpressionSyntax;
 
         private static bool CanOfferUseExpressionBody(
-            ExpressionBodyPreference preference, LambdaExpressionSyntax declaration)
+            ExpressionBodyPreference preference, LambdaExpressionSyntax declaration, LanguageVersion languageVersion)
         {
             var userPrefersExpressionBodies = preference != ExpressionBodyPreference.Never;
             if (!userPrefersExpressionBodies)
@@ -64,20 +64,19 @@ private static bool CanOfferUseExpressionBody(
 
             // They don't have an expression body.  See if we could convert the block they 
             // have into one.
-            var options = declaration.SyntaxTree.Options;
-            return TryConvertToExpressionBody(declaration, options, preference, out _, out _);
+            return TryConvertToExpressionBody(declaration, languageVersion, preference, out _, out _);
         }
 
         private static bool TryConvertToExpressionBody(
             LambdaExpressionSyntax declaration,
-            ParseOptions options, ExpressionBodyPreference conversionPreference,
-            out ExpressionSyntax expression, out SyntaxToken semicolon)
+            LanguageVersion languageVersion,
+            ExpressionBodyPreference conversionPreference,
+            out ExpressionSyntax expression,
+            out SyntaxToken semicolon)
         {
             var body = declaration.Body as BlockSyntax;
 
-            return body.TryConvertToExpressionBody(
-                options, conversionPreference,
-                out expression, out semicolon);
+            return body.TryConvertToExpressionBody(languageVersion, conversionPreference, out expression, out semicolon);
         }
 
         private static bool CanOfferUseBlockBody(
@@ -134,15 +133,13 @@ private static LambdaExpressionSyntax UpdateWorker(
         {
             var expressionBody = GetBodyAsExpression(currentDeclaration);
             return expressionBody == null
-                ? WithExpressionBody(currentDeclaration)
+                ? WithExpressionBody(currentDeclaration, originalDeclaration.GetLanguageVersion())
                 : WithBlockBody(semanticModel, originalDeclaration, currentDeclaration);
         }
 
-        private static LambdaExpressionSyntax WithExpressionBody(LambdaExpressionSyntax declaration)
+        private static LambdaExpressionSyntax WithExpressionBody(LambdaExpressionSyntax declaration, LanguageVersion languageVersion)
         {
-            if (!TryConvertToExpressionBody(
-                    declaration, declaration.SyntaxTree.Options, ExpressionBodyPreference.WhenPossible,
-                    out var expressionBody, out _))
+            if (!TryConvertToExpressionBody(declaration, languageVersion, ExpressionBodyPreference.WhenPossible, out var expressionBody, out _))
             {
                 return declaration;
             }
diff --git a/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider_Analysis.cs b/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider_Analysis.cs
index aff8520c8d660..bb21394dadfff 100644
--- a/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider_Analysis.cs
+++ b/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider_Analysis.cs
@@ -7,6 +7,7 @@
 using System.Collections.Immutable;
 using System.Threading;
 using Microsoft.CodeAnalysis.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Text;
@@ -38,7 +39,7 @@ private Diagnostic AnalyzeSyntax(
             SemanticModel semanticModel, CodeStyleOption2<ExpressionBodyPreference> option,
             LambdaExpressionSyntax declaration, CancellationToken cancellationToken)
         {
-            if (CanOfferUseExpressionBody(option.Value, declaration))
+            if (CanOfferUseExpressionBody(option.Value, declaration, declaration.GetLanguageVersion()))
             {
                 var location = GetDiagnosticLocation(declaration);
 
diff --git a/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider_Refactoring.cs b/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider_Refactoring.cs
index 4ada48a26f064..a394bfb30fe7b 100644
--- a/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider_Refactoring.cs
+++ b/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider_Refactoring.cs
@@ -10,6 +10,7 @@
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeRefactorings;
 using Microsoft.CodeAnalysis.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Text;
@@ -106,7 +107,7 @@ private static async Task<ImmutableArray<CodeAction>> ComputeRefactoringsAsync(
             var optionSet = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
 
             using var resultDisposer = ArrayBuilder<CodeAction>.GetInstance(out var result);
-            if (CanOfferUseExpressionBody(option, lambdaNode))
+            if (CanOfferUseExpressionBody(option, lambdaNode, root.GetLanguageVersion()))
             {
                 result.Add(new MyCodeAction(
                     UseExpressionBodyTitle.ToString(),
diff --git a/src/Features/CSharp/Portable/UseLocalFunction/CSharpUseLocalFunctionCodeFixProvider.cs b/src/Features/CSharp/Portable/UseLocalFunction/CSharpUseLocalFunctionCodeFixProvider.cs
index bc8fb3da24002..a18aab329000c 100644
--- a/src/Features/CSharp/Portable/UseLocalFunction/CSharpUseLocalFunctionCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/UseLocalFunction/CSharpUseLocalFunctionCodeFixProvider.cs
@@ -21,6 +21,7 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Formatting;
+using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;
 
@@ -105,7 +106,7 @@ protected override async Task FixAllAsync(
                 var currentAnonymousFunction = currentRoot.GetCurrentNode(anonymousFunction);
 
                 currentRoot = ReplaceAnonymousWithLocalFunction(
-                    document.Project.Solution.Workspace, currentRoot,
+                    document.Project.Solution.Workspace.Services, currentRoot,
                     currentLocalDeclaration, currentAnonymousFunction,
                     delegateType.DelegateInvokeMethod, parameterList, makeStatic);
 
@@ -149,7 +150,7 @@ private static bool MakeStatic(
         }
 
         private static SyntaxNode ReplaceAnonymousWithLocalFunction(
-            Workspace workspace, SyntaxNode currentRoot,
+            HostWorkspaceServices services, SyntaxNode currentRoot,
             LocalDeclarationStatementSyntax localDeclaration, AnonymousFunctionExpressionSyntax anonymousFunction,
             IMethodSymbol delegateMethod, ParameterListSyntax parameterList, bool makeStatic)
         {
@@ -157,7 +158,7 @@ private static SyntaxNode ReplaceAnonymousWithLocalFunction(
                 .WithTriviaFrom(localDeclaration)
                 .WithAdditionalAnnotations(Formatter.Annotation);
 
-            var editor = new SyntaxEditor(currentRoot, workspace);
+            var editor = new SyntaxEditor(currentRoot, services);
             editor.ReplaceNode(localDeclaration, newLocalFunctionStatement);
 
             var anonymousFunctionStatement = anonymousFunction.GetAncestor<StatementSyntax>();
diff --git a/src/Features/Core/Portable/AddConstructorParametersFromMembers/AddConstructorParametersFromMembersCodeRefactoringProvider.AddConstructorParametersCodeAction.cs b/src/Features/Core/Portable/AddConstructorParametersFromMembers/AddConstructorParametersFromMembersCodeRefactoringProvider.AddConstructorParametersCodeAction.cs
index 6d73aa2eb24f2..57a7eb8bb50f0 100644
--- a/src/Features/Core/Portable/AddConstructorParametersFromMembers/AddConstructorParametersFromMembersCodeRefactoringProvider.AddConstructorParametersCodeAction.cs
+++ b/src/Features/Core/Portable/AddConstructorParametersFromMembers/AddConstructorParametersFromMembersCodeRefactoringProvider.AddConstructorParametersCodeAction.cs
@@ -47,22 +47,25 @@ public AddConstructorParametersCodeAction(
                 _useSubMenuName = useSubMenuName;
             }
 
-            protected override Task<Document> GetChangedDocumentAsync(CancellationToken cancellationToken)
+            protected override async Task<Document> GetChangedDocumentAsync(CancellationToken cancellationToken)
             {
-                var workspace = _document.Project.Solution.Workspace;
+                var services = _document.Project.Solution.Workspace.Services;
                 var declarationService = _document.GetRequiredLanguageService<ISymbolDeclarationService>();
                 var constructor = declarationService.GetDeclarations(
                     _constructorCandidate.Constructor).Select(r => r.GetSyntax(cancellationToken)).First();
 
+                var codeGenerator = _document.GetRequiredLanguageService<ICodeGenerationService>();
+                var options = await CodeGenerationOptions.FromDocumentAsync(CodeGenerationContext.Default, _document, cancellationToken).ConfigureAwait(false);
+
                 var newConstructor = constructor;
-                newConstructor = CodeGenerator.AddParameterDeclarations(newConstructor, _missingParameters, workspace);
-                newConstructor = CodeGenerator.AddStatements(newConstructor, CreateAssignStatements(_constructorCandidate), workspace)
+                newConstructor = codeGenerator.AddParameters(newConstructor, _missingParameters, options, cancellationToken);
+                newConstructor = codeGenerator.AddStatements(newConstructor, CreateAssignStatements(_constructorCandidate), options, cancellationToken)
                                                       .WithAdditionalAnnotations(Formatter.Annotation);
 
                 var syntaxTree = constructor.SyntaxTree;
                 var newRoot = syntaxTree.GetRoot(cancellationToken).ReplaceNode(constructor, newConstructor);
 
-                return Task.FromResult(_document.WithSyntaxRoot(newRoot));
+                return _document.WithSyntaxRoot(newRoot);
             }
 
             private IEnumerable<SyntaxNode> CreateAssignStatements(ConstructorCandidate constructorCandidate)
diff --git a/src/Features/Core/Portable/AddDebuggerDisplay/AbstractAddDebuggerDisplayCodeRefactoringProvider.cs b/src/Features/Core/Portable/AddDebuggerDisplay/AbstractAddDebuggerDisplayCodeRefactoringProvider.cs
index 38327967a7173..261c20b40f164 100644
--- a/src/Features/Core/Portable/AddDebuggerDisplay/AbstractAddDebuggerDisplayCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/AddDebuggerDisplay/AbstractAddDebuggerDisplayCodeRefactoringProvider.cs
@@ -113,7 +113,7 @@ private async Task<Document> ApplyAsync(Document document, TTypeDeclarationSynta
             var syntaxRoot = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
 
-            var editor = new SyntaxEditor(syntaxRoot, document.Project.Solution.Workspace);
+            var editor = new SyntaxEditor(syntaxRoot, document.Project.Solution.Workspace.Services);
             var generator = editor.Generator;
 
             SyntaxNode attributeArgument;
diff --git a/src/Features/Core/Portable/AddImport/AbstractAddImportFeatureService.cs b/src/Features/Core/Portable/AddImport/AbstractAddImportFeatureService.cs
index c0cc1aaf35ae1..40c95f26c90cf 100644
--- a/src/Features/Core/Portable/AddImport/AbstractAddImportFeatureService.cs
+++ b/src/Features/Core/Portable/AddImport/AbstractAddImportFeatureService.cs
@@ -23,6 +23,7 @@
 using Microsoft.CodeAnalysis.SymbolSearch;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
+using Microsoft.CodeAnalysis.CodeGeneration;
 
 namespace Microsoft.CodeAnalysis.AddImport
 {
@@ -51,7 +52,7 @@ internal abstract partial class AbstractAddImportFeatureService<TSimpleNameSynta
         protected abstract bool IsAddMethodContext(SyntaxNode node, SemanticModel semanticModel);
 
         protected abstract string GetDescription(IReadOnlyList<string> nameParts);
-        protected abstract (string description, bool hasExistingImport) GetDescription(Document document, OptionSet options, INamespaceOrTypeSymbol symbol, SemanticModel semanticModel, SyntaxNode root, CancellationToken cancellationToken);
+        protected abstract (string description, bool hasExistingImport) GetDescription(Document document, CodeGenerationPreferences preferences, INamespaceOrTypeSymbol symbol, SemanticModel semanticModel, SyntaxNode root, CancellationToken cancellationToken);
 
         public async Task<ImmutableArray<AddImportFixData>> GetFixesAsync(
             Document document, TextSpan span, string diagnosticId, int maxResults,
diff --git a/src/Features/Core/Portable/AddImport/References/MetadataSymbolReference.cs b/src/Features/Core/Portable/AddImport/References/MetadataSymbolReference.cs
index 30674ecb28b21..230b680865f12 100644
--- a/src/Features/Core/Portable/AddImport/References/MetadataSymbolReference.cs
+++ b/src/Features/Core/Portable/AddImport/References/MetadataSymbolReference.cs
@@ -9,6 +9,7 @@
 using System.IO;
 using System.Threading;
 using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Tags;
 using Microsoft.CodeAnalysis.Text;
@@ -41,10 +42,10 @@ public MetadataSymbolReference(
             protected override bool ShouldAddWithExistingImport(Document document) => true;
 
             protected override (string description, bool hasExistingImport) GetDescription(
-                Document document, OptionSet options, SyntaxNode node,
+                Document document, CodeGenerationPreferences preferences, SyntaxNode node,
                 SemanticModel semanticModel, CancellationToken cancellationToken)
             {
-                var (description, hasExistingImport) = base.GetDescription(document, options, node, semanticModel, cancellationToken);
+                var (description, hasExistingImport) = base.GetDescription(document, preferences, node, semanticModel, cancellationToken);
                 if (description == null)
                 {
                     return (null, false);
diff --git a/src/Features/Core/Portable/AddImport/References/ProjectSymbolReference.cs b/src/Features/Core/Portable/AddImport/References/ProjectSymbolReference.cs
index dd4f15c19888b..12939dbe3e1f5 100644
--- a/src/Features/Core/Portable/AddImport/References/ProjectSymbolReference.cs
+++ b/src/Features/Core/Portable/AddImport/References/ProjectSymbolReference.cs
@@ -7,6 +7,7 @@
 using System.Collections.Immutable;
 using System.Threading;
 using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Tags;
 using Microsoft.CodeAnalysis.Text;
@@ -86,10 +87,10 @@ protected override AddImportFixData GetFixData(
             }
 
             protected override (string description, bool hasExistingImport) GetDescription(
-                Document document, OptionSet options, SyntaxNode node,
+                Document document, CodeGenerationPreferences preferences, SyntaxNode node,
                 SemanticModel semanticModel, CancellationToken cancellationToken)
             {
-                var (description, hasExistingImport) = base.GetDescription(document, options, node, semanticModel, cancellationToken);
+                var (description, hasExistingImport) = base.GetDescription(document, preferences, node, semanticModel, cancellationToken);
                 if (description == null)
                 {
                     return (null, false);
diff --git a/src/Features/Core/Portable/AddImport/References/SymbolReference.cs b/src/Features/Core/Portable/AddImport/References/SymbolReference.cs
index e8b90b1f28262..ed39d369ee50f 100644
--- a/src/Features/Core/Portable/AddImport/References/SymbolReference.cs
+++ b/src/Features/Core/Portable/AddImport/References/SymbolReference.cs
@@ -9,7 +9,9 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Tags;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
@@ -81,9 +83,9 @@ public sealed override async Task<AddImportFixData> TryGetFixDataAsync(
                 Document document, SyntaxNode node,
                 bool allowInHiddenRegions, CancellationToken cancellationToken)
             {
-                var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
+                var preferences = await CodeGenerationPreferences.FromDocumentAsync(document, cancellationToken).ConfigureAwait(false);
                 var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
-                var (description, hasExistingImport) = GetDescription(document, options, node, semanticModel, cancellationToken);
+                var (description, hasExistingImport) = GetDescription(document, preferences, node, semanticModel, cancellationToken);
                 if (description == null)
                 {
                     return null;
@@ -128,11 +130,11 @@ protected abstract AddImportFixData GetFixData(
             protected abstract CodeActionPriority GetPriority(Document document);
 
             protected virtual (string description, bool hasExistingImport) GetDescription(
-                Document document, OptionSet options, SyntaxNode node,
+                Document document, CodeGenerationPreferences preferences, SyntaxNode node,
                 SemanticModel semanticModel, CancellationToken cancellationToken)
             {
                 return provider.GetDescription(
-                    document, options, SymbolResult.Symbol, semanticModel, node, cancellationToken);
+                    document, preferences, SymbolResult.Symbol, semanticModel, node, cancellationToken);
             }
         }
     }
diff --git a/src/Features/Core/Portable/AddObsoleteAttribute/AbstractAddObsoleteAttributeCodeFixProvider.cs b/src/Features/Core/Portable/AddObsoleteAttribute/AbstractAddObsoleteAttributeCodeFixProvider.cs
index 8e2a19f2356f8..3d8a78d4c50c4 100644
--- a/src/Features/Core/Portable/AddObsoleteAttribute/AbstractAddObsoleteAttributeCodeFixProvider.cs
+++ b/src/Features/Core/Portable/AddObsoleteAttribute/AbstractAddObsoleteAttributeCodeFixProvider.cs
@@ -80,6 +80,10 @@ protected override async Task FixAllAsync(
             SyntaxEditor editor, CancellationToken cancellationToken)
         {
             var obsoleteAttribute = await GetObsoleteAttributeAsync(document, cancellationToken).ConfigureAwait(false);
+
+            // RegisterCodeFixesAsync checked for null
+            Contract.ThrowIfNull(obsoleteAttribute);
+
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
             var containers = diagnostics.Select(d => GetContainer(root, d.Location.FindNode(cancellationToken)))
diff --git a/src/Features/Core/Portable/AddParameter/AddParameterService.cs b/src/Features/Core/Portable/AddParameter/AddParameterService.cs
index 017505dd01965..53dcb613ecde6 100644
--- a/src/Features/Core/Portable/AddParameter/AddParameterService.cs
+++ b/src/Features/Core/Portable/AddParameter/AddParameterService.cs
@@ -98,7 +98,7 @@ public async Task<Solution> AddParameterAsync(
                 var document = documentLookup.Key;
                 var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
                 var syntaxRoot = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-                var editor = new SyntaxEditor(syntaxRoot, solution.Workspace);
+                var editor = new SyntaxEditor(syntaxRoot, solution.Workspace.Services);
                 var generator = editor.Generator;
                 foreach (var methodDeclaration in documentLookup)
                 {
diff --git a/src/Features/Core/Portable/AliasAmbiguousType/AbstractAliasAmbiguousTypeCodeFixProvider.cs b/src/Features/Core/Portable/AliasAmbiguousType/AbstractAliasAmbiguousTypeCodeFixProvider.cs
index bd12d7f4e6f0f..c137b7e50340d 100644
--- a/src/Features/Core/Portable/AliasAmbiguousType/AbstractAliasAmbiguousTypeCodeFixProvider.cs
+++ b/src/Features/Core/Portable/AliasAmbiguousType/AbstractAliasAmbiguousTypeCodeFixProvider.cs
@@ -10,6 +10,7 @@
 using Microsoft.CodeAnalysis.AddImports;
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.Shared.Extensions;
@@ -43,8 +44,10 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
             {
                 var addImportService = document.GetRequiredLanguageService<IAddImportsService>();
                 var syntaxGenerator = document.GetRequiredLanguageService<SyntaxGenerator>();
+                var codeGenerator = document.GetRequiredLanguageService<ICodeGenerationService>();
                 var compilation = semanticModel.Compilation;
-                var optionSet = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
+                var preferences = await CodeGenerationPreferences.FromDocumentAsync(document, cancellationToken).ConfigureAwait(false);
+
                 var allowInHiddenRegions = document.CanAddImportsInHiddenRegions();
                 var codeActionsBuilder = ImmutableArray.CreateBuilder<CodeAction>(symbolInfo.CandidateSymbols.Length);
                 foreach (var symbol in symbolInfo.CandidateSymbols.Cast<ITypeSymbol>())
@@ -54,7 +57,7 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
                     codeActionsBuilder.Add(new MyCodeAction(codeActionPreviewText, c =>
                         {
                             var aliasDirective = syntaxGenerator.AliasImportDeclaration(typeName, symbol);
-                            var newRoot = addImportService.AddImport(compilation, root, diagnosticNode, aliasDirective, syntaxGenerator, optionSet, allowInHiddenRegions, cancellationToken);
+                            var newRoot = addImportService.AddImport(compilation, root, diagnosticNode, aliasDirective, syntaxGenerator, preferences, allowInHiddenRegions, cancellationToken);
                             return Task.FromResult(document.WithSyntaxRoot(newRoot));
                         }));
                 }
diff --git a/src/Features/Core/Portable/CodeRefactorings/SyncNamespace/AbstractChangeNamespaceService.cs b/src/Features/Core/Portable/CodeRefactorings/SyncNamespace/AbstractChangeNamespaceService.cs
index d4c89edca9c7a..b2c6802a6bddd 100644
--- a/src/Features/Core/Portable/CodeRefactorings/SyncNamespace/AbstractChangeNamespaceService.cs
+++ b/src/Features/Core/Portable/CodeRefactorings/SyncNamespace/AbstractChangeNamespaceService.cs
@@ -12,6 +12,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.AddImports;
+using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.FindSymbols;
 using Microsoft.CodeAnalysis.Formatting;
@@ -688,6 +689,7 @@ await FixReferencesAsync(document, changeNamespaceService, addImportService, ref
 
             var generator = SyntaxGenerator.GetGenerator(document);
             var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
+            var codeGenerator = document.GetRequiredLanguageService<ICodeGenerationService>();
 
             // We need a dummy import to figure out the container for given reference.
             var dummyImport = CreateImport(generator, "Dummy", withFormatterAnnotation: false);
@@ -728,9 +730,10 @@ await FixReferencesAsync(document, changeNamespaceService, addImportService, ref
                     }
                 }
 
-                var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
+                var preferences = await CodeGenerationPreferences.FromDocumentAsync(document, cancellationToken).ConfigureAwait(false);
+
                 // Use a dummy import node to figure out which container the new import will be added to.
-                var container = addImportService.GetImportContainer(root, refNode, dummyImport, options);
+                var container = addImportService.GetImportContainer(root, refNode, dummyImport, preferences);
                 containers.Add(container);
             }
 
@@ -818,7 +821,8 @@ private static async Task<Document> AddImportsInContainersAsync(
                 containers = containers.Sort(SyntaxNodeSpanStartComparer.Instance);
             }
 
-            var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
+            var preferences = await CodeGenerationPreferences.FromDocumentAsync(document, cancellationToken).ConfigureAwait(false);
+            var generator = document.GetRequiredLanguageService<SyntaxGenerator>();
 
             var imports = CreateImports(document, names, withFormatterAnnotation: true);
             foreach (var container in containers)
@@ -832,8 +836,7 @@ private static async Task<Document> AddImportsInContainersAsync(
 
                 var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);
                 var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-                var generator = document.GetRequiredLanguageService<SyntaxGenerator>();
-                root = addImportService.AddImports(compilation, root, contextLocation, imports, generator, options, allowInHiddenRegions, cancellationToken);
+                root = addImportService.AddImports(compilation, root, contextLocation, imports, generator, preferences, allowInHiddenRegions, cancellationToken);
                 document = document.WithSyntaxRoot(root);
             }
 
diff --git a/src/Features/Core/Portable/Completion/Providers/AbstractMemberInsertingCompletionProvider.cs b/src/Features/Core/Portable/Completion/Providers/AbstractMemberInsertingCompletionProvider.cs
index cc3fbda24b4a5..37fd238b56cce 100644
--- a/src/Features/Core/Portable/Completion/Providers/AbstractMemberInsertingCompletionProvider.cs
+++ b/src/Features/Core/Portable/Completion/Providers/AbstractMemberInsertingCompletionProvider.cs
@@ -125,9 +125,8 @@ private async Task<Document> DetermineNewDocumentAsync(Document document, Comple
             }
 
             // CodeGenerationOptions containing before and after
-            var options = new CodeGenerationOptions(
-                contextLocation: semanticModel.SyntaxTree.GetLocation(TextSpan.FromBounds(line.Start, line.Start)),
-                options: await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false));
+            var context = new CodeGenerationContext(
+                contextLocation: semanticModel.SyntaxTree.GetLocation(TextSpan.FromBounds(line.Start, line.Start)));
 
             var generatedMember = await GenerateMemberAsync(overriddenMember, containingType, document, completionItem, cancellationToken).ConfigureAwait(false);
             generatedMember = _annotation.AddAnnotationToSymbol(generatedMember);
@@ -135,15 +134,15 @@ private async Task<Document> DetermineNewDocumentAsync(Document document, Comple
             Document? memberContainingDocument = null;
             if (generatedMember.Kind == SymbolKind.Method)
             {
-                memberContainingDocument = await codeGenService.AddMethodAsync(document.Project.Solution, containingType, (IMethodSymbol)generatedMember, options, cancellationToken).ConfigureAwait(false);
+                memberContainingDocument = await codeGenService.AddMethodAsync(document.Project.Solution, containingType, (IMethodSymbol)generatedMember, context, cancellationToken).ConfigureAwait(false);
             }
             else if (generatedMember.Kind == SymbolKind.Property)
             {
-                memberContainingDocument = await codeGenService.AddPropertyAsync(document.Project.Solution, containingType, (IPropertySymbol)generatedMember, options, cancellationToken).ConfigureAwait(false);
+                memberContainingDocument = await codeGenService.AddPropertyAsync(document.Project.Solution, containingType, (IPropertySymbol)generatedMember, context, cancellationToken).ConfigureAwait(false);
             }
             else if (generatedMember.Kind == SymbolKind.Event)
             {
-                memberContainingDocument = await codeGenService.AddEventAsync(document.Project.Solution, containingType, (IEventSymbol)generatedMember, options, cancellationToken).ConfigureAwait(false);
+                memberContainingDocument = await codeGenService.AddEventAsync(document.Project.Solution, containingType, (IEventSymbol)generatedMember, context, cancellationToken).ConfigureAwait(false);
             }
 
             return memberContainingDocument;
diff --git a/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/AbstractImportCompletionProvider.cs b/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/AbstractImportCompletionProvider.cs
index a7297f2185005..1e29f23f3cb0c 100644
--- a/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/AbstractImportCompletionProvider.cs
+++ b/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/AbstractImportCompletionProvider.cs
@@ -7,6 +7,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.AddImports;
+using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.Completion.Log;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Formatting;
@@ -127,12 +128,12 @@ public override async Task<CompletionChange> GetChangeAsync(
             // Add required using/imports directive.
             var addImportService = document.GetRequiredLanguageService<IAddImportsService>();
             var generator = document.GetRequiredLanguageService<SyntaxGenerator>();
-            var optionSet = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
+            var preferences = await CodeGenerationPreferences.FromDocumentAsync(document, cancellationToken).ConfigureAwait(false);
             var allowInHiddenRegions = document.CanAddImportsInHiddenRegions();
             var importNode = CreateImport(document, containingNamespace);
 
             var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);
-            var rootWithImport = addImportService.AddImport(compilation, root, addImportContextNode!, importNode, generator, optionSet, allowInHiddenRegions, cancellationToken);
+            var rootWithImport = addImportService.AddImport(compilation, root, addImportContextNode!, importNode, generator, preferences, allowInHiddenRegions, cancellationToken);
             var documentWithImport = document.WithSyntaxRoot(rootWithImport);
             // This only formats the annotated import we just added, not the entire document.
             var formattedDocumentWithImport = await Formatter.FormatAsync(documentWithImport, Formatter.Annotation, cancellationToken: cancellationToken).ConfigureAwait(false);
diff --git a/src/Features/Core/Portable/ConvertAnonymousType/AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs b/src/Features/Core/Portable/ConvertAnonymousType/AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs
index 1ed01b322bd86..1720eb5ac567f 100644
--- a/src/Features/Core/Portable/ConvertAnonymousType/AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/ConvertAnonymousType/AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs
@@ -81,7 +81,6 @@ private async Task<Document> ConvertAsync(Document document, TextSpan span, bool
             Debug.Assert(anonymousType != null);
 
             var position = span.Start;
-            var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
 
@@ -122,21 +121,18 @@ await ReplaceMatchingAnonymousTypesAsync(
                 containingMember, anonymousObject,
                 anonymousType, cancellationToken).ConfigureAwait(false);
 
+            var context = new CodeGenerationContext(
+                generateMembers: true,
+                sortMembers: false,
+                autoInsertionLocation: false);
+
+            var codeGenOptions = await CodeGenerationOptions.FromDocumentAsync(context, document, cancellationToken).ConfigureAwait(false);
+            var codeGenService = document.GetRequiredLanguageService<ICodeGenerationService>();
+
             // Then, actually insert the new class in the appropriate container.
             var container = anonymousObject.GetAncestor<TNamespaceDeclarationSyntax>() ?? root;
             editor.ReplaceNode(container, (currentContainer, _) =>
-            {
-                var codeGenService = document.GetRequiredLanguageService<ICodeGenerationService>();
-                var codeGenOptions = new CodeGenerationOptions(
-                    generateMembers: true,
-                    sortMembers: false,
-                    autoInsertionLocation: false,
-                    options: options,
-                    parseOptions: root.SyntaxTree.Options);
-
-                return codeGenService.AddNamedType(
-                    currentContainer, namedTypeSymbol, codeGenOptions, cancellationToken);
-            });
+                codeGenService.AddNamedType(currentContainer, namedTypeSymbol, codeGenOptions, cancellationToken));
 
             var updatedDocument = document.WithSyntaxRoot(editor.GetChangedRoot());
 
diff --git a/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs b/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs
index d5cc1f5d54cf0..8e626eb88a81d 100644
--- a/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs
@@ -11,23 +11,22 @@
 using Microsoft.CodeAnalysis.CodeRefactorings;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Formatting;
-using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.ConvertAutoPropertyToFullProperty
 {
-    internal abstract class AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider<TPropertyDeclarationNode, TTypeDeclarationNode>
-        : CodeRefactoringProvider
+    internal abstract class AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider<TPropertyDeclarationNode, TTypeDeclarationNode, TCodeGenerationPreferences> : CodeRefactoringProvider
         where TPropertyDeclarationNode : SyntaxNode
         where TTypeDeclarationNode : SyntaxNode
+        where TCodeGenerationPreferences : CodeGenerationPreferences
     {
         internal abstract Task<string> GetFieldNameAsync(Document document, IPropertySymbol propertySymbol, CancellationToken cancellationToken);
         internal abstract (SyntaxNode newGetAccessor, SyntaxNode newSetAccessor) GetNewAccessors(
-            DocumentOptionSet options, SyntaxNode property, string fieldName, SyntaxGenerator generator);
+            TCodeGenerationPreferences preferences, SyntaxNode property, string fieldName, SyntaxGenerator generator);
         internal abstract SyntaxNode GetPropertyWithoutInitializer(SyntaxNode property);
         internal abstract SyntaxNode GetInitializerValue(SyntaxNode property);
-        internal abstract SyntaxNode ConvertPropertyToExpressionBodyIfDesired(DocumentOptionSet options, SyntaxNode fullProperty);
+        internal abstract SyntaxNode ConvertPropertyToExpressionBodyIfDesired(TCodeGenerationPreferences preferences, SyntaxNode fullProperty);
         internal abstract SyntaxNode GetTypeBlock(SyntaxNode syntaxNode);
 
         public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
@@ -84,14 +83,18 @@ private async Task<Document> ExpandToFullPropertyAsync(
             SyntaxNode root,
             CancellationToken cancellationToken)
         {
+            Contract.ThrowIfNull(document.DocumentState.ParseOptions);
+
             var generator = SyntaxGenerator.GetGenerator(document);
-            var workspace = document.Project.Solution.Workspace;
-            var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
+            var codeGenerator = document.GetRequiredLanguageService<ICodeGenerationService>();
+            var services = document.Project.Solution.Workspace.Services;
+
+            var preferences = (TCodeGenerationPreferences)await CodeGenerationPreferences.FromDocumentAsync(document, cancellationToken).ConfigureAwait(false);
 
             // Create full property. If the auto property had an initial value
             // we need to remove it and later add it to the backing field
             var fieldName = await GetFieldNameAsync(document, propertySymbol, cancellationToken).ConfigureAwait(false);
-            var (newGetAccessor, newSetAccessor) = GetNewAccessors(options, property, fieldName, generator);
+            var (newGetAccessor, newSetAccessor) = GetNewAccessors(preferences, property, fieldName, generator);
             var fullProperty = generator
                 .WithAccessorDeclarations(
                     GetPropertyWithoutInitializer(property),
@@ -99,8 +102,8 @@ private async Task<Document> ExpandToFullPropertyAsync(
                         ? new SyntaxNode[] { newGetAccessor }
                         : new SyntaxNode[] { newGetAccessor, newSetAccessor })
                 .WithLeadingTrivia(property.GetLeadingTrivia());
-            fullProperty = ConvertPropertyToExpressionBodyIfDesired(options, fullProperty);
-            var editor = new SyntaxEditor(root, workspace);
+            fullProperty = ConvertPropertyToExpressionBodyIfDesired(preferences, fullProperty);
+            var editor = new SyntaxEditor(root, services);
             editor.ReplaceNode(property, fullProperty.WithAdditionalAnnotations(Formatter.Annotation));
 
             // add backing field, plus initializer if it exists 
@@ -110,6 +113,7 @@ private async Task<Document> ExpandToFullPropertyAsync(
                 propertySymbol.Type, fieldName,
                 initializer: GetInitializerValue(property));
 
+            var codeGenOptions = preferences.GetOptions(CodeGenerationContext.Default);
             var typeDeclaration = propertySymbol.ContainingType.DeclaringSyntaxReferences;
             foreach (var td in typeDeclaration)
             {
@@ -117,7 +121,7 @@ private async Task<Document> ExpandToFullPropertyAsync(
                 if (property.Ancestors().Contains(block))
                 {
                     editor.ReplaceNode(block, (currentTypeDecl, _)
-                        => CodeGenerator.AddFieldDeclaration(currentTypeDecl, newField, workspace)
+                        => codeGenerator.AddField(currentTypeDecl, newField, codeGenOptions, cancellationToken)
                         .WithAdditionalAnnotations(Formatter.Annotation));
                 }
             }
diff --git a/src/Features/Core/Portable/ConvertForEachToFor/AbstractConvertForEachToForCodeRefactoringProvider.cs b/src/Features/Core/Portable/ConvertForEachToFor/AbstractConvertForEachToForCodeRefactoringProvider.cs
index 1086407b4c04e..fc9cde67e6c2a 100644
--- a/src/Features/Core/Portable/ConvertForEachToFor/AbstractConvertForEachToForCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/ConvertForEachToFor/AbstractConvertForEachToForCodeRefactoringProvider.cs
@@ -120,8 +120,7 @@ protected static void IntroduceCollectionStatement(
             var collectionStatement = generator.LocalDeclarationStatement(
                 type,
                 collectionVariableToken,
-                foreachInfo.RequireExplicitCastInterface
-                    ? generator.CastExpression(foreachInfo.ExplicitCastInterface, expression) : expression);
+                (foreachInfo.ExplicitCastInterface != null) ? generator.CastExpression(foreachInfo.ExplicitCastInterface, expression) : expression);
 
             // attach trivia to right place
             collectionStatement = collectionStatement.WithLeadingTrivia(foreachInfo.ForEachStatement.GetFirstToken().LeadingTrivia);
@@ -422,8 +421,8 @@ private async Task<Document> ConvertForeachToForAsync(
             CancellationToken cancellationToken)
         {
             var model = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
-            var workspace = document.Project.Solution.Workspace;
-            var editor = new SyntaxEditor(model.SyntaxTree.GetRoot(cancellationToken), workspace);
+            var services = document.Project.Solution.Workspace.Services;
+            var editor = new SyntaxEditor(model.SyntaxTree.GetRoot(cancellationToken), services);
 
             ConvertToForStatement(model, foreachInfo, editor, cancellationToken);
 
@@ -431,7 +430,7 @@ private async Task<Document> ConvertForeachToForAsync(
             return document.WithSyntaxRoot(newRoot);
         }
 
-        protected class ForEachInfo
+        protected sealed class ForEachInfo
         {
             public ForEachInfo(
                 ISemanticFactsService semanticFacts, string collectionNameSuggestion, string countName,
@@ -440,8 +439,6 @@ public ForEachInfo(
             {
                 SemanticFacts = semanticFacts;
 
-                RequireExplicitCastInterface = explicitCastInterface != null;
-
                 CollectionNameSuggestion = collectionNameSuggestion;
                 CountName = countName;
 
@@ -455,7 +452,6 @@ public ForEachInfo(
 
             public ISemanticFactsService SemanticFacts { get; }
 
-            public bool RequireExplicitCastInterface { get; }
             public string CollectionNameSuggestion { get; }
             public string CountName { get; }
             public ITypeSymbol? ExplicitCastInterface { get; }
diff --git a/src/Features/Core/Portable/ConvertLinq/ConvertForEachToLinqQuery/AbstractConvertForEachToLinqQueryProvider.cs b/src/Features/Core/Portable/ConvertLinq/ConvertForEachToLinqQuery/AbstractConvertForEachToLinqQueryProvider.cs
index bd8c418eac6f0..a670cc0e6be90 100644
--- a/src/Features/Core/Portable/ConvertLinq/ConvertForEachToLinqQuery/AbstractConvertForEachToLinqQueryProvider.cs
+++ b/src/Features/Core/Portable/ConvertLinq/ConvertForEachToLinqQuery/AbstractConvertForEachToLinqQueryProvider.cs
@@ -148,7 +148,7 @@ private Task<Document> ApplyConversionAsync(
             bool convertToQuery,
             CancellationToken cancellationToken)
         {
-            var editor = new SyntaxEditor(converter.ForEachInfo.SemanticModel.SyntaxTree.GetRoot(cancellationToken), document.Project.Solution.Workspace);
+            var editor = new SyntaxEditor(converter.ForEachInfo.SemanticModel.SyntaxTree.GetRoot(cancellationToken), document.Project.Solution.Workspace.Services);
             converter.Convert(editor, convertToQuery, cancellationToken);
             var newRoot = editor.GetChangedRoot();
             var rootWithLinqUsing = AddLinqUsing(converter, converter.ForEachInfo.SemanticModel, newRoot);
diff --git a/src/Features/Core/Portable/ConvertToInterpolatedString/AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs b/src/Features/Core/Portable/ConvertToInterpolatedString/AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs
index 373fe90b1ecdf..14cb10e4ae3fe 100644
--- a/src/Features/Core/Portable/ConvertToInterpolatedString/AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs
+++ b/src/Features/Core/Portable/ConvertToInterpolatedString/AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs
@@ -267,7 +267,7 @@ private static ImmutableArray<TExpressionSyntax> GetExpandedArguments(
             for (var i = 1; i < arguments.Count; i++)
             {
                 var argumentExpression = syntaxFacts.GetExpressionOfArgument(GetArgument(arguments, i, syntaxFacts));
-                var convertedType = argumentExpression == null ? null : semanticModel.GetTypeInfo(argumentExpression).ConvertedType;
+                var convertedType = semanticModel.GetTypeInfo(argumentExpression).ConvertedType;
                 if (convertedType == null)
                 {
                     builder.Add((TExpressionSyntax)syntaxGenerator.AddParentheses(argumentExpression));
diff --git a/src/Features/Core/Portable/ConvertTupleToStruct/AbstractConvertTupleToStructCodeRefactoringProvider.cs b/src/Features/Core/Portable/ConvertTupleToStruct/AbstractConvertTupleToStructCodeRefactoringProvider.cs
index f07d17dd0827a..eb41179388067 100644
--- a/src/Features/Core/Portable/ConvertTupleToStruct/AbstractConvertTupleToStructCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/ConvertTupleToStruct/AbstractConvertTupleToStructCodeRefactoringProvider.cs
@@ -554,19 +554,17 @@ private static async Task GenerateStructIntoContainingNamespaceAsync(
             var syntaxFacts = document.GetLanguageService<ISyntaxFactsService>();
             var container = tupleExprOrTypeNode.GetAncestor<TNamespaceDeclarationSyntax>() ?? root;
 
+            var codeGenService = document.GetRequiredLanguageService<ICodeGenerationService>();
+            var context = new CodeGenerationContext(
+                generateMembers: true,
+                sortMembers: false,
+                autoInsertionLocation: false);
+
+            var options = await CodeGenerationOptions.FromDocumentAsync(context, document, cancellationToken).ConfigureAwait(false);
+
             // Then, actually insert the new class in the appropriate container.
             editor.ReplaceNode(container, (currentContainer, _) =>
-            {
-                var codeGenService = document.GetRequiredLanguageService<ICodeGenerationService>();
-                var options = new CodeGenerationOptions(
-                    generateMembers: true,
-                    sortMembers: false,
-                    autoInsertionLocation: false,
-                    parseOptions: root.SyntaxTree.Options);
-
-                return codeGenService.AddNamedType(
-                    currentContainer, namedTypeSymbol, options, cancellationToken);
-            });
+                codeGenService.AddNamedType(currentContainer, namedTypeSymbol, options, cancellationToken));
         }
 
         private static async Task<Solution> ApplyChangesAsync(
diff --git a/src/Features/Core/Portable/EncapsulateField/AbstractEncapsulateFieldService.cs b/src/Features/Core/Portable/EncapsulateField/AbstractEncapsulateFieldService.cs
index f33a07c2d04ee..264c1bb565560 100644
--- a/src/Features/Core/Portable/EncapsulateField/AbstractEncapsulateFieldService.cs
+++ b/src/Features/Core/Portable/EncapsulateField/AbstractEncapsulateFieldService.cs
@@ -315,14 +315,13 @@ protected static async Task<Solution> AddPropertyAsync(Document document, Soluti
             var codeGenerationService = document.GetLanguageService<ICodeGenerationService>();
 
             var fieldDeclaration = field.DeclaringSyntaxReferences.First();
-            var options = new CodeGenerationOptions(
-                contextLocation: fieldDeclaration.SyntaxTree.GetLocation(fieldDeclaration.Span),
-                parseOptions: fieldDeclaration.SyntaxTree.Options,
-                options: await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false));
+
+            var context = new CodeGenerationContext(
+                contextLocation: fieldDeclaration.SyntaxTree.GetLocation(fieldDeclaration.Span));
 
             var destination = field.ContainingType;
             var updatedDocument = await codeGenerationService.AddPropertyAsync(
-                destinationSolution, destination, property, options, cancellationToken).ConfigureAwait(false);
+                destinationSolution, destination, property, context, cancellationToken).ConfigureAwait(false);
 
             updatedDocument = await Formatter.FormatAsync(updatedDocument, Formatter.Annotation, cancellationToken: cancellationToken).ConfigureAwait(false);
             updatedDocument = await Simplifier.ReduceAsync(updatedDocument, cancellationToken: cancellationToken).ConfigureAwait(false);
diff --git a/src/Features/Core/Portable/ExtractInterface/AbstractExtractInterfaceService.cs b/src/Features/Core/Portable/ExtractInterface/AbstractExtractInterfaceService.cs
index 1d9e05d170793..fbefd43962602 100644
--- a/src/Features/Core/Portable/ExtractInterface/AbstractExtractInterfaceService.cs
+++ b/src/Features/Core/Portable/ExtractInterface/AbstractExtractInterfaceService.cs
@@ -324,7 +324,7 @@ private async Task<Solution> GetSolutionWithOriginalTypeUpdatedAsync(
             {
                 var document = solution.GetDocument(documentId);
                 var currentRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-                var editor = new SyntaxEditor(currentRoot, solution.Workspace);
+                var editor = new SyntaxEditor(currentRoot, solution.Workspace.Services);
 
                 var syntaxGenerator = SyntaxGenerator.GetGenerator(document);
                 var typeReference = syntaxGenerator.TypeExpression(extractedInterfaceSymbol);
diff --git a/src/Features/Core/Portable/ExtractMethod/MethodExtractor.CodeGenerator.cs b/src/Features/Core/Portable/ExtractMethod/MethodExtractor.CodeGenerator.cs
index 42ee81499b9f3..df1b7b1ba792f 100644
--- a/src/Features/Core/Portable/ExtractMethod/MethodExtractor.CodeGenerator.cs
+++ b/src/Features/Core/Portable/ExtractMethod/MethodExtractor.CodeGenerator.cs
@@ -105,10 +105,15 @@ public async Task<GeneratedCode> GenerateAsync(CancellationToken cancellationTok
                             OperationStatus.NoValidLocationToInsertMethodCall, callSiteDocument, cancellationToken).ConfigureAwait(false);
                     }
 
-                    var localMethod = codeGenerationService.CreateMethodDeclaration(
-                        method: result.Data,
-                        options: new CodeGenerationOptions(generateDefaultAccessibility: false, generateMethodBodies: true, options: Options, parseOptions: destination?.SyntaxTree.Options));
-                    newContainer = codeGenerationService.AddStatements(destination, new[] { localMethod }, cancellationToken: cancellationToken);
+                    var options = codeGenerationService.GetOptions(
+                        destination.SyntaxTree.Options,
+                        Options,
+                        new CodeGenerationContext(
+                            generateDefaultAccessibility: false,
+                            generateMethodBodies: true));
+
+                    var localMethod = codeGenerationService.CreateMethodDeclaration(result.Data, CodeGenerationDestination.Unspecified, options, cancellationToken);
+                    newContainer = codeGenerationService.AddStatements(destination, new[] { localMethod }, options, cancellationToken);
                 }
                 else
                 {
@@ -116,10 +121,16 @@ public async Task<GeneratedCode> GenerateAsync(CancellationToken cancellationTok
 
                     // it is possible in a script file case where there is no previous member. in that case, insert new text into top level script
                     destination = previousMemberNode.Parent ?? previousMemberNode;
-                    newContainer = codeGenerationService.AddMethod(
-                        destination, result.Data,
-                        new CodeGenerationOptions(afterThisLocation: previousMemberNode.GetLocation(), generateDefaultAccessibility: true, generateMethodBodies: true, options: Options),
-                        cancellationToken);
+
+                    var options = codeGenerationService.GetOptions(
+                        destination.SyntaxTree.Options,
+                        Options,
+                        new CodeGenerationContext(
+                            afterThisLocation: previousMemberNode.GetLocation(),
+                            generateDefaultAccessibility: true,
+                            generateMethodBodies: true));
+
+                    newContainer = codeGenerationService.AddMethod(destination, result.Data, options, cancellationToken);
                 }
 
                 var newSyntaxRoot = newCallSiteRoot.ReplaceNode(destination, newContainer);
diff --git a/src/Features/Core/Portable/GenerateComparisonOperators/GenerateComparisonOperatorsCodeRefactoringProvider.cs b/src/Features/Core/Portable/GenerateComparisonOperators/GenerateComparisonOperatorsCodeRefactoringProvider.cs
index 852139e23f41b..9ccad19ba7c4c 100644
--- a/src/Features/Core/Portable/GenerateComparisonOperators/GenerateComparisonOperatorsCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/GenerateComparisonOperators/GenerateComparisonOperatorsCodeRefactoringProvider.cs
@@ -136,7 +136,6 @@ private static async Task<Document> GenerateComparisonOperatorsAsync(
             INamedTypeSymbol comparableType,
             CancellationToken cancellationToken)
         {
-            var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
             var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
 
             var containingType = (INamedTypeSymbol)semanticModel.GetRequiredDeclaredSymbol(typeDeclaration, cancellationToken);
@@ -149,14 +148,9 @@ private static async Task<Document> GenerateComparisonOperatorsAsync(
                 generator, semanticModel.Compilation, containingType, comparableType,
                 GenerateLeftExpression(generator, comparableType, compareMethod));
 
-            return await codeGenService.AddMembersAsync(
-                document.Project.Solution,
-                containingType,
-                operators,
-                new CodeGenerationOptions(
-                    contextLocation: typeDeclaration.GetLocation(),
-                    options: options,
-                    parseOptions: typeDeclaration.SyntaxTree.Options), cancellationToken).ConfigureAwait(false);
+            var context = new CodeGenerationContext(contextLocation: typeDeclaration.GetLocation());
+
+            return await codeGenService.AddMembersAsync(document.Project.Solution, containingType, operators, context, cancellationToken).ConfigureAwait(false);
         }
 
         private static SyntaxNode GenerateLeftExpression(
diff --git a/src/Features/Core/Portable/GenerateConstructorFromMembers/AbstractGenerateConstructorFromMembersCodeRefactoringProvider.ConstructorDelegatingCodeAction.cs b/src/Features/Core/Portable/GenerateConstructorFromMembers/AbstractGenerateConstructorFromMembersCodeRefactoringProvider.ConstructorDelegatingCodeAction.cs
index 77d7848fce439..8ab0ee4c71b32 100644
--- a/src/Features/Core/Portable/GenerateConstructorFromMembers/AbstractGenerateConstructorFromMembersCodeRefactoringProvider.ConstructorDelegatingCodeAction.cs
+++ b/src/Features/Core/Portable/GenerateConstructorFromMembers/AbstractGenerateConstructorFromMembersCodeRefactoringProvider.ConstructorDelegatingCodeAction.cs
@@ -98,7 +98,7 @@ protected override async Task<Document> GetChangedDocumentAsync(CancellationToke
                         parameters: _state.Parameters,
                         statements: statements,
                         thisConstructorArguments: thisConstructorArguments),
-                    new CodeGenerationOptions(
+                    new CodeGenerationContext(
                         contextLocation: syntaxTree.GetLocation(_state.TextSpan),
                         afterThisLocation: afterThisLocation),
                     cancellationToken: cancellationToken).ConfigureAwait(false);
diff --git a/src/Features/Core/Portable/GenerateConstructorFromMembers/AbstractGenerateConstructorFromMembersCodeRefactoringProvider.FieldDelegatingCodeAction.cs b/src/Features/Core/Portable/GenerateConstructorFromMembers/AbstractGenerateConstructorFromMembersCodeRefactoringProvider.FieldDelegatingCodeAction.cs
index 57f807e53a2d2..2505655e2a6a9 100644
--- a/src/Features/Core/Portable/GenerateConstructorFromMembers/AbstractGenerateConstructorFromMembersCodeRefactoringProvider.FieldDelegatingCodeAction.cs
+++ b/src/Features/Core/Portable/GenerateConstructorFromMembers/AbstractGenerateConstructorFromMembersCodeRefactoringProvider.FieldDelegatingCodeAction.cs
@@ -77,7 +77,7 @@ protected override async Task<Document> GetChangedDocumentAsync(CancellationToke
                     _document.Project.Solution,
                     _state.ContainingType,
                     members,
-                    new CodeGenerationOptions(
+                    new CodeGenerationContext(
                         contextLocation: syntaxTree.GetLocation(_state.TextSpan),
                         afterThisLocation: afterThisLocation),
                     cancellationToken).ConfigureAwait(false);
diff --git a/src/Features/Core/Portable/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.AbstractCodeAction.cs b/src/Features/Core/Portable/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.AbstractCodeAction.cs
index 37cd7f4cfdf9f..123ee3c1c7e19 100644
--- a/src/Features/Core/Portable/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.AbstractCodeAction.cs
+++ b/src/Features/Core/Portable/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.AbstractCodeAction.cs
@@ -44,7 +44,8 @@ protected override async Task<Document> GetChangedDocumentAsync(CancellationToke
                     _document.Project.Solution,
                     _state.ClassType,
                     _constructors.Select(CreateConstructorDefinition),
-                    cancellationToken: cancellationToken).ConfigureAwait(false);
+                    CodeGenerationContext.Default,
+                    cancellationToken).ConfigureAwait(false);
 
                 return result;
             }
diff --git a/src/Features/Core/Portable/GenerateEqualsAndGetHashCodeFromMembers/GenerateEqualsAndGetHashCodeAction.cs b/src/Features/Core/Portable/GenerateEqualsAndGetHashCodeFromMembers/GenerateEqualsAndGetHashCodeAction.cs
index d55ce6dc559fd..28019aa924b37 100644
--- a/src/Features/Core/Portable/GenerateEqualsAndGetHashCodeFromMembers/GenerateEqualsAndGetHashCodeAction.cs
+++ b/src/Features/Core/Portable/GenerateEqualsAndGetHashCodeFromMembers/GenerateEqualsAndGetHashCodeAction.cs
@@ -80,10 +80,9 @@ protected override async Task<Document> GetChangedDocumentAsync(CancellationToke
                     await AddOperatorsAsync(methods, cancellationToken).ConfigureAwait(false);
                 }
 
-                var options = await _document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
-                var newTypeDeclaration = CodeGenerator.AddMemberDeclarations(
-                    _typeDeclaration, methods, _document.Project.Solution.Workspace,
-                    new CodeGenerationOptions(options: options));
+                var codeGenerator = _document.GetRequiredLanguageService<ICodeGenerationService>();
+                var options = await CodeGenerationOptions.FromDocumentAsync(CodeGenerationContext.Default, _document, cancellationToken).ConfigureAwait(false);
+                var newTypeDeclaration = codeGenerator.AddMembers(_typeDeclaration, methods, options, cancellationToken);
 
                 if (constructedTypeToImplement is object)
                 {
diff --git a/src/Features/Core/Portable/GenerateMember/GenerateConstructor/AbstractGenerateConstructorService.State.cs b/src/Features/Core/Portable/GenerateMember/GenerateConstructor/AbstractGenerateConstructorService.State.cs
index 7c97ed40b74a6..379432fe3f46f 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateConstructor/AbstractGenerateConstructorService.State.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateConstructor/AbstractGenerateConstructorService.State.cs
@@ -598,9 +598,7 @@ public async Task<Document> GetChangedDocumentAsync(
                     document.Project.Solution,
                     TypeToGenerateIn,
                     members.Concat(constructor),
-                    new CodeGenerationOptions(
-                        Token.GetLocation(),
-                        options: await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false)),
+                    new CodeGenerationContext(Token.GetLocation()),
                     cancellationToken).ConfigureAwait(false);
             }
 
@@ -654,9 +652,7 @@ private async Task<Document> GenerateMemberDelegatingConstructorAsync(
                         preferThrowExpression: false,
                         generateProperties: withProperties,
                         IsContainedInUnsafeType),
-                    new CodeGenerationOptions(
-                        Token.GetLocation(),
-                        options: await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false)),
+                    new CodeGenerationContext(Token.GetLocation()),
                     cancellationToken).ConfigureAwait(false);
             }
         }
diff --git a/src/Features/Core/Portable/GenerateMember/GenerateEnumMember/AbstractGenerateEnumMemberService.CodeAction.cs b/src/Features/Core/Portable/GenerateMember/GenerateEnumMember/AbstractGenerateEnumMemberService.CodeAction.cs
index 42c8153cad85a..4e3ccd73d7e22 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateEnumMember/AbstractGenerateEnumMemberService.CodeAction.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateEnumMember/AbstractGenerateEnumMemberService.CodeAction.cs
@@ -49,7 +49,7 @@ protected override async Task<Document> GetChangedDocumentAsync(CancellationToke
                         name: _state.IdentifierToken.ValueText,
                         hasConstantValue: value != null,
                         constantValue: value),
-                    new CodeGenerationOptions(contextLocation: _state.IdentifierToken.GetLocation()),
+                    new CodeGenerationContext(contextLocation: _state.IdentifierToken.GetLocation()),
                     cancellationToken)
                     .ConfigureAwait(false);
 
diff --git a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.CodeAction.cs b/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.CodeAction.cs
index 964e4e63d9ae8..ac2cc6d29a833 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.CodeAction.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.CodeAction.cs
@@ -64,7 +64,6 @@ private string GetDisplayText(
 
             protected override async Task<Document> GetChangedDocumentAsync(CancellationToken cancellationToken)
             {
-                var syntaxTree = await _document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
                 var syntaxFactory = _document.Project.Solution.Workspace.Services.GetLanguageServices(_state.TypeToGenerateIn.Language).GetService<SyntaxGenerator>();
 
                 if (_generateProperty)
@@ -75,7 +74,7 @@ protected override async Task<Document> GetChangedDocumentAsync(CancellationToke
                         _document.Project.Solution,
                         _state.TypeToGenerateIn,
                         property,
-                        new CodeGenerationOptions(
+                        new CodeGenerationContext(
                             afterThisLocation: _state.IdentifierToken.GetLocation(),
                             generateMethodBodies: _state.TypeToGenerateIn.TypeKind != TypeKind.Interface),
                         cancellationToken)
@@ -91,10 +90,9 @@ protected override async Task<Document> GetChangedDocumentAsync(CancellationToke
                         _document.Project.Solution,
                         _state.TypeToGenerateIn,
                         method,
-                        new CodeGenerationOptions(
+                        new CodeGenerationContext(
                             afterThisLocation: _state.Location,
-                            generateMethodBodies: _state.TypeToGenerateIn.TypeKind != TypeKind.Interface,
-                            parseOptions: syntaxTree.Options),
+                            generateMethodBodies: _state.TypeToGenerateIn.TypeKind != TypeKind.Interface),
                         cancellationToken)
                         .ConfigureAwait(false);
 
diff --git a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.CodeAction.cs b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.CodeAction.cs
index f48f240ceb715..41bd598a11b5f 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.CodeAction.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.CodeAction.cs
@@ -52,11 +52,10 @@ protected override async Task<Document> GetChangedDocumentAsync(CancellationToke
                 var generateUnsafe = _state.TypeMemberType.RequiresUnsafeModifier() &&
                                      !_state.IsContainedInUnsafeType;
 
-                var options = new CodeGenerationOptions(
+                var context = new CodeGenerationContext(
                     afterThisLocation: _state.AfterThisLocation,
                     beforeThisLocation: _state.BeforeThisLocation,
-                    contextLocation: _state.IdentifierToken.GetLocation(),
-                    options: await _semanticDocument.Document.GetOptionsAsync(cancellationToken).ConfigureAwait(false));
+                    contextLocation: _state.IdentifierToken.GetLocation());
 
                 if (_generateProperty)
                 {
@@ -79,7 +78,7 @@ protected override async Task<Document> GetChangedDocumentAsync(CancellationToke
                         setMethod: setAccessor);
 
                     return await CodeGenerator.AddPropertyDeclarationAsync(
-                        solution, _state.TypeToGenerateIn, propertySymbol, options, cancellationToken).ConfigureAwait(false);
+                        solution, _state.TypeToGenerateIn, propertySymbol, context, cancellationToken).ConfigureAwait(false);
                 }
                 else
                 {
@@ -93,7 +92,7 @@ protected override async Task<Document> GetChangedDocumentAsync(CancellationToke
                         name: _state.IdentifierToken.ValueText);
 
                     return await CodeGenerator.AddFieldDeclarationAsync(
-                        solution, _state.TypeToGenerateIn, fieldSymbol, options, cancellationToken).ConfigureAwait(false);
+                        solution, _state.TypeToGenerateIn, fieldSymbol, context, cancellationToken).ConfigureAwait(false);
                 }
             }
 
diff --git a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.GenerateLocalCodeAction.cs b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.GenerateLocalCodeAction.cs
index 27a42fd4da25c..b6ebbe03a1fed 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.GenerateLocalCodeAction.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.GenerateLocalCodeAction.cs
@@ -54,9 +54,9 @@ protected override async Task<Document> GetChangedDocumentAsync(CancellationToke
             private async Task<SyntaxNode> GetNewRootAsync(CancellationToken cancellationToken)
             {
                 var semanticModel = await _document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
-                var documentOptions = await _document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
+                var preferences = await CodeGenerationPreferences.FromDocumentAsync(_document, cancellationToken).ConfigureAwait(false);
 
-                if (_service.TryConvertToLocalDeclaration(_state.LocalType, _state.IdentifierToken, documentOptions, semanticModel, cancellationToken, out var newRoot))
+                if (_service.TryConvertToLocalDeclaration(_state.LocalType, _state.IdentifierToken, semanticModel, cancellationToken, out var newRoot))
                 {
                     return newRoot;
                 }
@@ -73,10 +73,13 @@ private async Task<SyntaxNode> GetNewRootAsync(CancellationToken cancellationTok
                 var codeGenService = _document.GetLanguageService<ICodeGenerationService>();
                 var root = _state.IdentifierToken.GetAncestors<SyntaxNode>().Last();
 
+                var options = preferences.GetOptions(
+                    new CodeGenerationContext(beforeThisLocation: _state.IdentifierToken.GetLocation()));
+
                 return codeGenService.AddStatements(
                     root,
                     SpecializedCollections.SingletonEnumerable(localStatement),
-                    options: new CodeGenerationOptions(beforeThisLocation: _state.IdentifierToken.GetLocation()),
+                    options,
                     cancellationToken: cancellationToken);
             }
         }
diff --git a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.cs b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.cs
index 3b22a3fa641d7..8be2945aee95d 100644
--- a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.cs
+++ b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.cs
@@ -33,7 +33,7 @@ protected AbstractGenerateVariableService()
         protected abstract bool TryInitializeExplicitInterfaceState(SemanticDocument document, SyntaxNode node, CancellationToken cancellationToken, out SyntaxToken identifierToken, out IPropertySymbol propertySymbol, out INamedTypeSymbol typeToGenerateIn);
         protected abstract bool TryInitializeIdentifierNameState(SemanticDocument document, TSimpleNameSyntax identifierName, CancellationToken cancellationToken, out SyntaxToken identifierToken, out TExpressionSyntax simpleNameOrMemberAccessExpression, out bool isInExecutableBlock, out bool isinConditionalAccessExpression);
 
-        protected abstract bool TryConvertToLocalDeclaration(ITypeSymbol type, SyntaxToken identifierToken, OptionSet options, SemanticModel semanticModel, CancellationToken cancellationToken, out SyntaxNode newRoot);
+        protected abstract bool TryConvertToLocalDeclaration(ITypeSymbol type, SyntaxToken identifierToken, SemanticModel semanticModel, CancellationToken cancellationToken, out SyntaxNode newRoot);
 
         public async Task<ImmutableArray<CodeAction>> GenerateVariableAsync(
             Document document,
diff --git a/src/Features/Core/Portable/GenerateOverrides/GenerateOverridesWithDialogCodeAction.cs b/src/Features/Core/Portable/GenerateOverrides/GenerateOverridesWithDialogCodeAction.cs
index 99ab655fd829c..101eec10fb902 100644
--- a/src/Features/Core/Portable/GenerateOverrides/GenerateOverridesWithDialogCodeAction.cs
+++ b/src/Features/Core/Portable/GenerateOverrides/GenerateOverridesWithDialogCodeAction.cs
@@ -76,10 +76,9 @@ protected override async Task<IEnumerable<CodeActionOperation>> ComputeOperation
                     _document.Project.Solution,
                     _containingType,
                     members,
-                    new CodeGenerationOptions(
+                    new CodeGenerationContext(
                         afterThisLocation: afterThisLocation,
-                        contextLocation: syntaxTree.GetLocation(_textSpan),
-                        options: await _document.GetOptionsAsync(cancellationToken).ConfigureAwait(false)),
+                        contextLocation: syntaxTree.GetLocation(_textSpan)),
                     cancellationToken).ConfigureAwait(false);
 
                 return new CodeActionOperation[]
diff --git a/src/Features/Core/Portable/GenerateType/AbstractGenerateTypeService.Editor.cs b/src/Features/Core/Portable/GenerateType/AbstractGenerateTypeService.Editor.cs
index 3845df9ac7c9d..0a34d81af7323 100644
--- a/src/Features/Core/Portable/GenerateType/AbstractGenerateTypeService.Editor.cs
+++ b/src/Features/Core/Portable/GenerateType/AbstractGenerateTypeService.Editor.cs
@@ -294,7 +294,7 @@ private async Task<IEnumerable<CodeActionOperation>> GetGenerateInNewFileOperati
                     newSolution,
                     enclosingNamespace,
                     rootNamespaceOrType,
-                    new CodeGenerationOptions(newSemanticModel.SyntaxTree.GetLocation(new TextSpan())),
+                    new CodeGenerationContext(newSemanticModel.SyntaxTree.GetLocation(new TextSpan())),
                     _cancellationToken).ConfigureAwait(false);
 
                 // containers is determined to be
@@ -387,9 +387,7 @@ private async Task<IEnumerable<CodeActionOperation>> GetGenerateIntoContainingNa
                     solution,
                     enclosingNamespace,
                     namedType,
-                    new CodeGenerationOptions(
-                        afterThisLocation: _semanticDocument.SyntaxTree.GetLocation(_state.SimpleName.Span),
-                        options: await _semanticDocument.Document.GetOptionsAsync(_cancellationToken).ConfigureAwait(false)),
+                    new CodeGenerationContext(afterThisLocation: _semanticDocument.SyntaxTree.GetLocation(_state.SimpleName.Span)),
                     _cancellationToken).ConfigureAwait(false);
 
                 return new CodeActionOperation[] { new ApplyChangesOperation(codeGenResult.Project.Solution) };
@@ -434,7 +432,7 @@ private async Task<IEnumerable<CodeActionOperation>> GetGenerateIntoExistingDocu
                     solution,
                     enclosingNamespaceGeneratedTypeToAddAndLocation.Item1,
                     enclosingNamespaceGeneratedTypeToAddAndLocation.Item2,
-                    new CodeGenerationOptions(afterThisLocation: enclosingNamespaceGeneratedTypeToAddAndLocation.Item3),
+                    new CodeGenerationContext(afterThisLocation: enclosingNamespaceGeneratedTypeToAddAndLocation.Item3),
                     _cancellationToken).ConfigureAwait(false);
                 var newRoot = await codeGenResult.GetSyntaxRootAsync(_cancellationToken).ConfigureAwait(false);
                 var updatedSolution = solution.WithDocumentSyntaxRoot(generateTypeOptionsResult.ExistingDocument.Id, newRoot, PreservationMode.PreserveIdentity);
@@ -548,7 +546,7 @@ private async Task<IEnumerable<CodeActionOperation>> GetGenerateIntoTypeOperatio
                     solution,
                     _state.TypeToGenerateInOpt,
                     namedType,
-                    new CodeGenerationOptions(contextLocation: _state.SimpleName.GetLocation()),
+                    new CodeGenerationContext(contextLocation: _state.SimpleName.GetLocation()),
                     _cancellationToken)
                     .ConfigureAwait(false);
 
diff --git a/src/Features/Core/Portable/ImplementAbstractClass/ImplementAbstractClassData.cs b/src/Features/Core/Portable/ImplementAbstractClass/ImplementAbstractClassData.cs
index fd78fc5a477c8..b6f3e094d41e3 100644
--- a/src/Features/Core/Portable/ImplementAbstractClass/ImplementAbstractClassData.cs
+++ b/src/Features/Core/Portable/ImplementAbstractClass/ImplementAbstractClassData.cs
@@ -105,16 +105,19 @@ public async Task<Document> ImplementAbstractClassAsync(
                         FeaturesResources.Base_classes_contain_inaccessible_unimplemented_members)));
             }
 
-            var options = await _document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
-            var updatedClassNode = CodeGenerator.AddMemberDeclarations(
+            var context = new CodeGenerationContext(
+                contextLocation: classNodeToAddMembersTo.GetLocation(),
+                autoInsertionLocation: groupMembers,
+                sortMembers: groupMembers);
+
+            var codeGenerator = _document.GetRequiredLanguageService<ICodeGenerationService>();
+            var options = await CodeGenerationOptions.FromDocumentAsync(context, _document, cancellationToken).ConfigureAwait(false);
+
+            var updatedClassNode = codeGenerator.AddMembers(
                 classNodeToAddMembersTo,
                 memberDefinitions,
-                _document.Project.Solution.Workspace,
-                new CodeGenerationOptions(
-                    contextLocation: classNodeToAddMembersTo.GetLocation(),
-                    autoInsertionLocation: groupMembers,
-                    sortMembers: groupMembers,
-                    options: options));
+                options,
+                cancellationToken);
 
             var root = await _document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             var newRoot = root.ReplaceNode(_classNode, updatedClassNode);
diff --git a/src/Features/Core/Portable/ImplementInterface/AbstractImplementInterfaceService.CodeAction.cs b/src/Features/Core/Portable/ImplementInterface/AbstractImplementInterfaceService.CodeAction.cs
index 8b1dce2749de2..359183f3815c6 100644
--- a/src/Features/Core/Portable/ImplementInterface/AbstractImplementInterfaceService.CodeAction.cs
+++ b/src/Features/Core/Portable/ImplementInterface/AbstractImplementInterfaceService.CodeAction.cs
@@ -208,13 +208,13 @@ protected async Task<Document> GetUpdatedDocumentAsync(
                     Options.InsertionBehavior == ImplementTypeInsertionBehavior.WithOtherMembersOfTheSameKind;
 
                 return await CodeGenerator.AddMemberDeclarationsAsync(
-                    result.Project.Solution, classOrStructType,
+                    result.Project.Solution,
+                    classOrStructType,
                     memberDefinitions.Concat(extraMembers),
-                    new CodeGenerationOptions(
+                    new CodeGenerationContext(
                         contextLocation: classOrStructDecl.GetLocation(),
                         autoInsertionLocation: groupMembers,
-                        sortMembers: groupMembers,
-                        options: await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false)),
+                        sortMembers: groupMembers),
                     cancellationToken).ConfigureAwait(false);
             }
 
diff --git a/src/Features/Core/Portable/ImplementInterface/AbstractImplementInterfaceService.DisposePatternCodeAction.cs b/src/Features/Core/Portable/ImplementInterface/AbstractImplementInterfaceService.DisposePatternCodeAction.cs
index ccc4517226375..860c90e995a1b 100644
--- a/src/Features/Core/Portable/ImplementInterface/AbstractImplementInterfaceService.DisposePatternCodeAction.cs
+++ b/src/Features/Core/Portable/ImplementInterface/AbstractImplementInterfaceService.DisposePatternCodeAction.cs
@@ -151,15 +151,20 @@ public override async Task<Document> GetUpdatedDocumentAsync(
                 var firstGeneratedMember = rootWithCoreMembers.GetAnnotatedNodes(CodeGenerator.Annotation).First();
                 var typeDeclarationWithCoreMembers = firstGeneratedMember.Parent!;
 
-                var typeDeclarationWithAllMembers = CodeGenerator.AddMemberDeclarations(
+                var codeGenerator = document.GetRequiredLanguageService<ICodeGenerationService>();
+
+                var context = new CodeGenerationContext(
+                    addImports: false,
+                    sortMembers: false,
+                    autoInsertionLocation: false);
+
+                var codeGenerationOptions = await CodeGenerationOptions.FromDocumentAsync(context, document, cancellationToken).ConfigureAwait(false);
+
+                var typeDeclarationWithAllMembers = codeGenerator.AddMembers(
                     typeDeclarationWithCoreMembers,
                     disposableMethods,
-                    document.Project.Solution.Workspace,
-                    new CodeGenerationOptions(
-                        addImports: false,
-                        parseOptions: rootWithCoreMembers.SyntaxTree.Options,
-                        sortMembers: false,
-                        autoInsertionLocation: false));
+                    codeGenerationOptions,
+                    cancellationToken);
 
                 var docWithAllMembers = docWithCoreMembers.WithSyntaxRoot(
                     rootWithCoreMembers.ReplaceNode(
@@ -291,12 +296,16 @@ private IMethodSymbol CreateDisposeInterfaceMethod(
                             g.Argument(DisposingName, RefKind.None, g.TrueLiteralExpression())))));
 
                 // GC.SuppressFinalize(this);
-                statements.Add(g.ExpressionStatement(
-                    g.InvocationExpression(
-                        g.MemberAccessExpression(
-                            g.TypeExpression(compilation.GetTypeByMetadataName(typeof(GC).FullName!)),
-                            nameof(GC.SuppressFinalize)),
-                        g.ThisExpression())));
+                var gcType = compilation.GetTypeByMetadataName(typeof(GC).FullName!);
+                if (gcType != null)
+                {
+                    statements.Add(g.ExpressionStatement(
+                        g.InvocationExpression(
+                            g.MemberAccessExpression(
+                                g.TypeExpression(gcType),
+                                nameof(GC.SuppressFinalize)),
+                            g.ThisExpression())));
+                }
 
                 var modifiers = DeclarationModifiers.From(disposeMethod);
                 modifiers = modifiers.WithIsAbstract(false);
diff --git a/src/Features/Core/Portable/InitializeParameter/AbstractAddParameterCheckCodeRefactoringProvider.cs b/src/Features/Core/Portable/InitializeParameter/AbstractAddParameterCheckCodeRefactoringProvider.cs
index 21c83ad5ae0dd..05e60c40b28be 100644
--- a/src/Features/Core/Portable/InitializeParameter/AbstractAddParameterCheckCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/InitializeParameter/AbstractAddParameterCheckCodeRefactoringProvider.cs
@@ -383,7 +383,7 @@ private async Task<Document> AddNullCheckStatementAsync(
             var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
-            var editor = new SyntaxEditor(root, document.Project.Solution.Workspace);
+            var editor = new SyntaxEditor(root, document.Project.Solution.Workspace.Services);
             var nullCheckStatement = generateNullCheck(semanticModel, editor.Generator);
 
             // We may be inserting a statement into a single-line container.  In that case,
diff --git a/src/Features/Core/Portable/InitializeParameter/AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs b/src/Features/Core/Portable/InitializeParameter/AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs
index 87079e49d8f8e..fd740fa47435a 100644
--- a/src/Features/Core/Portable/InitializeParameter/AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs
+++ b/src/Features/Core/Portable/InitializeParameter/AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs
@@ -422,11 +422,12 @@ private async Task<Document> AddSingleSymbolInitializationAsync(
             ISymbol fieldOrProperty,
             CancellationToken cancellationToken)
         {
-            var workspace = document.Project.Solution.Workspace;
+            var services = document.Project.Solution.Workspace.Services;
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-            var editor = new SyntaxEditor(root, workspace);
+            var editor = new SyntaxEditor(root, services);
             var generator = editor.Generator;
-            var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
+            var preferences = await CodeGenerationPreferences.FromDocumentAsync(document, cancellationToken).ConfigureAwait(false);
+            var codeGenerator = document.GetRequiredLanguageService<ICodeGenerationService>();
 
             if (fieldOrProperty.ContainingType == null)
             {
@@ -450,15 +451,17 @@ private async Task<Document> AddSingleSymbolInitializationAsync(
                     {
                         if (fieldOrProperty is IPropertySymbol property)
                         {
-                            return CodeGenerator.AddPropertyDeclaration(
-                                currentTypeDecl, property, workspace,
-                                GetAddOptions<IPropertySymbol>(parameter, blockStatementOpt, typeDeclaration, options, cancellationToken));
+                            return codeGenerator.AddProperty(
+                                currentTypeDecl, property,
+                                preferences.GetOptions(GetAddContext<IPropertySymbol>(parameter, blockStatementOpt, typeDeclaration, cancellationToken)),
+                                cancellationToken);
                         }
                         else if (fieldOrProperty is IFieldSymbol field)
                         {
-                            return CodeGenerator.AddFieldDeclaration(
-                                currentTypeDecl, field, workspace,
-                                GetAddOptions<IFieldSymbol>(parameter, blockStatementOpt, typeDeclaration, options, cancellationToken));
+                            return codeGenerator.AddField(
+                                currentTypeDecl, field,
+                                preferences.GetOptions(GetAddContext<IFieldSymbol>(parameter, blockStatementOpt, typeDeclaration, cancellationToken)),
+                                cancellationToken);
                         }
                         else
                         {
@@ -486,15 +489,15 @@ private async Task<Document> AddSingleSymbolInitializationAsync(
             return document.WithSyntaxRoot(editor.GetChangedRoot());
         }
 
-        private static CodeGenerationOptions GetAddOptions<TSymbol>(
-            IParameterSymbol parameter, IBlockOperation? blockStatementOpt,
-            SyntaxNode typeDeclaration, OptionSet options, CancellationToken cancellationToken)
+        private static CodeGenerationContext GetAddContext<TSymbol>(
+            IParameterSymbol parameter, IBlockOperation? blockStatement,
+            SyntaxNode typeDeclaration, CancellationToken cancellationToken)
             where TSymbol : ISymbol
         {
             foreach (var (sibling, before) in GetSiblingParameters(parameter))
             {
                 var statement = TryFindFieldOrPropertyAssignmentStatement(
-                    sibling, blockStatementOpt, out var fieldOrProperty);
+                    sibling, blockStatement, out var fieldOrProperty);
 
                 if (statement != null &&
                     fieldOrProperty is TSymbol symbol)
@@ -506,19 +509,19 @@ private static CodeGenerationOptions GetAddOptions<TSymbol>(
                         {
                             // Found an existing field/property that corresponds to a preceding parameter.
                             // Place ourselves directly after it.
-                            return new CodeGenerationOptions(afterThisLocation: symbolSyntax.GetLocation(), options: options);
+                            return new CodeGenerationContext(afterThisLocation: symbolSyntax.GetLocation());
                         }
                         else
                         {
                             // Found an existing field/property that corresponds to a following parameter.
                             // Place ourselves directly before it.
-                            return new CodeGenerationOptions(beforeThisLocation: symbolSyntax.GetLocation(), options: options);
+                            return new CodeGenerationContext(beforeThisLocation: symbolSyntax.GetLocation());
                         }
                     }
                 }
             }
 
-            return new CodeGenerationOptions(options: options);
+            return CodeGenerationContext.Default;
         }
 
         private static ImmutableArray<(IParameterSymbol parameter, bool before)> GetSiblingParameters(IParameterSymbol parameter)
diff --git a/src/Features/Core/Portable/IntroduceVariable/AbstractIntroduceParameterDocumentRewriter.cs b/src/Features/Core/Portable/IntroduceVariable/AbstractIntroduceParameterDocumentRewriter.cs
index 53c8610ad3170..b3d4dd35fc439 100644
--- a/src/Features/Core/Portable/IntroduceVariable/AbstractIntroduceParameterDocumentRewriter.cs
+++ b/src/Features/Core/Portable/IntroduceVariable/AbstractIntroduceParameterDocumentRewriter.cs
@@ -449,12 +449,14 @@ private async Task<SyntaxNode> CreateMethodDeclarationAsync(SyntaxNode newStatem
                 string? newMethodIdentifier, ITypeSymbol? typeSymbol, bool isTrampoline, CancellationToken cancellationToken)
             {
                 var codeGenerationService = _originalDocument.GetRequiredLanguageService<ICodeGenerationService>();
-                var options = await _originalDocument.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
+                var codeGenOptions = await CodeGenerationOptions.FromDocumentAsync(CodeGenerationContext.Default, _originalDocument, cancellationToken).ConfigureAwait(false);
 
                 var newMethod = isTrampoline
                     ? CodeGenerationSymbolFactory.CreateMethodSymbol(_methodSymbol, name: newMethodIdentifier, parameters: validParameters, statements: ImmutableArray.Create(newStatement), returnType: typeSymbol)
                     : CodeGenerationSymbolFactory.CreateMethodSymbol(_methodSymbol, statements: ImmutableArray.Create(newStatement), containingType: _methodSymbol.ContainingType);
-                var newMethodDeclaration = codeGenerationService.CreateMethodDeclaration(newMethod, options: new CodeGenerationOptions(options: options, parseOptions: _expression.SyntaxTree.Options));
+
+                var newMethodDeclaration = codeGenerationService.CreateMethodDeclaration(newMethod, CodeGenerationDestination.Unspecified, codeGenOptions, cancellationToken);
+                Contract.ThrowIfNull(newMethodDeclaration);
                 return newMethodDeclaration;
             }
 
diff --git a/src/Features/Core/Portable/InvertConditional/AbstractInvertConditionalCodeRefactoringProvider.cs b/src/Features/Core/Portable/InvertConditional/AbstractInvertConditionalCodeRefactoringProvider.cs
index 84a20c63a83ef..59da6609cc87e 100644
--- a/src/Features/Core/Portable/InvertConditional/AbstractInvertConditionalCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/InvertConditional/AbstractInvertConditionalCodeRefactoringProvider.cs
@@ -48,7 +48,7 @@ private static async Task<Document> InvertConditionalAsync(
             var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
-            var editor = new SyntaxEditor(root, document.Project.Solution.Workspace);
+            var editor = new SyntaxEditor(root, document.Project.Solution.Workspace.Services);
 
             editor.Generator.SyntaxFacts.GetPartsOfConditionalExpression(conditional,
                 out var condition, out var whenTrue, out var whenFalse);
diff --git a/src/Features/Core/Portable/MakeMethodSynchronous/AbstractMakeMethodSynchronousCodeFixProvider.cs b/src/Features/Core/Portable/MakeMethodSynchronous/AbstractMakeMethodSynchronousCodeFixProvider.cs
index 1d05148dcdcbe..9cc95a4149a76 100644
--- a/src/Features/Core/Portable/MakeMethodSynchronous/AbstractMakeMethodSynchronousCodeFixProvider.cs
+++ b/src/Features/Core/Portable/MakeMethodSynchronous/AbstractMakeMethodSynchronousCodeFixProvider.cs
@@ -164,7 +164,7 @@ private static async Task<Solution> RemoveAwaitFromCallersAsync(
             var syntaxFactsService = document.GetLanguageService<ISyntaxFactsService>();
             var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
-            var editor = new SyntaxEditor(root, currentSolution.Workspace);
+            var editor = new SyntaxEditor(root, currentSolution.Workspace.Services);
 
             foreach (var location in group)
             {
diff --git a/src/Features/Core/Portable/MetadataAsSource/AbstractMetadataAsSourceService.cs b/src/Features/Core/Portable/MetadataAsSource/AbstractMetadataAsSourceService.cs
index 7a8ecdfd63b06..3886be3109624 100644
--- a/src/Features/Core/Portable/MetadataAsSource/AbstractMetadataAsSourceService.cs
+++ b/src/Features/Core/Portable/MetadataAsSource/AbstractMetadataAsSourceService.cs
@@ -34,14 +34,19 @@ public async Task<Document> AddSourceToAsync(Document document, Compilation symb
             var newSemanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
             var rootNamespace = newSemanticModel.GetEnclosingNamespace(0, cancellationToken);
 
-            var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
+            var context = new CodeGenerationContext(
+                contextLocation: newSemanticModel.SyntaxTree.GetLocation(new TextSpan()),
+                generateMethodBodies: false,
+                generateDocumentationComments: true,
+                mergeAttributes: false,
+                autoInsertionLocation: false);
 
             // Add the interface of the symbol to the top of the root namespace
             document = await CodeGenerator.AddNamespaceOrTypeDeclarationAsync(
                 document.Project.Solution,
                 rootNamespace,
                 CreateCodeGenerationSymbol(document, symbol),
-                CreateCodeGenerationOptions(newSemanticModel.SyntaxTree.GetLocation(new TextSpan()), options),
+                context,
                 cancellationToken).ConfigureAwait(false);
 
             document = await AddNullableRegionsAsync(document, cancellationToken).ConfigureAwait(false);
@@ -101,16 +106,5 @@ private static INamespaceOrTypeSymbol CreateCodeGenerationSymbol(Document docume
                     null,
                     new[] { wrappedType });
         }
-
-        private static CodeGenerationOptions CreateCodeGenerationOptions(Location contextLocation, OptionSet options)
-        {
-            return new CodeGenerationOptions(
-                contextLocation: contextLocation,
-                generateMethodBodies: false,
-                generateDocumentationComments: true,
-                mergeAttributes: false,
-                autoInsertionLocation: false,
-                options: options);
-        }
     }
 }
diff --git a/src/Features/Core/Portable/PullMemberUp/MembersPuller.cs b/src/Features/Core/Portable/PullMemberUp/MembersPuller.cs
index d8448d3a7fb57..751ccf51cc452 100644
--- a/src/Features/Core/Portable/PullMemberUp/MembersPuller.cs
+++ b/src/Features/Core/Portable/PullMemberUp/MembersPuller.cs
@@ -15,6 +15,7 @@
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.LanguageServices;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.PullMemberUp;
 using Microsoft.CodeAnalysis.RemoveUnnecessaryImports;
@@ -93,20 +94,23 @@ private static async Task<Solution> PullMembersIntoInterfaceAsync(
             var solutionEditor = new SolutionEditor(solution);
             var codeGenerationService = document.Project.LanguageServices.GetRequiredService<ICodeGenerationService>();
             var destinationSyntaxNode = await codeGenerationService.FindMostRelevantNameSpaceOrTypeDeclarationAsync(
-                solution, pullMemberUpOptions.Destination, options: null, cancellationToken).ConfigureAwait(false);
+                solution, pullMemberUpOptions.Destination, CodeGenerationContext.Default, cancellationToken).ConfigureAwait(false);
             var symbolToDeclarationsMap = await InitializeSymbolToDeclarationsMapAsync(pullMemberUpOptions, cancellationToken).ConfigureAwait(false);
             var symbolsToPullUp = pullMemberUpOptions.MemberAnalysisResults.
                 SelectAsArray(analysisResult => GetSymbolsToPullUp(analysisResult));
 
-            // Add members to interface
-            var codeGenerationOptions = new CodeGenerationOptions(
-                generateMethodBodies: false,
-                generateMembers: false,
-                options: await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false));
-            var destinationWithMembersAdded = codeGenerationService.AddMembers(destinationSyntaxNode, symbolsToPullUp, options: codeGenerationOptions, cancellationToken: cancellationToken);
             var destinationEditor = await solutionEditor.GetDocumentEditorAsync(
                 solution.GetDocumentId(destinationSyntaxNode.SyntaxTree),
                 cancellationToken).ConfigureAwait(false);
+
+            // Add members to interface
+            var context = new CodeGenerationContext(
+                generateMethodBodies: false,
+                generateMembers: false);
+
+            var codeGenerationOptions = await CodeGenerationOptions.FromDocumentAsync(context, destinationEditor.OriginalDocument, cancellationToken).ConfigureAwait(false);
+            var destinationWithMembersAdded = codeGenerationService.AddMembers(destinationSyntaxNode, symbolsToPullUp, codeGenerationOptions, cancellationToken);
+
             destinationEditor.ReplaceNode(destinationSyntaxNode, (syntaxNode, generator) => destinationWithMembersAdded);
 
             // Change original members
@@ -130,7 +134,8 @@ private static async Task<Solution> PullMembersIntoInterfaceAsync(
                         {
                             ChangeMemberToPublicAndNonStatic(
                                 codeGenerationService, originalMemberEditor,
-                                declaration, analysisResult.Member);
+                                declaration, analysisResult.Member,
+                                codeGenerationOptions, cancellationToken);
                         }
                     }
                 }
@@ -174,7 +179,9 @@ private static void ChangeMemberToPublicAndNonStatic(
             ICodeGenerationService codeGenerationService,
             DocumentEditor editor,
             SyntaxNode memberDeclaration,
-            ISymbol member)
+            ISymbol member,
+            CodeGenerationOptions options,
+            CancellationToken cancellationToken)
         {
             var modifiers = DeclarationModifiers.From(member).WithIsStatic(false);
             // Event is different since several events may be declared in one line.
@@ -185,7 +192,9 @@ private static void ChangeMemberToPublicAndNonStatic(
                     editor,
                     eventSymbol,
                     memberDeclaration,
-                    modifiers);
+                    modifiers,
+                    options,
+                    cancellationToken);
             }
             else
             {
@@ -199,7 +208,9 @@ private static void ChangeEventToPublicAndNonStatic(
             DocumentEditor editor,
             IEventSymbol eventSymbol,
             SyntaxNode eventDeclaration,
-            DeclarationModifiers modifiers)
+            DeclarationModifiers modifiers,
+            CodeGenerationOptions options,
+            CancellationToken cancellationToken)
         {
             var declaration = editor.Generator.GetDeclaration(eventDeclaration);
             var isEventHasExplicitAddOrRemoveMethod =
@@ -219,8 +230,9 @@ private static void ChangeEventToPublicAndNonStatic(
                     eventSymbol,
                     accessibility: Accessibility.Public,
                     modifiers: modifiers);
-                var options = new CodeGenerationOptions(generateMethodBodies: false);
-                var publicAndNonStaticSyntax = codeGenerationService.CreateEventDeclaration(publicAndNonStaticSymbol, destination: CodeGenerationDestination.ClassType, options: options);
+
+                var eventGenerationOptions = options.WithContext(new CodeGenerationContext(generateMethodBodies: false));
+                var publicAndNonStaticSyntax = codeGenerationService.CreateEventDeclaration(publicAndNonStaticSymbol, CodeGenerationDestination.ClassType, eventGenerationOptions, cancellationToken);
                 // Insert a new declaration and remove the original declaration
                 editor.InsertAfter(declaration, publicAndNonStaticSyntax);
                 editor.RemoveNode(eventDeclaration);
@@ -241,9 +253,12 @@ private static async Task<Solution> PullMembersIntoClassAsync(
         {
             var solutionEditor = new SolutionEditor(solution);
             var codeGenerationService = document.Project.LanguageServices.GetRequiredService<ICodeGenerationService>();
+
             var destinationSyntaxNode = await codeGenerationService.FindMostRelevantNameSpaceOrTypeDeclarationAsync(
-                solution, result.Destination, options: null, cancellationToken).ConfigureAwait(false);
+                solution, result.Destination, CodeGenerationContext.Default, cancellationToken).ConfigureAwait(false);
+
             var symbolToDeclarations = await InitializeSymbolToDeclarationsMapAsync(result, cancellationToken).ConfigureAwait(false);
+
             // Add members to destination
             var pullUpMembersSymbols = result.MemberAnalysisResults.SelectAsArray(
                 memberResult =>
@@ -258,11 +273,11 @@ private static async Task<Solution> PullMembersIntoClassAsync(
                         return memberResult.Member;
                     }
                 });
-            var options = new CodeGenerationOptions(
-                reuseSyntax: true,
-                generateMethodBodies: false,
-                options: await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false));
-            var newDestination = codeGenerationService.AddMembers(destinationSyntaxNode, pullUpMembersSymbols, options: options, cancellationToken: cancellationToken);
+
+            var context = new CodeGenerationContext(reuseSyntax: true, generateMethodBodies: false);
+            var options = await CodeGenerationOptions.FromDocumentAsync(context, document, cancellationToken).ConfigureAwait(false);
+
+            var newDestination = codeGenerationService.AddMembers(destinationSyntaxNode, pullUpMembersSymbols, options, cancellationToken);
 
             using var _ = PooledHashSet<SyntaxNode>.GetInstance(out var sourceImports);
             var destinationEditor = await solutionEditor.GetDocumentEditorAsync(
@@ -332,7 +347,7 @@ private static async Task<Solution> PullMembersIntoClassAsync(
                 node.GetCurrentNode(newDestination),
                 sourceImports,
                 generator,
-                options.Options,
+                options.Preferences,
                 destinationEditor.OriginalDocument.CanAddImportsInHiddenRegions(),
                 cancellationToken));
 
diff --git a/src/Features/Core/Portable/ReplaceMethodWithProperty/ReplaceMethodWithPropertyCodeRefactoringProvider.cs b/src/Features/Core/Portable/ReplaceMethodWithProperty/ReplaceMethodWithPropertyCodeRefactoringProvider.cs
index d14449726a7b1..8ef9f76dd1c26 100644
--- a/src/Features/Core/Portable/ReplaceMethodWithProperty/ReplaceMethodWithPropertyCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/ReplaceMethodWithProperty/ReplaceMethodWithPropertyCodeRefactoringProvider.cs
@@ -220,7 +220,7 @@ private async Task<Solution> UpdateReferencesInDocumentAsync(
         {
             var root = await originalDocument.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
-            var editor = new SyntaxEditor(root, originalDocument.Project.Solution.Workspace);
+            var editor = new SyntaxEditor(root, originalDocument.Project.Solution.Workspace.Services);
             var service = originalDocument.GetRequiredLanguageService<IReplaceMethodWithPropertyService>();
 
             ReplaceGetReferences(propertyName, nameChanged, getReferences, root, editor, service, cancellationToken);
@@ -363,7 +363,7 @@ private static async Task<Solution> ReplaceGetMethodsAndRemoveSetMethodsAsync(
             var syntaxTree = await updatedDocument.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
             var root = await updatedDocument.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
-            var editor = new SyntaxEditor(root, updatedSolution.Workspace);
+            var editor = new SyntaxEditor(root, updatedSolution.Workspace.Services);
 
             var documentOptions = await updatedDocument.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
             var parseOptions = syntaxTree.Options;
diff --git a/src/Features/Core/Portable/ReplacePropertyWithMethods/ReplacePropertyWithMethodsCodeRefactoringProvider.cs b/src/Features/Core/Portable/ReplacePropertyWithMethods/ReplacePropertyWithMethodsCodeRefactoringProvider.cs
index 6895ed758e1fa..85179d5c155d0 100644
--- a/src/Features/Core/Portable/ReplacePropertyWithMethods/ReplacePropertyWithMethodsCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/ReplacePropertyWithMethods/ReplacePropertyWithMethodsCodeRefactoringProvider.cs
@@ -224,7 +224,7 @@ private async Task<Solution> UpdateReferencesInDocumentAsync(
         {
             var root = await originalDocument.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
-            var editor = new SyntaxEditor(root, originalDocument.Project.Solution.Workspace);
+            var editor = new SyntaxEditor(root, originalDocument.Project.Solution.Workspace.Services);
             var service = originalDocument.GetRequiredLanguageService<IReplacePropertyWithMethodsService>();
 
             await ReplaceReferencesAsync(
@@ -357,7 +357,7 @@ private static async Task<Solution> ReplaceDefinitionsWithMethodsAsync(
 
             var root = await updatedDocument.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
-            var editor = new SyntaxEditor(root, updatedSolution.Workspace);
+            var editor = new SyntaxEditor(root, updatedSolution.Workspace.Services);
 
             // First replace all the properties with the appropriate getters/setters.
             foreach (var (property, declaration) in currentDefinitions)
diff --git a/src/Features/Core/Portable/Shared/Utilities/ExtractTypeHelpers.cs b/src/Features/Core/Portable/Shared/Utilities/ExtractTypeHelpers.cs
index 2e6141c97953a..f61368657e11f 100644
--- a/src/Features/Core/Portable/Shared/Utilities/ExtractTypeHelpers.cs
+++ b/src/Features/Core/Portable/Shared/Utilities/ExtractTypeHelpers.cs
@@ -29,13 +29,13 @@ internal static class ExtractTypeHelpers
         {
             var originalRoot = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             var typeDeclaration = originalRoot.GetAnnotatedNodes(symbolMapping.TypeNodeAnnotation).Single();
-            var editor = new SyntaxEditor(originalRoot, symbolMapping.AnnotatedSolution.Workspace);
+            var editor = new SyntaxEditor(originalRoot, symbolMapping.AnnotatedSolution.Workspace.Services);
+
+            var context = new CodeGenerationContext(generateMethodBodies: true);
+            var options = await CodeGenerationOptions.FromDocumentAsync(context, document, cancellationToken).ConfigureAwait(false);
 
-            var options = new CodeGenerationOptions(
-                generateMethodBodies: true,
-                options: await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false));
             var codeGenService = document.GetRequiredLanguageService<ICodeGenerationService>();
-            var newTypeNode = codeGenService.CreateNamedTypeDeclaration(newType, options: options, cancellationToken: cancellationToken)
+            var newTypeNode = codeGenService.CreateNamedTypeDeclaration(newType, CodeGenerationDestination.Unspecified, options, cancellationToken)
                 .WithAdditionalAnnotations(SimplificationHelpers.SimplifyModuleNameAnnotation);
 
             var typeAnnotation = new SyntaxAnnotation();
@@ -63,10 +63,10 @@ internal static class ExtractTypeHelpers
             var solutionWithInterfaceDocument = solution.AddDocument(newDocumentId, fileName, text: "", folders: folders, filePath: newDocumentPath);
             var newDocument = solutionWithInterfaceDocument.GetRequiredDocument(newDocumentId);
             var newSemanticModel = await newDocument.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
-            var options = new CodeGenerationOptions(
+
+            var context = new CodeGenerationContext(
                 contextLocation: newSemanticModel.SyntaxTree.GetLocation(new TextSpan()),
-                generateMethodBodies: true,
-                options: await newDocument.GetOptionsAsync(cancellationToken).ConfigureAwait(false));
+                generateMethodBodies: true);
 
             // need to remove the root namespace from the containing namespace display because it is implied
             // For C# this does nothing as there is no root namespace (root namespace is empty string)
@@ -84,8 +84,8 @@ internal static class ExtractTypeHelpers
                 newDocument.Project.Solution,
                 newSemanticModel.GetEnclosingNamespace(0, cancellationToken),
                 newSymbol.GenerateRootNamespaceOrType(namespaceParts.ToArray()),
-                options: options,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                context,
+                cancellationToken).ConfigureAwait(false);
 
             var formattingSerivce = newTypeDocument.GetLanguageService<INewDocumentFormattingService>();
             if (formattingSerivce is not null)
diff --git a/src/Features/Core/Portable/UseAutoProperty/AbstractUseAutoPropertyCodeFixProvider.cs b/src/Features/Core/Portable/UseAutoProperty/AbstractUseAutoPropertyCodeFixProvider.cs
index 3e787ff052338..795ebf87b57bf 100644
--- a/src/Features/Core/Portable/UseAutoProperty/AbstractUseAutoPropertyCodeFixProvider.cs
+++ b/src/Features/Core/Portable/UseAutoProperty/AbstractUseAutoPropertyCodeFixProvider.cs
@@ -203,7 +203,7 @@ private async Task<Solution> ProcessResultAsync(CodeFixContext context, Diagnost
                 // Same file.  Have to do this in a slightly complicated fashion.
                 var declaratorTreeRoot = await fieldDocument.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
-                var editor = new SyntaxEditor(declaratorTreeRoot, fieldDocument.Project.Solution.Workspace);
+                var editor = new SyntaxEditor(declaratorTreeRoot, fieldDocument.Project.Solution.Workspace.Services);
                 editor.ReplaceNode(property, updatedProperty);
                 editor.RemoveNode(nodeToRemove, syntaxRemoveOptions);
 
diff --git a/src/Features/VisualBasic/Portable/AddImport/VisualBasicAddImportFeatureService.vb b/src/Features/VisualBasic/Portable/AddImport/VisualBasicAddImportFeatureService.vb
index 225b8c448d7bc..9583478f889dc 100644
--- a/src/Features/VisualBasic/Portable/AddImport/VisualBasicAddImportFeatureService.vb
+++ b/src/Features/VisualBasic/Portable/AddImport/VisualBasicAddImportFeatureService.vb
@@ -7,6 +7,7 @@ Imports System.Threading
 Imports Microsoft.CodeAnalysis.AddImport
 Imports Microsoft.CodeAnalysis.AddImports
 Imports Microsoft.CodeAnalysis.CaseCorrection
+Imports Microsoft.CodeAnalysis.CodeGeneration
 Imports Microsoft.CodeAnalysis.Diagnostics
 Imports Microsoft.CodeAnalysis.Editing
 Imports Microsoft.CodeAnalysis.Formatting
@@ -14,6 +15,7 @@ Imports Microsoft.CodeAnalysis.Host.Mef
 Imports Microsoft.CodeAnalysis.LanguageServices
 Imports Microsoft.CodeAnalysis.Options
 Imports Microsoft.CodeAnalysis.Simplification
+Imports Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.AddImport
@@ -187,7 +189,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.AddImport
 
         Protected Overrides Function GetDescription(
                 document As Document,
-                options As OptionSet,
+                preferences As CodeGenerationPreferences,
                 symbol As INamespaceOrTypeSymbol,
                 semanticModel As SemanticModel,
                 root As SyntaxNode,
@@ -295,13 +297,13 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.AddImport
                 allowInHiddenRegions As Boolean,
                 importsStatement As ImportsStatementSyntax, cancellationToken As CancellationToken) As Task(Of Document)
 
-            Dim options = Await document.GetOptionsAsync(cancellationToken).ConfigureAwait(False)
+            Dim preferences = Await VisualBasicCodeGenerationPreferences.FromDocumentAsync(document, cancellationToken).ConfigureAwait(False)
             Dim compilation = Await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(False)
             Dim importService = document.GetLanguageService(Of IAddImportsService)
             Dim generator = SyntaxGenerator.GetGenerator(document)
 
             Dim root = Await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(False)
-            Dim newRoot = importService.AddImport(compilation, root, contextNode, importsStatement, generator, options, allowInHiddenRegions, cancellationToken)
+            Dim newRoot = importService.AddImport(compilation, root, contextNode, importsStatement, generator, preferences, allowInHiddenRegions, cancellationToken)
             newRoot = newRoot.WithAdditionalAnnotations(CaseCorrector.Annotation, Formatter.Annotation)
             Dim newDocument = document.WithSyntaxRoot(newRoot)
 
diff --git a/src/Features/VisualBasic/Portable/CodeFixes/GenerateEvent/GenerateEventCodeFixProvider.CodeAction.vb b/src/Features/VisualBasic/Portable/CodeFixes/GenerateEvent/GenerateEventCodeFixProvider.CodeAction.vb
index 265d916aeab82..b6ac043fa5026 100644
--- a/src/Features/VisualBasic/Portable/CodeFixes/GenerateEvent/GenerateEventCodeFixProvider.CodeAction.vb
+++ b/src/Features/VisualBasic/Portable/CodeFixes/GenerateEvent/GenerateEventCodeFixProvider.CodeAction.vb
@@ -14,19 +14,16 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.GenerateEvent
             Private ReadOnly _solution As Solution
             Private ReadOnly _targetSymbol As INamedTypeSymbol
             Private ReadOnly _generatedEvent As IEventSymbol
-            Private ReadOnly _codeGenerationOptions As CodeGenerationOptions
             Private ReadOnly _codeGenService As ICodeGenerationService
 
             Public Sub New(solution As Solution,
                     targetSymbol As INamedTypeSymbol,
                     generatedEvent As IEventSymbol,
-                    codeGenService As ICodeGenerationService,
-                    codeGenerationOptions As CodeGenerationOptions)
+                    codeGenService As ICodeGenerationService)
                 _solution = solution
                 _targetSymbol = targetSymbol
                 _generatedEvent = generatedEvent
                 _codeGenService = codeGenService
-                _codeGenerationOptions = codeGenerationOptions
             End Sub
 
             Public Overrides ReadOnly Property Title As String
@@ -38,7 +35,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.GenerateEvent
             Protected Overrides Function GetChangedDocumentAsync(cancellationToken As CancellationToken) As Task(Of Document)
                 Return _codeGenService.AddEventAsync(
                     _solution, _targetSymbol, _generatedEvent,
-                    _codeGenerationOptions, cancellationToken)
+                    CodeGenerationContext.Default, cancellationToken)
             End Function
         End Class
     End Class
diff --git a/src/Features/VisualBasic/Portable/CodeFixes/GenerateEvent/GenerateEventCodeFixProvider.vb b/src/Features/VisualBasic/Portable/CodeFixes/GenerateEvent/GenerateEventCodeFixProvider.vb
index b9c13314614a7..a0837df596ca2 100644
--- a/src/Features/VisualBasic/Portable/CodeFixes/GenerateEvent/GenerateEventCodeFixProvider.vb
+++ b/src/Features/VisualBasic/Portable/CodeFixes/GenerateEvent/GenerateEventCodeFixProvider.vb
@@ -147,9 +147,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.GenerateEvent
             ' instead of an 'As' clause.
             delegateType.AssociatedSymbol = generatedEvent
 
-            Return New GenerateEventCodeAction(
-                document.Project.Solution, targetType, generatedEvent,
-                codeGenService, CodeGenerationOptions.Default)
+            Return New GenerateEventCodeAction(document.Project.Solution, targetType, generatedEvent, codeGenService)
         End Function
 
         Private Shared Function GetHandlerExpression(handlerStatement As AddRemoveHandlerStatementSyntax) As ExpressionSyntax
@@ -298,14 +296,11 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.GenerateEvent
                 ' instead of an 'As' clause.
                 eventHandlerType.AssociatedSymbol = generatedEvent
 
-                Return New GenerateEventCodeAction(
-                        document.Project.Solution, targetType, generatedEvent,
-                        codeGenService, New CodeGenerationOptions())
+                Return New GenerateEventCodeAction(document.Project.Solution, targetType, generatedEvent, codeGenService)
             Else
                 ' Event with no parameters.
                 Dim generatedMember = CodeGenerationSymbolFactory.CreateEventSymbol(boundEvent, name:=actualEventName)
-                Return New GenerateEventCodeAction(
-                    document.Project.Solution, targetType, generatedMember, codeGenService, New CodeGenerationOptions())
+                Return New GenerateEventCodeAction(document.Project.Solution, targetType, generatedMember, codeGenService)
             End If
         End Function
 
@@ -402,7 +397,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.GenerateEvent
 
             Return New GenerateEventCodeAction(
                 document.Project.Solution, originalTargetType, generatedEvent,
-                codeGenService, New CodeGenerationOptions())
+                codeGenService)
         End Function
     End Class
 End Namespace
diff --git a/src/Features/VisualBasic/Portable/ConvertAutoPropertyToFullProperty/VisualBasicConvertAutoPropertyToFullProperty.vb b/src/Features/VisualBasic/Portable/ConvertAutoPropertyToFullProperty/VisualBasicConvertAutoPropertyToFullProperty.vb
index b457cc081cb6e..ae22a97584cee 100644
--- a/src/Features/VisualBasic/Portable/ConvertAutoPropertyToFullProperty/VisualBasicConvertAutoPropertyToFullProperty.vb
+++ b/src/Features/VisualBasic/Portable/ConvertAutoPropertyToFullProperty/VisualBasicConvertAutoPropertyToFullProperty.vb
@@ -5,16 +5,18 @@
 Imports System.Composition
 Imports System.Diagnostics.CodeAnalysis
 Imports System.Threading
+Imports Microsoft.CodeAnalysis.CodeGeneration
 Imports Microsoft.CodeAnalysis.CodeRefactorings
 Imports Microsoft.CodeAnalysis.ConvertAutoPropertyToFullProperty
 Imports Microsoft.CodeAnalysis.Editing
 Imports Microsoft.CodeAnalysis.Options
+Imports Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.ConvertAutoPropertyToFullProperty
     <ExportCodeRefactoringProvider(LanguageNames.VisualBasic, Name:=PredefinedCodeRefactoringProviderNames.ConvertAutoPropertyToFullProperty), [Shared]>
     Friend Class VisualBasicConvertAutoPropertyToFullPropertyCodeRefactoringProvider
-        Inherits AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider(Of PropertyStatementSyntax, TypeBlockSyntax)
+        Inherits AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider(Of PropertyStatementSyntax, TypeBlockSyntax, VisualBasicCodeGenerationPreferences)
 
         Private Const Underscore As String = "_"
 
@@ -32,7 +34,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ConvertAutoPropertyToFullProperty
             Return Task.FromResult(Underscore + propertySymbol.Name)
         End Function
 
-        Friend Overrides Function GetNewAccessors(options As DocumentOptionSet, propertyNode As SyntaxNode,
+        Friend Overrides Function GetNewAccessors(preferences As VisualBasicCodeGenerationPreferences, propertyNode As SyntaxNode,
             fieldName As String, generator As SyntaxGenerator) _
             As (newGetAccessor As SyntaxNode, newSetAccessor As SyntaxNode)
 
@@ -78,7 +80,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ConvertAutoPropertyToFullProperty
             Return DirectCast(propertyNode, PropertyStatementSyntax).Initializer?.Value
         End Function
 
-        Friend Overrides Function ConvertPropertyToExpressionBodyIfDesired(options As DocumentOptionSet, propertyNode As SyntaxNode) As SyntaxNode
+        Friend Overrides Function ConvertPropertyToExpressionBodyIfDesired(preferences As VisualBasicCodeGenerationPreferences, propertyNode As SyntaxNode) As SyntaxNode
             Return propertyNode
         End Function
 
diff --git a/src/Features/VisualBasic/Portable/ConvertForEachToFor/VisualBasicConvertForEachToForCodeRefactoringProvider.vb b/src/Features/VisualBasic/Portable/ConvertForEachToFor/VisualBasicConvertForEachToForCodeRefactoringProvider.vb
index 4fe3f4df930c4..b1841a464dfb1 100644
--- a/src/Features/VisualBasic/Portable/ConvertForEachToFor/VisualBasicConvertForEachToForCodeRefactoringProvider.vb
+++ b/src/Features/VisualBasic/Portable/ConvertForEachToFor/VisualBasicConvertForEachToForCodeRefactoringProvider.vb
@@ -58,7 +58,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ConvertForEachToFor
                     foreachCollectionExpression.GetTrailingTrivia().Where(Function(t) t.IsWhitespaceOrEndOfLine()))
 
             ' and remove all trailing trivia if it is used for cast
-            If foreachInfo.RequireExplicitCastInterface Then
+            If foreachInfo.ExplicitCastInterface IsNot Nothing Then
                 expression = expression.WithoutTrailingTrivia()
             End If
 
diff --git a/src/Features/VisualBasic/Portable/GenerateMember/GenerateVariable/VisualBasicGenerateVariableService.vb b/src/Features/VisualBasic/Portable/GenerateMember/GenerateVariable/VisualBasicGenerateVariableService.vb
index 3fecdf89d2f2c..9e5e70986273c 100644
--- a/src/Features/VisualBasic/Portable/GenerateMember/GenerateVariable/VisualBasicGenerateVariableService.vb
+++ b/src/Features/VisualBasic/Portable/GenerateMember/GenerateVariable/VisualBasicGenerateVariableService.vb
@@ -117,7 +117,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.GenerateMember.GenerateVariable
             Return expression.CanReplaceWithLValue(semanticModel, cancellationToken)
         End Function
 
-        Protected Overrides Function TryConvertToLocalDeclaration(type As ITypeSymbol, identifierToken As SyntaxToken, options As OptionSet, semanticModel As SemanticModel, cancellationToken As CancellationToken, ByRef newRoot As SyntaxNode) As Boolean
+        Protected Overrides Function TryConvertToLocalDeclaration(type As ITypeSymbol, identifierToken As SyntaxToken, semanticModel As SemanticModel, cancellationToken As CancellationToken, ByRef newRoot As SyntaxNode) As Boolean
             Return False
         End Function
     End Class
diff --git a/src/VisualStudio/CSharp/Impl/Snippets/SnippetExpansionClient.cs b/src/VisualStudio/CSharp/Impl/Snippets/SnippetExpansionClient.cs
index 675d19e7d3f99..089069700186b 100644
--- a/src/VisualStudio/CSharp/Impl/Snippets/SnippetExpansionClient.cs
+++ b/src/VisualStudio/CSharp/Impl/Snippets/SnippetExpansionClient.cs
@@ -10,6 +10,7 @@
 using System.Xml.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.AddImports;
+using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.Completion;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
@@ -114,7 +115,7 @@ public override int GetExpansionFunction(IXMLDOMNode xmlFunctionNode, string bst
         }
 
         internal override Document AddImports(
-            Document document, OptionSet options, int position, XElement snippetNode,
+            Document document, CodeGenerationPreferences preferences, int position, XElement snippetNode,
             bool allowInHiddenRegions,
             CancellationToken cancellationToken)
         {
@@ -144,7 +145,7 @@ internal override Document AddImports(
             var addImportService = document.GetRequiredLanguageService<IAddImportsService>();
             var generator = document.GetRequiredLanguageService<SyntaxGenerator>();
             var compilation = document.Project.GetRequiredCompilationAsync(cancellationToken).WaitAndGetResult(cancellationToken);
-            var newRoot = addImportService.AddImports(compilation, root, contextLocation, newUsingDirectives, generator, options, allowInHiddenRegions, cancellationToken);
+            var newRoot = addImportService.AddImports(compilation, root, contextLocation, newUsingDirectives, generator, preferences, allowInHiddenRegions, cancellationToken);
 
             var newDocument = document.WithSyntaxRoot(newRoot);
 
diff --git a/src/VisualStudio/Core/Def/Implementation/Snippets/AbstractSnippetExpansionClient.cs b/src/VisualStudio/Core/Def/Implementation/Snippets/AbstractSnippetExpansionClient.cs
index 8530a8d79a8e7..da8c6917a4513 100644
--- a/src/VisualStudio/Core/Def/Implementation/Snippets/AbstractSnippetExpansionClient.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Snippets/AbstractSnippetExpansionClient.cs
@@ -15,6 +15,7 @@
 using System.Threading.Tasks;
 using System.Xml.Linq;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.Completion;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.SignatureHelp;
@@ -131,7 +132,7 @@ public ImmutableArray<ArgumentProvider> GetArgumentProviders(Workspace workspace
 
         public abstract int GetExpansionFunction(IXMLDOMNode xmlFunctionNode, string bstrFieldName, out IVsExpansionFunction? pFunc);
         protected abstract ITrackingSpan? InsertEmptyCommentAndGetEndPositionTrackingSpan();
-        internal abstract Document AddImports(Document document, OptionSet options, int position, XElement snippetNode, bool allowInHiddenRegions, CancellationToken cancellationToken);
+        internal abstract Document AddImports(Document document, CodeGenerationPreferences preferences, int position, XElement snippetNode, bool allowInHiddenRegions, CancellationToken cancellationToken);
         protected abstract string FallbackDefaultLiteral { get; }
 
         public int FormatSpan(IVsTextLines pBuffer, VsTextSpan[] tsInSurfaceBuffer)
@@ -1052,10 +1053,10 @@ private void AddReferencesAndImports(
                 return;
             }
 
-            var documentOptions = documentWithImports.GetOptionsAsync(cancellationToken).WaitAndGetResult(cancellationToken);
+            var preferences = CodeGenerationPreferences.FromDocumentAsync(documentWithImports, cancellationToken).WaitAndGetResult(cancellationToken);
             var allowInHiddenRegions = documentWithImports.CanAddImportsInHiddenRegions();
 
-            documentWithImports = AddImports(documentWithImports, documentOptions, position, snippetNode, allowInHiddenRegions, cancellationToken);
+            documentWithImports = AddImports(documentWithImports, preferences, position, snippetNode, allowInHiddenRegions, cancellationToken);
             AddReferences(documentWithImports.Project, snippetNode);
         }
 
diff --git a/src/VisualStudio/Core/Def/Implementation/Venus/ContainedLanguageCodeSupport.cs b/src/VisualStudio/Core/Def/Implementation/Venus/ContainedLanguageCodeSupport.cs
index f8569f44fe72d..50bb61eda988f 100644
--- a/src/VisualStudio/Core/Def/Implementation/Venus/ContainedLanguageCodeSupport.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Venus/ContainedLanguageCodeSupport.cs
@@ -209,15 +209,20 @@ public static Tuple<string, string, VsTextSpan> EnsureEventHandler(
 
             var position = type.Locations.First(loc => loc.SourceTree == targetSyntaxTree).SourceSpan.Start;
             var destinationType = syntaxFacts.GetContainingTypeDeclaration(targetSyntaxTree.GetRoot(cancellationToken), position);
-            var options = targetDocument.GetOptionsAsync(cancellationToken).WaitAndGetResult_Venus(cancellationToken);
-            var insertionPoint = codeModel.GetEndPoint(destinationType, options, EnvDTE.vsCMPart.vsCMPartBody);
+            var documentOptions = targetDocument.GetOptionsAsync(cancellationToken).WaitAndGetResult_Venus(cancellationToken);
+            var insertionPoint = codeModel.GetEndPoint(destinationType, documentOptions, EnvDTE.vsCMPart.vsCMPartBody);
 
             if (insertionPoint == null)
             {
                 throw new InvalidOperationException(ServicesVSResources.Can_t_find_where_to_insert_member);
             }
 
-            var newType = codeGenerationService.AddMethod(destinationType, newMethod, new CodeGenerationOptions(autoInsertionLocation: false), cancellationToken);
+            var options = codeGenerationService.GetOptions(
+                targetSyntaxTree.Options,
+                documentOptions,
+                new CodeGenerationContext(autoInsertionLocation: false));
+
+            var newType = codeGenerationService.AddMethod(destinationType, newMethod, options, cancellationToken);
             var newRoot = targetSyntaxTree.GetRoot(cancellationToken).ReplaceNode(destinationType, newType);
 
             newRoot = Simplifier.ReduceAsync(
diff --git a/src/VisualStudio/Core/Impl/CodeModel/AbstractCodeModelObject_CodeGen.cs b/src/VisualStudio/Core/Impl/CodeModel/AbstractCodeModelObject_CodeGen.cs
index 73a30b58343e6..75cfd2971b887 100644
--- a/src/VisualStudio/Core/Impl/CodeModel/AbstractCodeModelObject_CodeGen.cs
+++ b/src/VisualStudio/Core/Impl/CodeModel/AbstractCodeModelObject_CodeGen.cs
@@ -2,14 +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.
 
-#nullable disable
-
-using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Threading;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Options;
+using Roslyn.Utilities;
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.CodeModel
 {
@@ -19,14 +18,19 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.CodeModel
     /// </summary>
     public partial class AbstractCodeModelObject
     {
-        private static CodeGenerationOptions GetCodeGenerationOptions(
-            EnvDTE.vsCMAccess access, ParseOptions parseOptions, OptionSet options)
+        private CodeGenerationOptions GetCodeGenerationOptions(
+            SyntaxNode containerNode,
+            OptionSet? options = null,
+            EnvDTE.vsCMAccess access = EnvDTE.vsCMAccess.vsCMAccessDefault,
+            bool generateMethodBodies = true)
         {
             var generateDefaultAccessibility = (access & EnvDTE.vsCMAccess.vsCMAccessDefault) == 0;
-            return new CodeGenerationOptions(
-                generateDefaultAccessibility: generateDefaultAccessibility,
-                parseOptions: parseOptions,
-                options: options);
+            return CodeGenerationService.GetOptions(
+                containerNode.SyntaxTree.Options,
+                options ?? Workspace.Options,
+                new CodeGenerationContext(
+                    generateDefaultAccessibility: generateDefaultAccessibility,
+                    generateMethodBodies: generateMethodBodies));
         }
 
         protected SyntaxNode CreateConstructorDeclaration(SyntaxNode containerNode, string typeName, EnvDTE.vsCMAccess access)
@@ -40,10 +44,10 @@ protected SyntaxNode CreateConstructorDeclaration(SyntaxNode containerNode, stri
                 typeName: typeName,
                 parameters: default);
 
-            return CodeGenerationService.CreateMethodDeclaration(
-                newMethodSymbol, destination,
-                options: GetCodeGenerationOptions(
-                    access, containerNode.SyntaxTree.Options, options: null));
+            var codeGenOptions = GetCodeGenerationOptions(containerNode, access: access);
+            var method = CodeGenerationService.CreateMethodDeclaration(newMethodSymbol, destination, codeGenOptions, CancellationToken.None);
+            Contract.ThrowIfNull(method);
+            return method;
         }
 
         protected SyntaxNode CreateDestructorDeclaration(SyntaxNode containerNode, string typeName)
@@ -54,8 +58,10 @@ protected SyntaxNode CreateDestructorDeclaration(SyntaxNode containerNode, strin
                 attributes: default,
                 typeName: typeName);
 
-            return CodeGenerationService.CreateMethodDeclaration(
-                newMethodSymbol, destination);
+            var options = GetCodeGenerationOptions(containerNode);
+            var method = CodeGenerationService.CreateMethodDeclaration(newMethodSymbol, destination, options, CancellationToken.None);
+            Contract.ThrowIfNull(method);
+            return method;
         }
 
         protected SyntaxNode CreateDelegateTypeDeclaration(SyntaxNode containerNode, string name, EnvDTE.vsCMAccess access, INamedTypeSymbol returnType)
@@ -70,18 +76,17 @@ protected SyntaxNode CreateDelegateTypeDeclaration(SyntaxNode containerNode, str
                 refKind: RefKind.None,
                 name: name);
 
-            return CodeGenerationService.CreateNamedTypeDeclaration(
-                newTypeSymbol, destination,
-                options: GetCodeGenerationOptions(
-                    access, containerNode.SyntaxTree.Options, options: null));
+            var codeGenOptions = GetCodeGenerationOptions(containerNode, access: access);
+
+            return CodeGenerationService.CreateNamedTypeDeclaration(newTypeSymbol, destination, codeGenOptions, CancellationToken.None);
         }
 
         protected SyntaxNode CreateEventDeclaration(SyntaxNode containerNode, string name, EnvDTE.vsCMAccess access, ITypeSymbol type, bool createPropertyStyleEvent)
         {
             var destination = CodeModelService.GetDestination(containerNode);
 
-            IMethodSymbol addMethod = null;
-            IMethodSymbol removeMethod = null;
+            IMethodSymbol? addMethod = null;
+            IMethodSymbol? removeMethod = null;
 
             if (createPropertyStyleEvent)
             {
@@ -118,10 +123,8 @@ protected SyntaxNode CreateEventDeclaration(SyntaxNode containerNode, string nam
                 addMethod: addMethod,
                 removeMethod: removeMethod);
 
-            return CodeGenerationService.CreateEventDeclaration(
-                newEventSymbol, destination,
-                options: GetCodeGenerationOptions(
-                    access, containerNode.SyntaxTree.Options, options: null));
+            var codeGenOptions = GetCodeGenerationOptions(containerNode, access: access);
+            return CodeGenerationService.CreateEventDeclaration(newEventSymbol, destination, codeGenOptions, CancellationToken.None);
         }
 
         protected SyntaxNode CreateFieldDeclaration(SyntaxNode containerNode, string name, EnvDTE.vsCMAccess access, ITypeSymbol type)
@@ -135,10 +138,8 @@ protected SyntaxNode CreateFieldDeclaration(SyntaxNode containerNode, string nam
                 type: type,
                 name: name);
 
-            return CodeGenerationService.CreateFieldDeclaration(
-                newFieldSymbol, destination,
-                options: GetCodeGenerationOptions(
-                    access, containerNode.SyntaxTree.Options, options: null));
+            var codeGenOptions = GetCodeGenerationOptions(containerNode, access: access);
+            return CodeGenerationService.CreateFieldDeclaration(newFieldSymbol, destination, codeGenOptions, CancellationToken.None);
         }
 
         protected SyntaxNode CreateMethodDeclaration(SyntaxNode containerNode, string name, EnvDTE.vsCMAccess access, ITypeSymbol returnType)
@@ -156,18 +157,16 @@ protected SyntaxNode CreateMethodDeclaration(SyntaxNode containerNode, string na
                 typeParameters: default,
                 parameters: default);
 
+            // Generating method with body is allowed when targeting an interface,
+            // so we have to explicitly disable it here.
             var codeGenerationOptions = GetCodeGenerationOptions(
-                access, containerNode.SyntaxTree.Options, options: null);
-            if (destination == CodeGenerationDestination.InterfaceType)
-            {
-                // Generating method with body is allowed when targeting an interface,
-                // so we have to explicitly disable it here.
-                codeGenerationOptions = codeGenerationOptions.With(generateMethodBodies: false);
-            }
+                containerNode,
+                access: access,
+                generateMethodBodies: destination != CodeGenerationDestination.InterfaceType);
 
-            return CodeGenerationService.CreateMethodDeclaration(
-                newMethodSymbol, destination,
-                options: codeGenerationOptions);
+            var method = CodeGenerationService.CreateMethodDeclaration(newMethodSymbol, destination, codeGenerationOptions, CancellationToken.None);
+            Contract.ThrowIfNull(method);
+            return method;
         }
 
         protected SyntaxNode CreatePropertyDeclaration(
@@ -181,7 +180,7 @@ protected SyntaxNode CreatePropertyDeclaration(
         {
             var destination = CodeModelService.GetDestination(containerNode);
 
-            IMethodSymbol getMethod = null;
+            IMethodSymbol? getMethod = null;
             if (generateGetter)
             {
                 getMethod = CodeGenerationSymbolFactory.CreateMethodSymbol(
@@ -197,7 +196,7 @@ protected SyntaxNode CreatePropertyDeclaration(
                     statements: ImmutableArray.Create(CodeModelService.CreateReturnDefaultValueStatement(type)));
             }
 
-            IMethodSymbol setMethod = null;
+            IMethodSymbol? setMethod = null;
             if (generateSetter)
             {
                 setMethod = CodeGenerationSymbolFactory.CreateMethodSymbol(
@@ -224,22 +223,17 @@ protected SyntaxNode CreatePropertyDeclaration(
                 getMethod: getMethod,
                 setMethod: setMethod);
 
-            return CodeGenerationService.CreatePropertyDeclaration(
-                newPropertySymbol, destination,
-                options: GetCodeGenerationOptions(
-                    access, containerNode.SyntaxTree.Options, options));
+            var codeGenOptions = GetCodeGenerationOptions(containerNode, options, access);
+            return CodeGenerationService.CreatePropertyDeclaration(newPropertySymbol, destination, codeGenOptions, CancellationToken.None);
         }
 
         protected SyntaxNode CreateNamespaceDeclaration(SyntaxNode containerNode, string name)
         {
             var destination = CodeModelService.GetDestination(containerNode);
-
             var newNamespaceSymbol = CodeGenerationSymbolFactory.CreateNamespaceSymbol(name);
 
-            var newNamespace = CodeGenerationService.CreateNamespaceDeclaration(
-                newNamespaceSymbol, destination);
-
-            return newNamespace;
+            var options = GetCodeGenerationOptions(containerNode);
+            return CodeGenerationService.CreateNamespaceDeclaration(newNamespaceSymbol, destination, options, CancellationToken.None);
         }
 
         protected SyntaxNode CreateTypeDeclaration(
@@ -247,7 +241,7 @@ protected SyntaxNode CreateTypeDeclaration(
             TypeKind typeKind,
             string name,
             EnvDTE.vsCMAccess access,
-            INamedTypeSymbol baseType = null,
+            INamedTypeSymbol? baseType = null,
             ImmutableArray<INamedTypeSymbol> implementedInterfaces = default)
         {
             var destination = CodeModelService.GetDestination(containerNode);
@@ -264,10 +258,8 @@ protected SyntaxNode CreateTypeDeclaration(
                 specialType: SpecialType.None,
                 members: default);
 
-            return CodeGenerationService.CreateNamedTypeDeclaration(
-                newTypeSymbol, destination,
-                options: GetCodeGenerationOptions(
-                    access, containerNode.SyntaxTree.Options, options: null));
+            var codeGenOptions = GetCodeGenerationOptions(containerNode, access: access);
+            return CodeGenerationService.CreateNamedTypeDeclaration(newTypeSymbol, destination, codeGenOptions, CancellationToken.None);
         }
     }
 }
diff --git a/src/VisualStudio/Core/Impl/CodeModel/FileCodeModel_CodeGen.cs b/src/VisualStudio/Core/Impl/CodeModel/FileCodeModel_CodeGen.cs
index b4588915e82b3..b9596f01dcee4 100644
--- a/src/VisualStudio/Core/Impl/CodeModel/FileCodeModel_CodeGen.cs
+++ b/src/VisualStudio/Core/Impl/CodeModel/FileCodeModel_CodeGen.cs
@@ -204,7 +204,7 @@ internal EnvDTE.CodeClass AddClass(SyntaxNode containerNode, string name, object
             var implementedInterfaceArray = GetValidArray(implementedInterfaces, allowMultipleElements: true);
 
             var implementedInterfaceSymbols = Array.ConvertAll(implementedInterfaceArray,
-                i => (INamedTypeSymbol?)CodeModelService.GetTypeSymbol(i, semanticModel, containerNodePosition));
+                i => (INamedTypeSymbol)CodeModelService.GetTypeSymbol(i, semanticModel, containerNodePosition));
 
             var newType = CreateTypeDeclaration(
                 containerNode,
@@ -226,7 +226,7 @@ internal EnvDTE.CodeDelegate AddDelegate(SyntaxNode containerNode, string name,
             var containerNodePosition = containerNode.SpanStart;
             var semanticModel = GetSemanticModel();
 
-            var returnType = (INamedTypeSymbol?)CodeModelService.GetTypeSymbol(type, semanticModel, containerNodePosition);
+            var returnType = (INamedTypeSymbol)CodeModelService.GetTypeSymbol(type, semanticModel, containerNodePosition);
 
             var newType = CreateDelegateTypeDeclaration(containerNode, CodeModelService.GetUnescapedName(name), access, returnType);
             var insertionIndex = CodeModelService.PositionVariantToMemberInsertionIndex(position, containerNode, fileCodeModel: this);
@@ -257,7 +257,12 @@ public EnvDTE.CodeVariable AddEnumMember(SyntaxNode containerNode, string name,
 
             var semanticModel = GetSemanticModel();
 
-            var type = semanticModel.GetDeclaredSymbol(containerNode) as ITypeSymbol;
+            var type = (ITypeSymbol?)semanticModel.GetDeclaredSymbol(containerNode);
+            if (type == null)
+            {
+                throw Exceptions.ThrowEInvalidArg();
+            }
+
             var newField = CreateFieldDeclaration(containerNode, CodeModelService.GetUnescapedName(name), EnvDTE.vsCMAccess.vsCMAccessPublic, type);
             if (value != null)
             {
diff --git a/src/VisualStudio/Core/Test/Snippets/CSharpSnippetExpansionClientTests.vb b/src/VisualStudio/Core/Test/Snippets/CSharpSnippetExpansionClientTests.vb
index d4b96628114b8..29031633262c7 100644
--- a/src/VisualStudio/Core/Test/Snippets/CSharpSnippetExpansionClientTests.vb
+++ b/src/VisualStudio/Core/Test/Snippets/CSharpSnippetExpansionClientTests.vb
@@ -6,6 +6,8 @@ Imports System.Collections.Immutable
 Imports System.Threading
 Imports Microsoft.CodeAnalysis
 Imports Microsoft.CodeAnalysis.Completion
+Imports Microsoft.CodeAnalysis.CSharp
+Imports Microsoft.CodeAnalysis.CSharp.CodeGeneration
 Imports Microsoft.CodeAnalysis.Editing
 Imports Microsoft.CodeAnalysis.Editor.Shared.Utilities
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.Extensions
@@ -394,12 +396,12 @@ using G=   H.I;
 
                 Dim document = workspace.CurrentSolution.Projects.Single().Documents.Single()
                 Dim options = Await document.GetOptionsAsync(CancellationToken.None).ConfigureAwait(False)
-
                 options = options.WithChangedOption(GenerationOptions.PlaceSystemNamespaceFirst, placeSystemNamespaceFirst)
+                Dim preferences = New CSharpCodeGenerationPreferences(CType(document.DocumentState.ParseOptions, CSharpParseOptions), options)
 
                 Dim updatedDocument = expansionClient.AddImports(
                     document,
-                    options,
+                    preferences,
                     If(position, 0),
                     snippetNode,
                     allowInHiddenRegions:=False,
diff --git a/src/VisualStudio/Core/Test/Snippets/SnippetTestState.vb b/src/VisualStudio/Core/Test/Snippets/SnippetTestState.vb
index f73fc881f7d6b..bec94616cc128 100644
--- a/src/VisualStudio/Core/Test/Snippets/SnippetTestState.vb
+++ b/src/VisualStudio/Core/Test/Snippets/SnippetTestState.vb
@@ -5,6 +5,7 @@
 Imports System.Collections.Immutable
 Imports System.Threading
 Imports Microsoft.CodeAnalysis
+Imports Microsoft.CodeAnalysis.CodeGeneration
 Imports Microsoft.CodeAnalysis.Completion
 Imports Microsoft.CodeAnalysis.Editor
 Imports Microsoft.CodeAnalysis.Editor.Implementation.Formatting
@@ -219,7 +220,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Snippets
                 End Get
             End Property
 
-            Friend Overrides Function AddImports(document As Document, options As OptionSet, position As Integer, snippetNode As XElement, allowInHiddenRegions As Boolean, cancellationToken As CancellationToken) As Document
+            Friend Overrides Function AddImports(document As Document, preferences As CodeGenerationPreferences, position As Integer, snippetNode As XElement, allowInHiddenRegions As Boolean, cancellationToken As CancellationToken) As Document
                 Return document
             End Function
         End Class
diff --git a/src/VisualStudio/Core/Test/Snippets/VisualBasicSnippetExpansionClientTests.vb b/src/VisualStudio/Core/Test/Snippets/VisualBasicSnippetExpansionClientTests.vb
index 85176333eedba..809838ea997d6 100644
--- a/src/VisualStudio/Core/Test/Snippets/VisualBasicSnippetExpansionClientTests.vb
+++ b/src/VisualStudio/Core/Test/Snippets/VisualBasicSnippetExpansionClientTests.vb
@@ -14,6 +14,7 @@ Imports Microsoft.CodeAnalysis.Formatting
 Imports Microsoft.CodeAnalysis.Host.Mef
 Imports Microsoft.CodeAnalysis.Options
 Imports Microsoft.CodeAnalysis.Test.Utilities
+Imports Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
 Imports Microsoft.VisualStudio.LanguageServices.VisualBasic.Snippets
 Imports Microsoft.VisualStudio.Text.Projection
 Imports Roslyn.Test.Utilities
@@ -412,12 +413,12 @@ End Class</Test>
 
                 Dim document = workspace.CurrentSolution.Projects.Single().Documents.Single()
                 Dim options = Await document.GetOptionsAsync(CancellationToken.None).ConfigureAwait(False)
-
                 options = options.WithChangedOption(GenerationOptions.PlaceSystemNamespaceFirst, placeSystemNamespaceFirst)
+                Dim preferences = New VisualBasicCodeGenerationPreferences(options)
 
                 Dim updatedDocument = expansionClient.AddImports(
                     document,
-                    options,
+                    preferences,
                     If(position, 0),
                     snippetNode,
                     allowInHiddenRegions:=False,
diff --git a/src/VisualStudio/VisualBasic/Impl/Snippets/SnippetExpansionClient.vb b/src/VisualStudio/VisualBasic/Impl/Snippets/SnippetExpansionClient.vb
index 64d104e415c45..bf821d4d677b6 100644
--- a/src/VisualStudio/VisualBasic/Impl/Snippets/SnippetExpansionClient.vb
+++ b/src/VisualStudio/VisualBasic/Impl/Snippets/SnippetExpansionClient.vb
@@ -5,6 +5,7 @@
 Imports System.Collections.Immutable
 Imports System.Threading
 Imports Microsoft.CodeAnalysis
+Imports Microsoft.CodeAnalysis.CodeGeneration
 Imports Microsoft.CodeAnalysis.Completion
 Imports Microsoft.CodeAnalysis.Editing
 Imports Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.SignatureHelp
@@ -127,7 +128,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Snippets
 
         Friend Overrides Function AddImports(
                 document As Document,
-                options As OptionSet,
+                preferences As CodeGenerationPreferences,
                 position As Integer,
                 snippetNode As XElement,
                 allowInHiddenRegions As Boolean,
@@ -153,7 +154,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Snippets
 
             Dim root = document.GetSyntaxRootSynchronously(cancellationToken)
 
-            Dim placeSystemNamespaceFirst = options.GetOption(GenerationOptions.PlaceSystemNamespaceFirst, document.Project.Language)
+            Dim placeSystemNamespaceFirst = preferences.Options.GetOption(GenerationOptions.PlaceSystemNamespaceFirst, document.Project.Language)
 
             Dim newRoot = CType(root, CompilationUnitSyntax).AddImportsStatements(newImportsStatements, placeSystemNamespaceFirst)
             Dim newDocument = document.WithSyntaxRoot(newRoot)
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/AttributeGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/AttributeGenerator.cs
index 831b6b063a2ea..8dd19e7feadf6 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/AttributeGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/AttributeGenerator.cs
@@ -18,10 +18,10 @@ internal static class AttributeGenerator
     {
         public static SyntaxList<AttributeListSyntax> GenerateAttributeLists(
             ImmutableArray<AttributeData> attributes,
-            CodeGenerationOptions options,
+            CSharpCodeGenerationOptions options,
             SyntaxToken? target = null)
         {
-            if (options.MergeAttributes)
+            if (options.Context.MergeAttributes)
             {
                 var attributeNodes =
                     attributes.OrderBy(a => a.AttributeClass?.Name)
@@ -46,7 +46,7 @@ public static SyntaxList<AttributeListSyntax> GenerateAttributeLists(
         }
 
         private static AttributeListSyntax? TryGenerateAttributeDeclaration(
-            AttributeData attribute, SyntaxToken? target, CodeGenerationOptions options)
+            AttributeData attribute, SyntaxToken? target, CSharpCodeGenerationOptions options)
         {
             var attributeSyntax = TryGenerateAttribute(attribute, options);
             return attributeSyntax == null
@@ -58,12 +58,12 @@ public static SyntaxList<AttributeListSyntax> GenerateAttributeLists(
                     SyntaxFactory.SingletonSeparatedList(attributeSyntax));
         }
 
-        private static AttributeSyntax? TryGenerateAttribute(AttributeData attribute, CodeGenerationOptions options)
+        private static AttributeSyntax? TryGenerateAttribute(AttributeData attribute, CSharpCodeGenerationOptions options)
         {
             if (IsCompilerInternalAttribute(attribute))
                 return null;
 
-            if (!options.MergeAttributes)
+            if (!options.Context.MergeAttributes)
             {
                 var reusableSyntax = GetReuseableSyntaxNodeForAttribute<AttributeSyntax>(attribute, options);
                 if (reusableSyntax != null)
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpCodeGenerationHelpers.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpCodeGenerationHelpers.cs
index 867d2133cc422..5da837355bbfd 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpCodeGenerationHelpers.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpCodeGenerationHelpers.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -35,11 +33,10 @@ public static TDeclarationSyntax ConditionallyAddFormattingAnnotationTo<TDeclara
         internal static void AddAccessibilityModifiers(
             Accessibility accessibility,
             ArrayBuilder<SyntaxToken> tokens,
-            CodeGenerationOptions options,
+            CSharpCodeGenerationOptions options,
             Accessibility defaultAccessibility)
         {
-            options ??= CodeGenerationOptions.Default;
-            if (!options.GenerateDefaultAccessibility && accessibility == defaultAccessibility)
+            if (!options.Context.GenerateDefaultAccessibility && accessibility == defaultAccessibility)
             {
                 return;
             }
@@ -70,7 +67,7 @@ internal static void AddAccessibilityModifiers(
         }
 
         public static TypeDeclarationSyntax AddMembersTo(
-            TypeDeclarationSyntax destination, SyntaxList<MemberDeclarationSyntax> members)
+            TypeDeclarationSyntax destination, SyntaxList<MemberDeclarationSyntax> members, CancellationToken cancellationToken)
         {
             var syntaxTree = destination.SyntaxTree;
             destination = ReplaceUnterminatedConstructs(destination);
@@ -82,7 +79,7 @@ public static TypeDeclarationSyntax AddMembersTo(
             // Make sure the generated syntax node has same parse option.
             // e.g. If add syntax member to a C# 5 destination, we should return a C# 5 syntax node.
             var tree = node.SyntaxTree.WithRootAndOptions(node, syntaxTree.Options);
-            return (TypeDeclarationSyntax)tree.GetRoot();
+            return (TypeDeclarationSyntax)tree.GetRoot(cancellationToken);
         }
 
         private static TypeDeclarationSyntax ReplaceUnterminatedConstructs(TypeDeclarationSyntax destination)
@@ -113,7 +110,9 @@ private static TypeDeclarationSyntax ReplaceUnterminatedConstructs(TypeDeclarati
 
         private static SyntaxTrivia ReplaceUnterminatedConstructs(SyntaxTrivia skippedTokensTrivia)
         {
-            var syntax = (SkippedTokensTriviaSyntax)skippedTokensTrivia.GetStructure();
+            var syntax = (SkippedTokensTriviaSyntax?)skippedTokensTrivia.GetStructure();
+            Contract.ThrowIfNull(syntax);
+
             var tokens = syntax.Tokens;
 
             var updatedTokens = SyntaxFactory.TokenList(tokens.Select(ReplaceUnterminatedConstruct));
@@ -146,31 +145,31 @@ private static SyntaxToken ReplaceUnterminatedConstruct(SyntaxToken token)
             return token;
         }
 
-        public static MemberDeclarationSyntax FirstMember(SyntaxList<MemberDeclarationSyntax> members)
+        public static MemberDeclarationSyntax? FirstMember(SyntaxList<MemberDeclarationSyntax> members)
             => members.FirstOrDefault();
 
-        public static MemberDeclarationSyntax FirstMethod(SyntaxList<MemberDeclarationSyntax> members)
+        public static MemberDeclarationSyntax? FirstMethod(SyntaxList<MemberDeclarationSyntax> members)
             => members.FirstOrDefault(m => m is MethodDeclarationSyntax);
 
-        public static MemberDeclarationSyntax LastField(SyntaxList<MemberDeclarationSyntax> members)
+        public static MemberDeclarationSyntax? LastField(SyntaxList<MemberDeclarationSyntax> members)
             => members.LastOrDefault(m => m is FieldDeclarationSyntax);
 
-        public static MemberDeclarationSyntax LastConstructor(SyntaxList<MemberDeclarationSyntax> members)
+        public static MemberDeclarationSyntax? LastConstructor(SyntaxList<MemberDeclarationSyntax> members)
             => members.LastOrDefault(m => m is ConstructorDeclarationSyntax);
 
-        public static MemberDeclarationSyntax LastMethod(SyntaxList<MemberDeclarationSyntax> members)
+        public static MemberDeclarationSyntax? LastMethod(SyntaxList<MemberDeclarationSyntax> members)
             => members.LastOrDefault(m => m is MethodDeclarationSyntax);
 
-        public static MemberDeclarationSyntax LastOperator(SyntaxList<MemberDeclarationSyntax> members)
+        public static MemberDeclarationSyntax? LastOperator(SyntaxList<MemberDeclarationSyntax> members)
             => members.LastOrDefault(m => m is OperatorDeclarationSyntax or ConversionOperatorDeclarationSyntax);
 
         public static SyntaxList<TDeclaration> Insert<TDeclaration>(
             SyntaxList<TDeclaration> declarationList,
             TDeclaration declaration,
-            CodeGenerationOptions options,
-            IList<bool> availableIndices,
-            Func<SyntaxList<TDeclaration>, TDeclaration> after = null,
-            Func<SyntaxList<TDeclaration>, TDeclaration> before = null)
+            CSharpCodeGenerationOptions options,
+            IList<bool>? availableIndices,
+            Func<SyntaxList<TDeclaration>, TDeclaration?>? after = null,
+            Func<SyntaxList<TDeclaration>, TDeclaration?>? before = null)
             where TDeclaration : SyntaxNode
         {
             var index = GetInsertionIndex(
@@ -195,7 +194,7 @@ public static SyntaxList<TDeclaration> Insert<TDeclaration>(
         private static bool AreBracesMissing<TDeclaration>(TDeclaration declaration) where TDeclaration : SyntaxNode
             => declaration.ChildTokens().Where(t => t.IsKind(SyntaxKind.OpenBraceToken, SyntaxKind.CloseBraceToken) && t.IsMissing).Any();
 
-        public static SyntaxNode GetContextNode(
+        public static SyntaxNode? GetContextNode(
             Location location, CancellationToken cancellationToken)
         {
             var contextLocation = location;
@@ -204,10 +203,10 @@ public static SyntaxNode GetContextNode(
                 ? contextLocation.SourceTree
                 : null;
 
-            return contextTree?.GetRoot(cancellationToken).FindToken(contextLocation.SourceSpan.Start).Parent;
+            return contextTree?.GetRoot(cancellationToken).FindToken(contextLocation!.SourceSpan.Start).Parent;
         }
 
-        public static ExplicitInterfaceSpecifierSyntax GenerateExplicitInterfaceSpecifier(
+        public static ExplicitInterfaceSpecifierSyntax? GenerateExplicitInterfaceSpecifier(
             IEnumerable<ISymbol> implementations)
         {
             var implementation = implementations.FirstOrDefault();
@@ -247,11 +246,11 @@ public static CodeGenerationDestination GetDestination(SyntaxNode destination)
         public static TSyntaxNode ConditionallyAddDocumentationCommentTo<TSyntaxNode>(
             TSyntaxNode node,
             ISymbol symbol,
-            CodeGenerationOptions options,
-            CancellationToken cancellationToken = default)
+            CSharpCodeGenerationOptions options,
+            CancellationToken cancellationToken)
             where TSyntaxNode : SyntaxNode
         {
-            if (!options.GenerateDocumentationComments || node.GetLeadingTrivia().Any(t => t.IsDocComment()))
+            if (!options.Context.GenerateDocumentationComments || node.GetLeadingTrivia().Any(t => t.IsDocComment()))
             {
                 return node;
             }
@@ -267,11 +266,11 @@ public static TSyntaxNode ConditionallyAddDocumentationCommentTo<TSyntaxNode>(
         /// Try use the existing syntax node and generate a new syntax node for the given <param name="symbol"/>.
         /// Note: the returned syntax node might be modified, which means its parent information might be missing.
         /// </summary>
-        public static T GetReuseableSyntaxNodeForSymbol<T>(ISymbol symbol, CodeGenerationOptions options) where T : SyntaxNode
+        public static T? GetReuseableSyntaxNodeForSymbol<T>(ISymbol symbol, CSharpCodeGenerationOptions options) where T : SyntaxNode
         {
             Contract.ThrowIfNull(symbol);
 
-            if (options is not null && options.ReuseSyntax && symbol.DeclaringSyntaxReferences.Length == 1)
+            if (options.Context.ReuseSyntax && symbol.DeclaringSyntaxReferences.Length == 1)
             {
                 var reusableSyntaxNode = symbol.DeclaringSyntaxReferences[0].GetSyntax();
 
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpCodeGenerationOptions.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpCodeGenerationOptions.cs
new file mode 100644
index 0000000000000..1095addc16853
--- /dev/null
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpCodeGenerationOptions.cs
@@ -0,0 +1,36 @@
+// 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.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeGeneration;
+
+namespace Microsoft.CodeAnalysis.CSharp.CodeGeneration
+{
+    internal sealed class CSharpCodeGenerationOptions : CodeGenerationOptions
+    {
+        private readonly CSharpCodeGenerationPreferences _preferences;
+
+        public CSharpCodeGenerationOptions(CodeGenerationContext Context, CSharpCodeGenerationPreferences Preferences)
+            : base(Context)
+        {
+            _preferences = Preferences;
+        }
+
+        public new CSharpCodeGenerationPreferences Preferences
+            => _preferences;
+
+        protected override CodeGenerationPreferences PreferencesImpl
+            => _preferences;
+
+        public new CSharpCodeGenerationOptions WithContext(CodeGenerationContext value)
+            => (Context == value) ? this : new(value, Preferences);
+
+        protected override CodeGenerationOptions WithContextImpl(CodeGenerationContext value)
+            => WithContext(value);
+
+        public static new async ValueTask<CSharpCodeGenerationOptions> FromDocumentAsync(CodeGenerationContext context, Document document, CancellationToken cancellationToken)
+            => new(context, await CSharpCodeGenerationPreferences.FromDocumentAsync(document, cancellationToken).ConfigureAwait(false));
+    }
+}
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpCodeGenerationPreferences.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpCodeGenerationPreferences.cs
new file mode 100644
index 0000000000000..47e0321deea7e
--- /dev/null
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpCodeGenerationPreferences.cs
@@ -0,0 +1,40 @@
+// 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.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeGeneration;
+using Microsoft.CodeAnalysis.Options;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.CSharp.CodeGeneration
+{
+    internal sealed class CSharpCodeGenerationPreferences : CodeGenerationPreferences
+    {
+        public readonly LanguageVersion LanguageVersion;
+
+        public CSharpCodeGenerationPreferences(CSharpParseOptions parseOptions, OptionSet options)
+            : this(parseOptions.LanguageVersion, options)
+        {
+        }
+
+        public CSharpCodeGenerationPreferences(LanguageVersion languageVersion, OptionSet options)
+            : base(options)
+        {
+            LanguageVersion = languageVersion;
+        }
+
+        public override CodeGenerationOptions GetOptions(CodeGenerationContext context)
+            => new CSharpCodeGenerationOptions(context, this);
+
+        public static new async Task<CSharpCodeGenerationPreferences> FromDocumentAsync(Document document, CancellationToken cancellationToken)
+        {
+            var parseOptions = (CSharpParseOptions?)document.Project.ParseOptions;
+            Contract.ThrowIfNull(parseOptions);
+
+            var documentOptions = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
+            return new CSharpCodeGenerationPreferences(parseOptions, documentOptions);
+        }
+    }
+}
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpCodeGenerationService.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpCodeGenerationService.cs
index 38b69457e6e1f..1dd36dd7be2c5 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpCodeGenerationService.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpCodeGenerationService.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
@@ -15,27 +13,30 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.LanguageServices;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.CodeGeneration
 {
-    internal partial class CSharpCodeGenerationService : AbstractCodeGenerationService
+    internal partial class CSharpCodeGenerationService : AbstractCodeGenerationService<CSharpCodeGenerationOptions>
     {
         public CSharpCodeGenerationService(HostLanguageServices languageServices)
-            : base(languageServices.GetService<ISymbolDeclarationService>(),
-                   languageServices.WorkspaceServices.Workspace)
+            : base(languageServices.GetRequiredService<ISymbolDeclarationService>())
         {
         }
 
+        public override CodeGenerationPreferences GetPreferences(ParseOptions parseOptions, OptionSet documentOptions)
+            => new CSharpCodeGenerationPreferences((CSharpParseOptions)parseOptions, documentOptions);
+
         public override CodeGenerationDestination GetDestination(SyntaxNode node)
             => CSharpCodeGenerationHelpers.GetDestination(node);
 
         protected override IComparer<SyntaxNode> GetMemberComparer()
             => CSharpDeclarationComparer.WithoutNamesInstance;
 
-        protected override IList<bool> GetAvailableInsertionIndices(SyntaxNode destination, CancellationToken cancellationToken)
+        protected override IList<bool>? GetAvailableInsertionIndices(SyntaxNode destination, CancellationToken cancellationToken)
         {
             if (destination is TypeDeclarationSyntax typeDeclaration)
             {
@@ -53,62 +54,62 @@ private static IList<bool> GetInsertionIndices(TypeDeclarationSyntax destination
 
         public override async Task<Document> AddEventAsync(
             Solution solution, INamedTypeSymbol destination, IEventSymbol @event,
-            CodeGenerationOptions options, CancellationToken cancellationToken)
+            CodeGenerationContext context, CancellationToken cancellationToken)
         {
             var newDocument = await base.AddEventAsync(
-                solution, destination, @event, options, cancellationToken).ConfigureAwait(false);
+                solution, destination, @event, context, cancellationToken).ConfigureAwait(false);
 
             var namedType = @event.Type as INamedTypeSymbol;
             if (namedType?.AssociatedSymbol != null)
             {
                 // This is a VB event that declares its own type.  i.e. "Public Event E(x As Object)"
                 // We also have to generate "public void delegate EEventHandler(object x)"
-                var compilation = await newDocument.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
+                var compilation = await newDocument.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);
                 var newDestinationSymbol = destination.GetSymbolKey(cancellationToken).Resolve(compilation, cancellationToken: cancellationToken).Symbol;
 
                 if (newDestinationSymbol?.ContainingType != null)
                 {
                     return await this.AddNamedTypeAsync(
                         newDocument.Project.Solution, newDestinationSymbol.ContainingType,
-                        namedType, options, cancellationToken).ConfigureAwait(false);
+                        namedType, context, cancellationToken).ConfigureAwait(false);
                 }
                 else if (newDestinationSymbol?.ContainingNamespace != null)
                 {
                     return await this.AddNamedTypeAsync(
                         newDocument.Project.Solution, newDestinationSymbol.ContainingNamespace,
-                        namedType, options, cancellationToken).ConfigureAwait(false);
+                        namedType, context, cancellationToken).ConfigureAwait(false);
                 }
             }
 
             return newDocument;
         }
 
-        protected override TDeclarationNode AddEvent<TDeclarationNode>(TDeclarationNode destination, IEventSymbol @event, CodeGenerationOptions options, IList<bool> availableIndices)
+        protected override TDeclarationNode AddEvent<TDeclarationNode>(TDeclarationNode destination, IEventSymbol @event, CSharpCodeGenerationOptions options, IList<bool>? availableIndices, CancellationToken cancellationToken)
         {
             CheckDeclarationNode<TypeDeclarationSyntax>(destination);
 
-            return Cast<TDeclarationNode>(EventGenerator.AddEventTo(Cast<TypeDeclarationSyntax>(destination), @event, options, availableIndices));
+            return Cast<TDeclarationNode>(EventGenerator.AddEventTo(Cast<TypeDeclarationSyntax>(destination), @event, options, availableIndices, cancellationToken));
         }
 
-        protected override TDeclarationNode AddField<TDeclarationNode>(TDeclarationNode destination, IFieldSymbol field, CodeGenerationOptions options, IList<bool> availableIndices)
+        protected override TDeclarationNode AddField<TDeclarationNode>(TDeclarationNode destination, IFieldSymbol field, CSharpCodeGenerationOptions options, IList<bool>? availableIndices, CancellationToken cancellationToken)
         {
             CheckDeclarationNode<EnumDeclarationSyntax, TypeDeclarationSyntax, CompilationUnitSyntax>(destination);
 
             if (destination is EnumDeclarationSyntax)
             {
-                return Cast<TDeclarationNode>(EnumMemberGenerator.AddEnumMemberTo(Cast<EnumDeclarationSyntax>(destination), field, options));
+                return Cast<TDeclarationNode>(EnumMemberGenerator.AddEnumMemberTo(Cast<EnumDeclarationSyntax>(destination), field, options, cancellationToken));
             }
             else if (destination is TypeDeclarationSyntax)
             {
-                return Cast<TDeclarationNode>(FieldGenerator.AddFieldTo(Cast<TypeDeclarationSyntax>(destination), field, options, availableIndices));
+                return Cast<TDeclarationNode>(FieldGenerator.AddFieldTo(Cast<TypeDeclarationSyntax>(destination), field, options, availableIndices, cancellationToken));
             }
             else
             {
-                return Cast<TDeclarationNode>(FieldGenerator.AddFieldTo(Cast<CompilationUnitSyntax>(destination), field, options, availableIndices));
+                return Cast<TDeclarationNode>(FieldGenerator.AddFieldTo(Cast<CompilationUnitSyntax>(destination), field, options, availableIndices, cancellationToken));
             }
         }
 
-        protected override TDeclarationNode AddMethod<TDeclarationNode>(TDeclarationNode destination, IMethodSymbol method, CodeGenerationOptions options, IList<bool> availableIndices)
+        protected override TDeclarationNode AddMethod<TDeclarationNode>(TDeclarationNode destination, IMethodSymbol method, CSharpCodeGenerationOptions options, IList<bool>? availableIndices, CancellationToken cancellationToken)
         {
             // https://github.com/dotnet/roslyn/issues/44425: Add handling for top level statements
             if (destination is GlobalStatementSyntax)
@@ -118,8 +119,6 @@ protected override TDeclarationNode AddMethod<TDeclarationNode>(TDeclarationNode
 
             CheckDeclarationNode<TypeDeclarationSyntax, CompilationUnitSyntax, BaseNamespaceDeclarationSyntax>(destination);
 
-            options = options.With(options: options.Options ?? Workspace.Options);
-
             // Synthesized methods for properties/events are not things we actually generate 
             // declarations for.
             if (method.AssociatedSymbol is IEventSymbol)
@@ -136,33 +135,35 @@ protected override TDeclarationNode AddMethod<TDeclarationNode>(TDeclarationNode
                 }
             }
 
+            var csharpOptions = options;
+
             if (destination is TypeDeclarationSyntax typeDeclaration)
             {
                 if (method.IsConstructor())
                 {
                     return Cast<TDeclarationNode>(ConstructorGenerator.AddConstructorTo(
-                        typeDeclaration, method, options, availableIndices));
+                        typeDeclaration, method, csharpOptions, availableIndices, cancellationToken));
                 }
 
                 if (method.IsDestructor())
                 {
-                    return Cast<TDeclarationNode>(DestructorGenerator.AddDestructorTo(typeDeclaration, method, options, availableIndices));
+                    return Cast<TDeclarationNode>(DestructorGenerator.AddDestructorTo(typeDeclaration, method, csharpOptions, availableIndices, cancellationToken));
                 }
 
                 if (method.MethodKind == MethodKind.Conversion)
                 {
                     return Cast<TDeclarationNode>(ConversionGenerator.AddConversionTo(
-                        typeDeclaration, method, options, availableIndices));
+                        typeDeclaration, method, csharpOptions, availableIndices, cancellationToken));
                 }
 
                 if (method.MethodKind == MethodKind.UserDefinedOperator)
                 {
                     return Cast<TDeclarationNode>(OperatorGenerator.AddOperatorTo(
-                        typeDeclaration, method, options, availableIndices));
+                        typeDeclaration, method, csharpOptions, availableIndices, cancellationToken));
                 }
 
                 return Cast<TDeclarationNode>(MethodGenerator.AddMethodTo(
-                    typeDeclaration, method, options, availableIndices));
+                    typeDeclaration, method, csharpOptions, availableIndices, cancellationToken));
             }
 
             if (method.IsConstructor() ||
@@ -174,15 +175,15 @@ protected override TDeclarationNode AddMethod<TDeclarationNode>(TDeclarationNode
             if (destination is CompilationUnitSyntax compilationUnit)
             {
                 return Cast<TDeclarationNode>(
-                    MethodGenerator.AddMethodTo(compilationUnit, method, options, availableIndices));
+                    MethodGenerator.AddMethodTo(compilationUnit, method, csharpOptions, availableIndices, cancellationToken));
             }
 
             var ns = Cast<BaseNamespaceDeclarationSyntax>(destination);
             return Cast<TDeclarationNode>(
-                MethodGenerator.AddMethodTo(ns, method, options, availableIndices));
+                MethodGenerator.AddMethodTo(ns, method, csharpOptions, availableIndices, cancellationToken));
         }
 
-        protected override TDeclarationNode AddProperty<TDeclarationNode>(TDeclarationNode destination, IPropertySymbol property, CodeGenerationOptions options, IList<bool> availableIndices)
+        protected override TDeclarationNode AddProperty<TDeclarationNode>(TDeclarationNode destination, IPropertySymbol property, CSharpCodeGenerationOptions options, IList<bool>? availableIndices, CancellationToken cancellationToken)
         {
             CheckDeclarationNode<TypeDeclarationSyntax, CompilationUnitSyntax>(destination);
 
@@ -225,40 +226,42 @@ protected override TDeclarationNode AddProperty<TDeclarationNode>(TDeclarationNo
                     options = CreateOptionsForMultipleMembers(options);
                 }
 
-                return AddMembers(destination, members, availableIndices, options, CancellationToken.None);
+                return AddMembers(destination, members, availableIndices, options, cancellationToken);
             }
 
             if (destination is TypeDeclarationSyntax)
             {
                 return Cast<TDeclarationNode>(PropertyGenerator.AddPropertyTo(
-                    Cast<TypeDeclarationSyntax>(destination), property, options, availableIndices));
+                    Cast<TypeDeclarationSyntax>(destination), property, options, availableIndices, cancellationToken));
             }
             else
             {
                 return Cast<TDeclarationNode>(PropertyGenerator.AddPropertyTo(
-                    Cast<CompilationUnitSyntax>(destination), property, options, availableIndices));
+                    Cast<CompilationUnitSyntax>(destination), property, options, availableIndices, cancellationToken));
             }
         }
 
-        protected override TDeclarationNode AddNamedType<TDeclarationNode>(TDeclarationNode destination, INamedTypeSymbol namedType, CodeGenerationOptions options, IList<bool> availableIndices, CancellationToken cancellationToken)
+        protected override TDeclarationNode AddNamedType<TDeclarationNode>(TDeclarationNode destination, INamedTypeSymbol namedType, CSharpCodeGenerationOptions options, IList<bool>? availableIndices, CancellationToken cancellationToken)
         {
             CheckDeclarationNode<TypeDeclarationSyntax, BaseNamespaceDeclarationSyntax, CompilationUnitSyntax>(destination);
 
+            var csharpOptions = options;
+
             if (destination is TypeDeclarationSyntax typeDeclaration)
             {
-                return Cast<TDeclarationNode>(NamedTypeGenerator.AddNamedTypeTo(this, typeDeclaration, namedType, options, availableIndices, cancellationToken));
+                return Cast<TDeclarationNode>(NamedTypeGenerator.AddNamedTypeTo(this, typeDeclaration, namedType, csharpOptions, availableIndices, cancellationToken));
             }
             else if (destination is BaseNamespaceDeclarationSyntax namespaceDeclaration)
             {
-                return Cast<TDeclarationNode>(NamedTypeGenerator.AddNamedTypeTo(this, namespaceDeclaration, namedType, options, availableIndices, cancellationToken));
+                return Cast<TDeclarationNode>(NamedTypeGenerator.AddNamedTypeTo(this, namespaceDeclaration, namedType, csharpOptions, availableIndices, cancellationToken));
             }
             else
             {
-                return Cast<TDeclarationNode>(NamedTypeGenerator.AddNamedTypeTo(this, Cast<CompilationUnitSyntax>(destination), namedType, options, availableIndices, cancellationToken));
+                return Cast<TDeclarationNode>(NamedTypeGenerator.AddNamedTypeTo(this, Cast<CompilationUnitSyntax>(destination), namedType, csharpOptions, availableIndices, cancellationToken));
             }
         }
 
-        protected override TDeclarationNode AddNamespace<TDeclarationNode>(TDeclarationNode destination, INamespaceSymbol @namespace, CodeGenerationOptions options, IList<bool> availableIndices, CancellationToken cancellationToken)
+        protected override TDeclarationNode AddNamespace<TDeclarationNode>(TDeclarationNode destination, INamespaceSymbol @namespace, CSharpCodeGenerationOptions options, IList<bool>? availableIndices, CancellationToken cancellationToken)
         {
             CheckDeclarationNode<CompilationUnitSyntax, BaseNamespaceDeclarationSyntax>(destination);
 
@@ -275,7 +278,7 @@ protected override TDeclarationNode AddNamespace<TDeclarationNode>(TDeclarationN
         public override TDeclarationNode AddParameters<TDeclarationNode>(
             TDeclarationNode destination,
             IEnumerable<IParameterSymbol> parameters,
-            CodeGenerationOptions options,
+            CSharpCodeGenerationOptions options,
             CancellationToken cancellationToken)
         {
             var currentParameterList = destination.GetParameterList();
@@ -308,7 +311,7 @@ public override TDeclarationNode AddAttributes<TDeclarationNode>(
             TDeclarationNode destination,
             IEnumerable<AttributeData> attributes,
             SyntaxToken? target,
-            CodeGenerationOptions options,
+            CSharpCodeGenerationOptions options,
             CancellationToken cancellationToken)
         {
             if (target.HasValue && !target.Value.IsValidAttributeTarget())
@@ -355,7 +358,7 @@ protected override TDeclarationNode AddMembers<TDeclarationNode>(TDeclarationNod
         public override TDeclarationNode RemoveAttribute<TDeclarationNode>(
             TDeclarationNode destination,
             AttributeData attributeToRemove,
-            CodeGenerationOptions options,
+            CSharpCodeGenerationOptions options,
             CancellationToken cancellationToken)
         {
             if (attributeToRemove.ApplicationSyntaxReference == null)
@@ -370,7 +373,7 @@ public override TDeclarationNode RemoveAttribute<TDeclarationNode>(
         public override TDeclarationNode RemoveAttribute<TDeclarationNode>(
             TDeclarationNode destination,
             SyntaxNode attributeToRemove,
-            CodeGenerationOptions options,
+            CSharpCodeGenerationOptions options,
             CancellationToken cancellationToken)
         {
             if (attributeToRemove == null)
@@ -466,7 +469,7 @@ private static SyntaxList<AttributeListSyntax> RemoveAttributeFromAttributeLists
         public override TDeclarationNode AddStatements<TDeclarationNode>(
             TDeclarationNode destinationMember,
             IEnumerable<SyntaxNode> statements,
-            CodeGenerationOptions options,
+            CSharpCodeGenerationOptions options,
             CancellationToken cancellationToken)
         {
             if (destinationMember is MemberDeclarationSyntax memberDeclaration)
@@ -481,11 +484,10 @@ public override TDeclarationNode AddStatements<TDeclarationNode>(
             {
                 return (accessorDeclaration.Body == null) ? destinationMember : Cast<TDeclarationNode>(accessorDeclaration.AddBodyStatements(StatementGenerator.GenerateStatements(statements).ToArray()));
             }
-            else if (destinationMember is CompilationUnitSyntax compilationUnit && options is null)
+            else if (destinationMember is CompilationUnitSyntax compilationUnit && options.Context.BestLocation is null)
             {
-                // This path supports top-level statement insertion. It only applies when 'options'
-                // is null so the fallback code below can handle cases where the insertion location
-                // is provided through options.BestLocation.
+                // This path supports top-level statement insertion. It only applies when best location is unspecified
+                // so the fallback code below can handle cases where the insertion location is provided.
                 //
                 // Insert the new global statement(s) at the end of any current global statements.
                 // This code relies on 'LastIndexOf' returning -1 when no matching element is found.
@@ -510,11 +512,11 @@ public override TDeclarationNode AddStatements<TDeclarationNode>(
         private static TDeclarationNode AddStatementsWorker<TDeclarationNode>(
             TDeclarationNode destinationMember,
             IEnumerable<SyntaxNode> statements,
-            CodeGenerationOptions options,
+            CSharpCodeGenerationOptions options,
             CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
         {
-            var location = options.BestLocation;
-            CheckLocation<TDeclarationNode>(destinationMember, location);
+            var location = options.Context.BestLocation;
+            CheckLocation(destinationMember, location);
 
             var token = location.FindToken(cancellationToken);
 
@@ -527,7 +529,7 @@ private static TDeclarationNode AddStatementsWorker<TDeclarationNode>(
 
                 var newStatements = statements.OfType<StatementSyntax>().ToArray();
                 BlockSyntax newBlock;
-                if (options.BeforeThisLocation != null)
+                if (options.Context.BeforeThisLocation != null)
                 {
                     var newContainingStatement = containingStatement.GetNodeWithoutLeadingBannerAndPreprocessorDirectives(out var strippedTrivia);
 
@@ -565,20 +567,21 @@ private static TDeclarationNode AddStatementsToMemberDeclaration<TDeclarationNod
         }
 
         public override SyntaxNode CreateEventDeclaration(
-            IEventSymbol @event, CodeGenerationDestination destination, CodeGenerationOptions options)
+            IEventSymbol @event, CodeGenerationDestination destination, CSharpCodeGenerationOptions options, CancellationToken cancellationToken)
         {
-            return EventGenerator.GenerateEventDeclaration(@event, destination, options);
+            return EventGenerator.GenerateEventDeclaration(@event, destination, options, cancellationToken);
         }
 
-        public override SyntaxNode CreateFieldDeclaration(IFieldSymbol field, CodeGenerationDestination destination, CodeGenerationOptions options)
+        public override SyntaxNode CreateFieldDeclaration(IFieldSymbol field, CodeGenerationDestination destination, CSharpCodeGenerationOptions options, CancellationToken cancellationToken)
         {
             return destination == CodeGenerationDestination.EnumType
-                ? EnumMemberGenerator.GenerateEnumMemberDeclaration(field, null, options)
-                : FieldGenerator.GenerateFieldDeclaration(field, options);
+                ? EnumMemberGenerator.GenerateEnumMemberDeclaration(field, destination: null, options, cancellationToken)
+                : FieldGenerator.GenerateFieldDeclaration(field, options, cancellationToken);
         }
 
-        public override SyntaxNode CreateMethodDeclaration(
-            IMethodSymbol method, CodeGenerationDestination destination, CodeGenerationOptions options)
+        // TODO: Change to not return null (https://github.com/dotnet/roslyn/issues/58243)
+        public override SyntaxNode? CreateMethodDeclaration(
+            IMethodSymbol method, CodeGenerationDestination destination, CSharpCodeGenerationOptions options, CancellationToken cancellationToken)
         {
             // Synthesized methods for properties/events are not things we actually generate 
             // declarations for.
@@ -596,57 +599,53 @@ public override SyntaxNode CreateMethodDeclaration(
                 }
             }
 
+            var csharpOptions = options;
+
             if (method.IsDestructor())
             {
-                return DestructorGenerator.GenerateDestructorDeclaration(method, options);
+                return DestructorGenerator.GenerateDestructorDeclaration(method, csharpOptions, cancellationToken);
             }
 
-            options = options.With(options: options.Options ?? Workspace.Options);
-
             if (method.IsConstructor())
             {
-                return ConstructorGenerator.GenerateConstructorDeclaration(
-                    method, options, options.ParseOptions);
-            }
-            else if (method.IsUserDefinedOperator())
-            {
-                return OperatorGenerator.GenerateOperatorDeclaration(
-                    method, options, options.ParseOptions);
+                return ConstructorGenerator.GenerateConstructorDeclaration(method, csharpOptions, cancellationToken);
             }
-            else if (method.IsConversion())
+
+            if (method.IsUserDefinedOperator())
             {
-                return ConversionGenerator.GenerateConversionDeclaration(
-                    method, options, options.ParseOptions);
+                return OperatorGenerator.GenerateOperatorDeclaration(method, csharpOptions, cancellationToken);
             }
-            else if (method.IsLocalFunction())
+
+            if (method.IsConversion())
             {
-                return MethodGenerator.GenerateLocalFunctionDeclaration(
-                    method, destination, options, options.ParseOptions);
+                return ConversionGenerator.GenerateConversionDeclaration(method, csharpOptions, cancellationToken);
             }
-            else
+
+            if (method.IsLocalFunction())
             {
-                return MethodGenerator.GenerateMethodDeclaration(
-                    method, destination, options, options.ParseOptions);
+                return MethodGenerator.GenerateLocalFunctionDeclaration(method, destination, csharpOptions, cancellationToken);
             }
+
+            return MethodGenerator.GenerateMethodDeclaration(method, destination, csharpOptions, cancellationToken);
         }
 
         public override SyntaxNode CreatePropertyDeclaration(
-            IPropertySymbol property, CodeGenerationDestination destination, CodeGenerationOptions options)
+            IPropertySymbol property, CodeGenerationDestination destination, CSharpCodeGenerationOptions options, CancellationToken cancellationToken)
         {
             return PropertyGenerator.GeneratePropertyOrIndexer(
-                property, destination, options, options.ParseOptions);
+                property, destination, options, cancellationToken);
         }
 
         public override SyntaxNode CreateNamedTypeDeclaration(
-            INamedTypeSymbol namedType, CodeGenerationDestination destination, CodeGenerationOptions options, CancellationToken cancellationToken)
+            INamedTypeSymbol namedType, CodeGenerationDestination destination, CSharpCodeGenerationOptions options, CancellationToken cancellationToken)
         {
             return NamedTypeGenerator.GenerateNamedTypeDeclaration(this, namedType, destination, options, cancellationToken);
         }
 
         public override SyntaxNode CreateNamespaceDeclaration(
-            INamespaceSymbol @namespace, CodeGenerationDestination destination, CodeGenerationOptions options, CancellationToken cancellationToken)
+            INamespaceSymbol @namespace, CodeGenerationDestination destination, CSharpCodeGenerationOptions options, CancellationToken cancellationToken)
         {
-            return NamespaceGenerator.GenerateNamespaceDeclaration(this, @namespace, destination, options, options?.ParseOptions, cancellationToken);
+            return NamespaceGenerator.GenerateNamespaceDeclaration(this, @namespace, destination, options, cancellationToken);
         }
 
         private static TDeclarationNode UpdateDeclarationModifiers<TDeclarationNode>(TDeclarationNode declaration, Func<SyntaxTokenList, SyntaxTokenList> computeNewModifiersList)
@@ -659,19 +658,19 @@ private static TDeclarationNode UpdateDeclarationModifiers<TDeclarationNode>(TDe
                 _ => declaration,
             };
 
-        public override TDeclarationNode UpdateDeclarationModifiers<TDeclarationNode>(TDeclarationNode declaration, IEnumerable<SyntaxToken> newModifiers, CodeGenerationOptions options, CancellationToken cancellationToken)
+        public override TDeclarationNode UpdateDeclarationModifiers<TDeclarationNode>(TDeclarationNode declaration, IEnumerable<SyntaxToken> newModifiers, CSharpCodeGenerationOptions options, CancellationToken cancellationToken)
         {
             SyntaxTokenList computeNewModifiersList(SyntaxTokenList modifiersList) => newModifiers.ToSyntaxTokenList();
             return UpdateDeclarationModifiers(declaration, computeNewModifiersList);
         }
 
-        public override TDeclarationNode UpdateDeclarationAccessibility<TDeclarationNode>(TDeclarationNode declaration, Accessibility newAccessibility, CodeGenerationOptions options, CancellationToken cancellationToken)
+        public override TDeclarationNode UpdateDeclarationAccessibility<TDeclarationNode>(TDeclarationNode declaration, Accessibility newAccessibility, CSharpCodeGenerationOptions options, CancellationToken cancellationToken)
         {
             SyntaxTokenList computeNewModifiersList(SyntaxTokenList modifiersList) => UpdateDeclarationAccessibility(modifiersList, newAccessibility, options);
             return UpdateDeclarationModifiers(declaration, computeNewModifiersList);
         }
 
-        private static SyntaxTokenList UpdateDeclarationAccessibility(SyntaxTokenList modifiersList, Accessibility newAccessibility, CodeGenerationOptions options)
+        private static SyntaxTokenList UpdateDeclarationAccessibility(SyntaxTokenList modifiersList, Accessibility newAccessibility, CSharpCodeGenerationOptions options)
         {
             using var _ = ArrayBuilder<SyntaxToken>.GetInstance(out var newModifierTokens);
             CSharpCodeGenerationHelpers.AddAccessibilityModifiers(newAccessibility, newModifierTokens, options, Accessibility.NotApplicable);
@@ -687,7 +686,7 @@ private static SyntaxTokenList UpdateDeclarationAccessibility(SyntaxTokenList mo
                 modifier => SyntaxFacts.IsAccessibilityModifier(modifier.Kind()));
         }
 
-        public override TDeclarationNode UpdateDeclarationType<TDeclarationNode>(TDeclarationNode declaration, ITypeSymbol newType, CodeGenerationOptions options, CancellationToken cancellationToken)
+        public override TDeclarationNode UpdateDeclarationType<TDeclarationNode>(TDeclarationNode declaration, ITypeSymbol newType, CSharpCodeGenerationOptions options, CancellationToken cancellationToken)
         {
             if (declaration is not CSharpSyntaxNode syntaxNode)
             {
@@ -699,7 +698,7 @@ public override TDeclarationNode UpdateDeclarationType<TDeclarationNode>(TDeclar
             {
                 case SyntaxKind.DelegateDeclaration:
                     // Handle delegate declarations.
-                    var delegateDeclarationSyntax = declaration as DelegateDeclarationSyntax;
+                    var delegateDeclarationSyntax = (DelegateDeclarationSyntax)syntaxNode;
                     newTypeSyntax = newType.GenerateTypeSyntax()
                         .WithLeadingTrivia(delegateDeclarationSyntax.ReturnType.GetLeadingTrivia())
                         .WithTrailingTrivia(delegateDeclarationSyntax.ReturnType.GetTrailingTrivia());
@@ -707,7 +706,7 @@ public override TDeclarationNode UpdateDeclarationType<TDeclarationNode>(TDeclar
 
                 case SyntaxKind.MethodDeclaration:
                     // Handle method declarations.
-                    var methodDeclarationSyntax = declaration as MethodDeclarationSyntax;
+                    var methodDeclarationSyntax = (MethodDeclarationSyntax)syntaxNode;
                     newTypeSyntax = newType.GenerateTypeSyntax()
                         .WithLeadingTrivia(methodDeclarationSyntax.ReturnType.GetLeadingTrivia())
                         .WithTrailingTrivia(methodDeclarationSyntax.ReturnType.GetTrailingTrivia());
@@ -715,7 +714,7 @@ public override TDeclarationNode UpdateDeclarationType<TDeclarationNode>(TDeclar
 
                 case SyntaxKind.OperatorDeclaration:
                     // Handle operator declarations.
-                    var operatorDeclarationSyntax = declaration as OperatorDeclarationSyntax;
+                    var operatorDeclarationSyntax = (OperatorDeclarationSyntax)syntaxNode;
                     newTypeSyntax = newType.GenerateTypeSyntax()
                         .WithLeadingTrivia(operatorDeclarationSyntax.ReturnType.GetLeadingTrivia())
                         .WithTrailingTrivia(operatorDeclarationSyntax.ReturnType.GetTrailingTrivia());
@@ -723,7 +722,7 @@ public override TDeclarationNode UpdateDeclarationType<TDeclarationNode>(TDeclar
 
                 case SyntaxKind.ConversionOperatorDeclaration:
                     // Handle conversion operator declarations.
-                    var conversionOperatorDeclarationSyntax = declaration as ConversionOperatorDeclarationSyntax;
+                    var conversionOperatorDeclarationSyntax = (ConversionOperatorDeclarationSyntax)syntaxNode;
                     newTypeSyntax = newType.GenerateTypeSyntax()
                         .WithLeadingTrivia(conversionOperatorDeclarationSyntax.Type.GetLeadingTrivia())
                         .WithTrailingTrivia(conversionOperatorDeclarationSyntax.Type.GetTrailingTrivia());
@@ -731,7 +730,7 @@ public override TDeclarationNode UpdateDeclarationType<TDeclarationNode>(TDeclar
 
                 case SyntaxKind.PropertyDeclaration:
                     // Handle properties.
-                    var propertyDeclaration = declaration as PropertyDeclarationSyntax;
+                    var propertyDeclaration = (PropertyDeclarationSyntax)syntaxNode;
                     newTypeSyntax = newType.GenerateTypeSyntax()
                         .WithLeadingTrivia(propertyDeclaration.Type.GetLeadingTrivia())
                         .WithTrailingTrivia(propertyDeclaration.Type.GetTrailingTrivia());
@@ -739,7 +738,7 @@ public override TDeclarationNode UpdateDeclarationType<TDeclarationNode>(TDeclar
 
                 case SyntaxKind.EventDeclaration:
                     // Handle events.
-                    var eventDeclarationSyntax = declaration as EventDeclarationSyntax;
+                    var eventDeclarationSyntax = (EventDeclarationSyntax)syntaxNode;
                     newTypeSyntax = newType.GenerateTypeSyntax()
                         .WithLeadingTrivia(eventDeclarationSyntax.Type.GetLeadingTrivia())
                         .WithTrailingTrivia(eventDeclarationSyntax.Type.GetTrailingTrivia());
@@ -747,7 +746,7 @@ public override TDeclarationNode UpdateDeclarationType<TDeclarationNode>(TDeclar
 
                 case SyntaxKind.IndexerDeclaration:
                     // Handle indexers.
-                    var indexerDeclarationSyntax = declaration as IndexerDeclarationSyntax;
+                    var indexerDeclarationSyntax = (IndexerDeclarationSyntax)syntaxNode;
                     newTypeSyntax = newType.GenerateTypeSyntax()
                         .WithLeadingTrivia(indexerDeclarationSyntax.Type.GetLeadingTrivia())
                         .WithTrailingTrivia(indexerDeclarationSyntax.Type.GetTrailingTrivia());
@@ -755,23 +754,35 @@ public override TDeclarationNode UpdateDeclarationType<TDeclarationNode>(TDeclar
 
                 case SyntaxKind.Parameter:
                     // Handle parameters.
-                    var parameterSyntax = declaration as ParameterSyntax;
-                    newTypeSyntax = newType.GenerateTypeSyntax()
-                        .WithLeadingTrivia(parameterSyntax.Type.GetLeadingTrivia())
-                        .WithTrailingTrivia(parameterSyntax.Type.GetTrailingTrivia());
+                    var parameterSyntax = (ParameterSyntax)syntaxNode;
+                    newTypeSyntax = newType.GenerateTypeSyntax();
+
+                    if (parameterSyntax.Type != null)
+                    {
+                        newTypeSyntax = newTypeSyntax
+                            .WithLeadingTrivia(parameterSyntax.Type.GetLeadingTrivia())
+                            .WithTrailingTrivia(parameterSyntax.Type.GetTrailingTrivia());
+                    }
+
                     return Cast<TDeclarationNode>(parameterSyntax.WithType(newTypeSyntax));
 
                 case SyntaxKind.IncompleteMember:
                     // Handle incomplete members.
-                    var incompleteMemberSyntax = declaration as IncompleteMemberSyntax;
-                    newTypeSyntax = newType.GenerateTypeSyntax()
-                        .WithLeadingTrivia(incompleteMemberSyntax.Type.GetLeadingTrivia())
-                        .WithTrailingTrivia(incompleteMemberSyntax.Type.GetTrailingTrivia());
+                    var incompleteMemberSyntax = (IncompleteMemberSyntax)syntaxNode;
+                    newTypeSyntax = newType.GenerateTypeSyntax();
+
+                    if (incompleteMemberSyntax.Type != null)
+                    {
+                        newTypeSyntax = newTypeSyntax
+                            .WithLeadingTrivia(incompleteMemberSyntax.Type.GetLeadingTrivia())
+                            .WithTrailingTrivia(incompleteMemberSyntax.Type.GetTrailingTrivia());
+                    }
+
                     return Cast<TDeclarationNode>(incompleteMemberSyntax.WithType(newTypeSyntax));
 
                 case SyntaxKind.ArrayType:
                     // Handle array type.
-                    var arrayTypeSyntax = declaration as ArrayTypeSyntax;
+                    var arrayTypeSyntax = (ArrayTypeSyntax)syntaxNode;
                     newTypeSyntax = newType.GenerateTypeSyntax()
                         .WithLeadingTrivia(arrayTypeSyntax.ElementType.GetLeadingTrivia())
                         .WithTrailingTrivia(arrayTypeSyntax.ElementType.GetTrailingTrivia());
@@ -779,7 +790,7 @@ public override TDeclarationNode UpdateDeclarationType<TDeclarationNode>(TDeclar
 
                 case SyntaxKind.PointerType:
                     // Handle pointer type.
-                    var pointerTypeSyntax = declaration as PointerTypeSyntax;
+                    var pointerTypeSyntax = (PointerTypeSyntax)syntaxNode;
                     newTypeSyntax = newType.GenerateTypeSyntax()
                         .WithLeadingTrivia(pointerTypeSyntax.ElementType.GetLeadingTrivia())
                         .WithTrailingTrivia(pointerTypeSyntax.ElementType.GetTrailingTrivia());
@@ -787,7 +798,7 @@ public override TDeclarationNode UpdateDeclarationType<TDeclarationNode>(TDeclar
 
                 case SyntaxKind.VariableDeclaration:
                     // Handle variable declarations.
-                    var variableDeclarationSyntax = declaration as VariableDeclarationSyntax;
+                    var variableDeclarationSyntax = (VariableDeclarationSyntax)syntaxNode;
                     newTypeSyntax = newType.GenerateTypeSyntax()
                         .WithLeadingTrivia(variableDeclarationSyntax.Type.GetLeadingTrivia())
                         .WithTrailingTrivia(variableDeclarationSyntax.Type.GetTrailingTrivia());
@@ -795,7 +806,7 @@ public override TDeclarationNode UpdateDeclarationType<TDeclarationNode>(TDeclar
 
                 case SyntaxKind.CatchDeclaration:
                     // Handle catch declarations.
-                    var catchDeclarationSyntax = declaration as CatchDeclarationSyntax;
+                    var catchDeclarationSyntax = (CatchDeclarationSyntax)syntaxNode;
                     newTypeSyntax = newType.GenerateTypeSyntax()
                         .WithLeadingTrivia(catchDeclarationSyntax.Type.GetLeadingTrivia())
                         .WithTrailingTrivia(catchDeclarationSyntax.Type.GetTrailingTrivia());
@@ -806,7 +817,7 @@ public override TDeclarationNode UpdateDeclarationType<TDeclarationNode>(TDeclar
             }
         }
 
-        public override TDeclarationNode UpdateDeclarationMembers<TDeclarationNode>(TDeclarationNode declaration, IList<ISymbol> newMembers, CodeGenerationOptions options = null, CancellationToken cancellationToken = default)
+        public override TDeclarationNode UpdateDeclarationMembers<TDeclarationNode>(TDeclarationNode declaration, IList<ISymbol> newMembers, CSharpCodeGenerationOptions options, CancellationToken cancellationToken)
         {
             if (declaration is MemberDeclarationSyntax memberDeclaration)
             {
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpCodeGenerationServiceFactory.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpCodeGenerationServiceFactory.cs
index 53d8202cec018..3a93d21c426a1 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpCodeGenerationServiceFactory.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpCodeGenerationServiceFactory.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System;
 using System.Composition;
 using Microsoft.CodeAnalysis.CodeGeneration;
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpDeclarationComparer.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpDeclarationComparer.cs
index 22366b11e111f..f755b96f241e4 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpDeclarationComparer.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpDeclarationComparer.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -69,8 +67,23 @@ internal class CSharpDeclarationComparer : IComparer<SyntaxNode>
         private CSharpDeclarationComparer(bool includeName)
             => _includeName = includeName;
 
-        public int Compare(SyntaxNode x, SyntaxNode y)
+        public int Compare(SyntaxNode? x, SyntaxNode? y)
         {
+            if (ReferenceEquals(x, y))
+            {
+                return 0;
+            }
+
+            if (x is null)
+            {
+                return -1;
+            }
+
+            if (y is null)
+            {
+                return 1;
+            }
+
             if (x.Kind() != y.Kind())
             {
                 if (!s_kindPrecedenceMap.TryGetValue(x.Kind(), out var xPrecedence) ||
@@ -162,8 +175,8 @@ private int Compare(BaseFieldDeclarationSyntax x, BaseFieldDeclarationSyntax y)
                 if (_includeName)
                 {
                     EqualIdentifierName(
-                        x.Declaration.Variables.FirstOrDefault().Identifier,
-                        y.Declaration.Variables.FirstOrDefault().Identifier,
+                        x.Declaration.Variables.First().Identifier,
+                        y.Declaration.Variables.First().Identifier,
                         out result);
                 }
             }
@@ -324,7 +337,7 @@ private enum Accessibility
             Private
         }
 
-        private static int GetAccessibilityPrecedence(SyntaxTokenList modifiers, SyntaxNode parent)
+        private static int GetAccessibilityPrecedence(SyntaxTokenList modifiers, SyntaxNode? parent)
         {
             if (ContainsToken(modifiers, SyntaxKind.PublicKeyword))
             {
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpFlagsEnumGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpFlagsEnumGenerator.cs
index 2d7c8e8581af8..fb30594207f25 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpFlagsEnumGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpFlagsEnumGenerator.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.Editing;
 using Roslyn.Utilities;
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs
index 8468718b34530..d59383bfc3cb9 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
@@ -93,7 +91,7 @@ internal override SyntaxNode DocumentationCommentTrivia(IEnumerable<SyntaxNode>
             return docTrivia.WithTrailingTrivia(SyntaxFactory.EndOfLine(endOfLineString));
         }
 
-        internal override SyntaxNode DocumentationCommentTriviaWithUpdatedContent(SyntaxTrivia trivia, IEnumerable<SyntaxNode> content)
+        internal override SyntaxNode? DocumentationCommentTriviaWithUpdatedContent(SyntaxTrivia trivia, IEnumerable<SyntaxNode> content)
         {
             if (trivia.GetStructure() is DocumentationCommentTriviaSyntax documentationCommentTrivia)
             {
@@ -120,7 +118,7 @@ private SyntaxList<UsingDirectiveSyntax> AsUsingDirectives(IEnumerable<SyntaxNod
                 : default;
         }
 
-        private SyntaxNode AsUsingDirective(SyntaxNode node)
+        private SyntaxNode? AsUsingDirective(SyntaxNode node)
         {
             if (node is NameSyntax name)
             {
@@ -137,7 +135,7 @@ private static SyntaxList<MemberDeclarationSyntax> AsNamespaceMembers(IEnumerabl
                 : default;
         }
 
-        private static SyntaxNode AsNamespaceMember(SyntaxNode declaration)
+        private static SyntaxNode? AsNamespaceMember(SyntaxNode declaration)
         {
             switch (declaration.Kind())
             {
@@ -176,7 +174,7 @@ public override SyntaxNode FieldDeclaration(
             SyntaxNode type,
             Accessibility accessibility,
             DeclarationModifiers modifiers,
-            SyntaxNode initializer)
+            SyntaxNode? initializer)
         {
             return SyntaxFactory.FieldDeclaration(
                 default,
@@ -190,12 +188,12 @@ public override SyntaxNode FieldDeclaration(
                             initializer != null ? SyntaxFactory.EqualsValueClause((ExpressionSyntax)initializer) : null))));
         }
 
-        public override SyntaxNode ParameterDeclaration(string name, SyntaxNode type, SyntaxNode initializer, RefKind refKind)
+        public override SyntaxNode ParameterDeclaration(string name, SyntaxNode? type, SyntaxNode? initializer, RefKind refKind)
         {
             return SyntaxFactory.Parameter(
                 default,
                 CSharpSyntaxGeneratorInternal.GetParameterModifiers(refKind),
-                (TypeSyntax)type,
+                (TypeSyntax?)type,
                 name.ToIdentifierToken(),
                 initializer != null ? SyntaxFactory.EqualsValueClause((ExpressionSyntax)initializer) : null);
         }
@@ -218,12 +216,12 @@ internal static SyntaxToken GetArgumentModifiers(RefKind refKind)
 
         public override SyntaxNode MethodDeclaration(
             string name,
-            IEnumerable<SyntaxNode> parameters,
-            IEnumerable<string> typeParameters,
-            SyntaxNode returnType,
+            IEnumerable<SyntaxNode>? parameters,
+            IEnumerable<string>? typeParameters,
+            SyntaxNode? returnType,
             Accessibility accessibility,
             DeclarationModifiers modifiers,
-            IEnumerable<SyntaxNode> statements)
+            IEnumerable<SyntaxNode>? statements)
         {
             var hasBody = !modifiers.IsAbstract && (!modifiers.IsPartial || statements != null);
 
@@ -241,7 +239,7 @@ public override SyntaxNode MethodDeclaration(
                 semicolonToken: !hasBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : default);
         }
 
-        public override SyntaxNode OperatorDeclaration(OperatorKind kind, IEnumerable<SyntaxNode> parameters = null, SyntaxNode returnType = null, Accessibility accessibility = Accessibility.NotApplicable, DeclarationModifiers modifiers = default, IEnumerable<SyntaxNode> statements = null)
+        public override SyntaxNode OperatorDeclaration(OperatorKind kind, IEnumerable<SyntaxNode>? parameters = null, SyntaxNode? returnType = null, Accessibility accessibility = Accessibility.NotApplicable, DeclarationModifiers modifiers = default, IEnumerable<SyntaxNode>? statements = null)
         {
             var hasBody = !modifiers.IsAbstract && (!modifiers.IsPartial || statements != null);
             var returnTypeNode = returnType != null ? (TypeSyntax)returnType : SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword));
@@ -300,7 +298,7 @@ private static SyntaxKind GetTokenKind(OperatorKind kind)
                 _ => throw new ArgumentException("Unknown operator kind."),
             };
 
-        private static ParameterListSyntax AsParameterList(IEnumerable<SyntaxNode> parameters)
+        private static ParameterListSyntax AsParameterList(IEnumerable<SyntaxNode>? parameters)
         {
             return parameters != null
                 ? SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(parameters.Cast<ParameterSyntax>()))
@@ -308,12 +306,12 @@ private static ParameterListSyntax AsParameterList(IEnumerable<SyntaxNode> param
         }
 
         public override SyntaxNode ConstructorDeclaration(
-            string name,
-            IEnumerable<SyntaxNode> parameters,
+            string? name,
+            IEnumerable<SyntaxNode>? parameters,
             Accessibility accessibility,
             DeclarationModifiers modifiers,
-            IEnumerable<SyntaxNode> baseConstructorArguments,
-            IEnumerable<SyntaxNode> statements)
+            IEnumerable<SyntaxNode>? baseConstructorArguments,
+            IEnumerable<SyntaxNode>? statements)
         {
             return SyntaxFactory.ConstructorDeclaration(
                 default,
@@ -329,8 +327,8 @@ public override SyntaxNode PropertyDeclaration(
             SyntaxNode type,
             Accessibility accessibility,
             DeclarationModifiers modifiers,
-            IEnumerable<SyntaxNode> getAccessorStatements,
-            IEnumerable<SyntaxNode> setAccessorStatements)
+            IEnumerable<SyntaxNode>? getAccessorStatements,
+            IEnumerable<SyntaxNode>? setAccessorStatements)
         {
             var accessors = new List<AccessorDeclarationSyntax>();
             var hasGetter = !modifiers.IsWriteOnly;
@@ -359,14 +357,14 @@ public override SyntaxNode PropertyDeclaration(
                 SyntaxFactory.AccessorList(SyntaxFactory.List(accessors)));
         }
 
-        public override SyntaxNode GetAccessorDeclaration(Accessibility accessibility, IEnumerable<SyntaxNode> statements)
+        public override SyntaxNode GetAccessorDeclaration(Accessibility accessibility, IEnumerable<SyntaxNode>? statements)
             => AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, accessibility, statements);
 
-        public override SyntaxNode SetAccessorDeclaration(Accessibility accessibility, IEnumerable<SyntaxNode> statements)
+        public override SyntaxNode SetAccessorDeclaration(Accessibility accessibility, IEnumerable<SyntaxNode>? statements)
             => AccessorDeclaration(SyntaxKind.SetAccessorDeclaration, accessibility, statements);
 
         private static SyntaxNode AccessorDeclaration(
-            SyntaxKind kind, Accessibility accessibility, IEnumerable<SyntaxNode> statements)
+            SyntaxKind kind, Accessibility accessibility, IEnumerable<SyntaxNode>? statements)
         {
             var accessor = SyntaxFactory.AccessorDeclaration(kind);
             accessor = accessor.WithModifiers(
@@ -393,12 +391,12 @@ public override SyntaxNode WithAccessorDeclarations(SyntaxNode declaration, IEnu
                 _ => declaration,
             };
 
-        private static AccessorListSyntax CreateAccessorList(AccessorListSyntax accessorListOpt, IEnumerable<SyntaxNode> accessorDeclarations)
+        private static AccessorListSyntax CreateAccessorList(AccessorListSyntax? accessorList, IEnumerable<SyntaxNode> accessorDeclarations)
         {
             var list = SyntaxFactory.List(accessorDeclarations.Cast<AccessorDeclarationSyntax>());
-            return accessorListOpt == null
+            return accessorList == null
                 ? SyntaxFactory.AccessorList(list)
-                : accessorListOpt.WithAccessors(list);
+                : accessorList.WithAccessors(list);
         }
 
         public override SyntaxNode IndexerDeclaration(
@@ -406,8 +404,8 @@ public override SyntaxNode IndexerDeclaration(
             SyntaxNode type,
             Accessibility accessibility,
             DeclarationModifiers modifiers,
-            IEnumerable<SyntaxNode> getAccessorStatements,
-            IEnumerable<SyntaxNode> setAccessorStatements)
+            IEnumerable<SyntaxNode>? getAccessorStatements,
+            IEnumerable<SyntaxNode>? setAccessorStatements)
         {
             var accessors = new List<AccessorDeclarationSyntax>();
             var hasGetter = !modifiers.IsWriteOnly;
@@ -447,7 +445,7 @@ public override SyntaxNode IndexerDeclaration(
                 default,
                 AsModifierList(accessibility, actualModifiers, SyntaxKind.IndexerDeclaration),
                 (TypeSyntax)type,
-                null,
+                explicitInterfaceSpecifier: null,
                 AsBracketedParameterList(parameters),
                 SyntaxFactory.AccessorList(SyntaxFactory.List(accessors)));
         }
@@ -459,7 +457,7 @@ private static BracketedParameterListSyntax AsBracketedParameterList(IEnumerable
                 : SyntaxFactory.BracketedParameterList();
         }
 
-        private static AccessorDeclarationSyntax AccessorDeclaration(SyntaxKind kind, IEnumerable<SyntaxNode> statements)
+        private static AccessorDeclarationSyntax AccessorDeclaration(SyntaxKind kind, IEnumerable<SyntaxNode>? statements)
         {
             var ad = SyntaxFactory.AccessorDeclaration(
                 kind,
@@ -493,9 +491,9 @@ public override SyntaxNode CustomEventDeclaration(
             SyntaxNode type,
             Accessibility accessibility,
             DeclarationModifiers modifiers,
-            IEnumerable<SyntaxNode> parameters,
-            IEnumerable<SyntaxNode> addAccessorStatements,
-            IEnumerable<SyntaxNode> removeAccessorStatements)
+            IEnumerable<SyntaxNode>? parameters,
+            IEnumerable<SyntaxNode>? addAccessorStatements,
+            IEnumerable<SyntaxNode>? removeAccessorStatements)
         {
             var accessors = new List<AccessorDeclarationSyntax>();
             if (modifiers.IsAbstract)
@@ -505,15 +503,8 @@ public override SyntaxNode CustomEventDeclaration(
             }
             else
             {
-                if (addAccessorStatements == null)
-                {
-                    addAccessorStatements = SpecializedCollections.EmptyEnumerable<SyntaxNode>();
-                }
-
-                if (removeAccessorStatements == null)
-                {
-                    removeAccessorStatements = SpecializedCollections.EmptyEnumerable<SyntaxNode>();
-                }
+                addAccessorStatements ??= SpecializedCollections.EmptyEnumerable<SyntaxNode>();
+                removeAccessorStatements ??= SpecializedCollections.EmptyEnumerable<SyntaxNode>();
             }
 
             accessors.Add(AccessorDeclaration(SyntaxKind.AddAccessorDeclaration, addAccessorStatements));
@@ -528,12 +519,12 @@ public override SyntaxNode CustomEventDeclaration(
                 SyntaxFactory.AccessorList(SyntaxFactory.List(accessors)));
         }
 
-        public override SyntaxNode AsPublicInterfaceImplementation(SyntaxNode declaration, SyntaxNode interfaceTypeName, string interfaceMemberName)
+        public override SyntaxNode? AsPublicInterfaceImplementation(SyntaxNode declaration, SyntaxNode interfaceTypeName, string? interfaceMemberName)
         {
             // C# interface implementations are implicit/not-specified -- so they are just named the name as the interface member
             return PreserveTrivia(declaration, d =>
             {
-                d = WithInterfaceSpecifier(d, null);
+                d = WithInterfaceSpecifier(d, specifier: null);
                 d = this.AsImplementation(d, Accessibility.Public);
 
                 if (interfaceMemberName != null)
@@ -545,7 +536,7 @@ public override SyntaxNode AsPublicInterfaceImplementation(SyntaxNode declaratio
             });
         }
 
-        public override SyntaxNode AsPrivateInterfaceImplementation(SyntaxNode declaration, SyntaxNode interfaceTypeName, string interfaceMemberName)
+        public override SyntaxNode? AsPrivateInterfaceImplementation(SyntaxNode declaration, SyntaxNode interfaceTypeName, string? interfaceMemberName)
         {
             return PreserveTrivia(declaration, d =>
             {
@@ -563,18 +554,18 @@ public override SyntaxNode AsPrivateInterfaceImplementation(SyntaxNode declarati
 
         private SyntaxNode WithoutConstraints(SyntaxNode declaration)
         {
-            if (declaration.IsKind(SyntaxKind.MethodDeclaration, out MethodDeclarationSyntax method))
+            if (declaration.IsKind(SyntaxKind.MethodDeclaration, out MethodDeclarationSyntax? method))
             {
                 if (method.ConstraintClauses.Count > 0)
                 {
-                    return this.RemoveNodes(method, method.ConstraintClauses);
+                    return RemoveNodes(method, method.ConstraintClauses);
                 }
             }
 
             return declaration;
         }
 
-        private static SyntaxNode WithInterfaceSpecifier(SyntaxNode declaration, ExplicitInterfaceSpecifierSyntax specifier)
+        private static SyntaxNode WithInterfaceSpecifier(SyntaxNode declaration, ExplicitInterfaceSpecifierSyntax? specifier)
             => declaration.Kind() switch
             {
                 SyntaxKind.MethodDeclaration => ((MethodDeclarationSyntax)declaration).WithExplicitInterfaceSpecifier(specifier),
@@ -598,22 +589,27 @@ private static SyntaxNode WithBodies(SyntaxNode declaration)
             {
                 case SyntaxKind.MethodDeclaration:
                     var method = (MethodDeclarationSyntax)declaration;
-                    return method.Body == null ? method.WithSemicolonToken(default).WithBody(CreateBlock(null)) : method;
+                    return (method.Body == null) ? method.WithSemicolonToken(default).WithBody(CreateBlock()) : method;
+
                 case SyntaxKind.OperatorDeclaration:
                     var op = (OperatorDeclarationSyntax)declaration;
-                    return op.Body == null ? op.WithSemicolonToken(default).WithBody(CreateBlock(null)) : op;
+                    return (op.Body == null) ? op.WithSemicolonToken(default).WithBody(CreateBlock()) : op;
+
                 case SyntaxKind.ConversionOperatorDeclaration:
                     var cop = (ConversionOperatorDeclarationSyntax)declaration;
-                    return cop.Body == null ? cop.WithSemicolonToken(default).WithBody(CreateBlock(null)) : cop;
+                    return (cop.Body == null) ? cop.WithSemicolonToken(default).WithBody(CreateBlock()) : cop;
+
                 case SyntaxKind.PropertyDeclaration:
                     var prop = (PropertyDeclarationSyntax)declaration;
-                    return prop.WithAccessorList(WithBodies(prop.AccessorList));
+                    return (prop.AccessorList != null) ? prop.WithAccessorList(WithBodies(prop.AccessorList)) : prop;
+
                 case SyntaxKind.IndexerDeclaration:
                     var ind = (IndexerDeclarationSyntax)declaration;
-                    return ind.WithAccessorList(WithBodies(ind.AccessorList));
+                    return (ind.AccessorList != null) ? ind.WithAccessorList(WithBodies(ind.AccessorList)) : ind;
+
                 case SyntaxKind.EventDeclaration:
                     var ev = (EventDeclarationSyntax)declaration;
-                    return ev.WithAccessorList(WithBodies(ev.AccessorList));
+                    return (ev.AccessorList != null) ? ev.WithAccessorList(WithBodies(ev.AccessorList)) : ev;
             }
 
             return declaration;
@@ -634,22 +630,22 @@ private static AccessorDeclarationSyntax WithBody(AccessorDeclarationSyntax acce
             }
         }
 
-        private static AccessorListSyntax WithoutBodies(AccessorListSyntax accessorList)
-            => accessorList.WithAccessors(SyntaxFactory.List(accessorList.Accessors.Select(WithoutBody)));
+        private static AccessorListSyntax? WithoutBodies(AccessorListSyntax? accessorList)
+            => accessorList?.WithAccessors(SyntaxFactory.List(accessorList.Accessors.Select(WithoutBody)));
 
         private static AccessorDeclarationSyntax WithoutBody(AccessorDeclarationSyntax accessor)
             => accessor.Body != null ? accessor.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)).WithBody(null) : accessor;
 
         public override SyntaxNode ClassDeclaration(
             string name,
-            IEnumerable<string> typeParameters,
+            IEnumerable<string>? typeParameters,
             Accessibility accessibility,
             DeclarationModifiers modifiers,
-            SyntaxNode baseType,
-            IEnumerable<SyntaxNode> interfaceTypes,
-            IEnumerable<SyntaxNode> members)
+            SyntaxNode? baseType,
+            IEnumerable<SyntaxNode>? interfaceTypes,
+            IEnumerable<SyntaxNode>? members)
         {
-            List<BaseTypeSyntax> baseTypes = null;
+            List<BaseTypeSyntax>? baseTypes = null;
             if (baseType != null || interfaceTypes != null)
             {
                 baseTypes = new List<BaseTypeSyntax>();
@@ -680,14 +676,14 @@ public override SyntaxNode ClassDeclaration(
                 this.AsClassMembers(name, members));
         }
 
-        private SyntaxList<MemberDeclarationSyntax> AsClassMembers(string className, IEnumerable<SyntaxNode> members)
+        private SyntaxList<MemberDeclarationSyntax> AsClassMembers(string className, IEnumerable<SyntaxNode>? members)
         {
             return members != null
-                ? SyntaxFactory.List(members.Select(m => this.AsClassMember(m, className)).Where(m => m != null))
+                ? SyntaxFactory.List(members.Select(m => AsClassMember(m, className)).WhereNotNull())
                 : default;
         }
 
-        private MemberDeclarationSyntax AsClassMember(SyntaxNode node, string className)
+        private MemberDeclarationSyntax? AsClassMember(SyntaxNode node, string className)
         {
             switch (node.Kind())
             {
@@ -697,7 +693,7 @@ private MemberDeclarationSyntax AsClassMember(SyntaxNode node, string className)
 
                 case SyntaxKind.VariableDeclaration:
                 case SyntaxKind.VariableDeclarator:
-                    node = this.AsIsolatedDeclaration(node);
+                    node = AsIsolatedDeclaration(node);
                     break;
             }
 
@@ -706,11 +702,11 @@ private MemberDeclarationSyntax AsClassMember(SyntaxNode node, string className)
 
         public override SyntaxNode StructDeclaration(
             string name,
-            IEnumerable<string> typeParameters,
+            IEnumerable<string>? typeParameters,
             Accessibility accessibility,
             DeclarationModifiers modifiers,
-            IEnumerable<SyntaxNode> interfaceTypes,
-            IEnumerable<SyntaxNode> members)
+            IEnumerable<SyntaxNode>? interfaceTypes,
+            IEnumerable<SyntaxNode>? members)
         {
             var itypes = interfaceTypes?.Select(i => (BaseTypeSyntax)SyntaxFactory.SimpleBaseType((TypeSyntax)i)).ToList();
             if (itypes?.Count == 0)
@@ -730,10 +726,10 @@ public override SyntaxNode StructDeclaration(
 
         public override SyntaxNode InterfaceDeclaration(
             string name,
-            IEnumerable<string> typeParameters,
+            IEnumerable<string>? typeParameters,
             Accessibility accessibility,
-            IEnumerable<SyntaxNode> interfaceTypes = null,
-            IEnumerable<SyntaxNode> members = null)
+            IEnumerable<SyntaxNode>? interfaceTypes = null,
+            IEnumerable<SyntaxNode>? members = null)
         {
             var itypes = interfaceTypes?.Select(i => (BaseTypeSyntax)SyntaxFactory.SimpleBaseType((TypeSyntax)i)).ToList();
             if (itypes?.Count == 0)
@@ -751,16 +747,16 @@ public override SyntaxNode InterfaceDeclaration(
                 this.AsInterfaceMembers(members));
         }
 
-        private SyntaxList<MemberDeclarationSyntax> AsInterfaceMembers(IEnumerable<SyntaxNode> members)
+        private SyntaxList<MemberDeclarationSyntax> AsInterfaceMembers(IEnumerable<SyntaxNode>? members)
         {
             return members != null
-                ? SyntaxFactory.List(members.Select(this.AsInterfaceMember).OfType<MemberDeclarationSyntax>())
+                ? SyntaxFactory.List(members.Select(AsInterfaceMember).OfType<MemberDeclarationSyntax>())
                 : default;
         }
 
         internal override SyntaxNode AsInterfaceMember(SyntaxNode m)
         {
-            return this.Isolate(m, member =>
+            return Isolate(m, member =>
             {
                 Accessibility acc;
                 DeclarationModifiers modifiers;
@@ -802,11 +798,15 @@ internal override SyntaxNode AsInterfaceMember(SyntaxNode m)
                     case SyntaxKind.FieldDeclaration:
                         var f = (FieldDeclarationSyntax)member;
                         GetAccessibilityAndModifiers(f.Modifiers, out acc, out modifiers, out _);
-                        return this.AsInterfaceMember(
-                            this.PropertyDeclaration(this.GetName(f), this.ClearTrivia(this.GetType(f)), acc, modifiers, getAccessorStatements: null, setAccessorStatements: null));
+
+                        var type = GetType(f);
+                        Contract.ThrowIfNull(type);
+
+                        return AsInterfaceMember(
+                            PropertyDeclaration(GetName(f), ClearTrivia(type), acc, modifiers, getAccessorStatements: null, setAccessorStatements: null));
 
                     default:
-                        return null;
+                        throw ExceptionUtilities.UnexpectedValue(member.Kind());
                 }
             });
         }
@@ -815,12 +815,12 @@ public override SyntaxNode EnumDeclaration(
             string name,
             Accessibility accessibility,
             DeclarationModifiers modifiers,
-            IEnumerable<SyntaxNode> members)
+            IEnumerable<SyntaxNode>? members)
         {
             return EnumDeclaration(name, underlyingType: null, accessibility, modifiers, members);
         }
 
-        internal override SyntaxNode EnumDeclaration(string name, SyntaxNode underlyingType, Accessibility accessibility = Accessibility.NotApplicable, DeclarationModifiers modifiers = default, IEnumerable<SyntaxNode> members = null)
+        internal override SyntaxNode EnumDeclaration(string name, SyntaxNode? underlyingType, Accessibility accessibility = Accessibility.NotApplicable, DeclarationModifiers modifiers = default, IEnumerable<SyntaxNode>? members = null)
         {
             return SyntaxFactory.EnumDeclaration(
                 default,
@@ -830,7 +830,7 @@ internal override SyntaxNode EnumDeclaration(string name, SyntaxNode underlyingT
                 this.AsEnumMembers(members));
         }
 
-        public override SyntaxNode EnumMember(string name, SyntaxNode expression)
+        public override SyntaxNode EnumMember(string name, SyntaxNode? expression)
         {
             return SyntaxFactory.EnumMemberDeclaration(
                 default,
@@ -860,14 +860,14 @@ private EnumMemberDeclarationSyntax AsEnumMember(SyntaxNode node)
             return (EnumMemberDeclarationSyntax)node;
         }
 
-        private SeparatedSyntaxList<EnumMemberDeclarationSyntax> AsEnumMembers(IEnumerable<SyntaxNode> members)
+        private SeparatedSyntaxList<EnumMemberDeclarationSyntax> AsEnumMembers(IEnumerable<SyntaxNode>? members)
             => members != null ? SyntaxFactory.SeparatedList(members.Select(this.AsEnumMember)) : default;
 
         public override SyntaxNode DelegateDeclaration(
             string name,
-            IEnumerable<SyntaxNode> parameters,
-            IEnumerable<string> typeParameters,
-            SyntaxNode returnType,
+            IEnumerable<SyntaxNode>? parameters,
+            IEnumerable<string>? typeParameters,
+            SyntaxNode? returnType,
             Accessibility accessibility = Accessibility.NotApplicable,
             DeclarationModifiers modifiers = default)
         {
@@ -881,17 +881,17 @@ public override SyntaxNode DelegateDeclaration(
                 default);
         }
 
-        public override SyntaxNode Attribute(SyntaxNode name, IEnumerable<SyntaxNode> attributeArguments)
+        public override SyntaxNode Attribute(SyntaxNode name, IEnumerable<SyntaxNode>? attributeArguments)
             => AsAttributeList(SyntaxFactory.Attribute((NameSyntax)name, AsAttributeArgumentList(attributeArguments)));
 
-        public override SyntaxNode AttributeArgument(string name, SyntaxNode expression)
+        public override SyntaxNode AttributeArgument(string? name, SyntaxNode expression)
         {
             return name != null
-                ? SyntaxFactory.AttributeArgument(SyntaxFactory.NameEquals(name.ToIdentifierName()), null, (ExpressionSyntax)expression)
+                ? SyntaxFactory.AttributeArgument(SyntaxFactory.NameEquals(name.ToIdentifierName()), nameColon: null, (ExpressionSyntax)expression)
                 : SyntaxFactory.AttributeArgument((ExpressionSyntax)expression);
         }
 
-        private static AttributeArgumentListSyntax AsAttributeArgumentList(IEnumerable<SyntaxNode> arguments)
+        private static AttributeArgumentListSyntax? AsAttributeArgumentList(IEnumerable<SyntaxNode>? arguments)
         {
             if (arguments != null)
             {
@@ -918,7 +918,8 @@ private static AttributeArgumentSyntax AsAttributeArgument(SyntaxNode node)
             return (AttributeArgumentSyntax)node;
         }
 
-        public override TNode ClearTrivia<TNode>(TNode node)
+        [return: MaybeNull, NotNullIfNotNull("node")]
+        public override TNode ClearTrivia<TNode>([MaybeNull] TNode node)
         {
             if (node != null)
             {
@@ -1105,7 +1106,7 @@ private static SyntaxNode InsertAttributeArgumentsInternal(SyntaxNode declaratio
             }
         }
 
-        private static AttributeArgumentListSyntax GetAttributeArgumentList(SyntaxNode declaration)
+        private static AttributeArgumentListSyntax? GetAttributeArgumentList(SyntaxNode declaration)
         {
             switch (declaration.Kind())
             {
@@ -1125,7 +1126,7 @@ private static AttributeArgumentListSyntax GetAttributeArgumentList(SyntaxNode d
             return null;
         }
 
-        private static SyntaxNode WithAttributeArgumentList(SyntaxNode declaration, AttributeArgumentListSyntax argList)
+        private static SyntaxNode WithAttributeArgumentList(SyntaxNode declaration, AttributeArgumentListSyntax? argList)
         {
             switch (declaration.Kind())
             {
@@ -1181,7 +1182,11 @@ public override IReadOnlyList<SyntaxNode> GetNamespaceImports(SyntaxNode declara
             };
 
         public override SyntaxNode InsertNamespaceImports(SyntaxNode declaration, int index, IEnumerable<SyntaxNode> imports)
-            => PreserveTrivia(declaration, d => this.InsertNamespaceImportsInternal(d, index, imports));
+        {
+            var result = PreserveTrivia(declaration, d => InsertNamespaceImportsInternal(d, index, imports));
+            Contract.ThrowIfNull(result);
+            return result;
+        }
 
         private SyntaxNode InsertNamespaceImportsInternal(SyntaxNode declaration, int index, IEnumerable<SyntaxNode> imports)
         {
@@ -1314,15 +1319,16 @@ public override SyntaxNode InsertMembers(SyntaxNode declaration, int index, IEnu
             }
         }
 
-        private IEnumerable<MemberDeclarationSyntax> AsMembersOf(SyntaxNode declaration, IEnumerable<SyntaxNode> members)
-            => members?.Select(m => this.AsMemberOf(declaration, m)).OfType<MemberDeclarationSyntax>();
+        [return: NotNullIfNotNull("members")]
+        private IEnumerable<MemberDeclarationSyntax>? AsMembersOf(SyntaxNode declaration, IEnumerable<SyntaxNode>? members)
+            => members?.Select(m => AsMemberOf(declaration, m)).OfType<MemberDeclarationSyntax>();
 
-        private SyntaxNode AsMemberOf(SyntaxNode declaration, SyntaxNode member)
+        private SyntaxNode? AsMemberOf(SyntaxNode declaration, SyntaxNode member)
             => declaration switch
             {
-                InterfaceDeclarationSyntax => this.AsInterfaceMember(member),
-                TypeDeclarationSyntax typeDeclaration => this.AsClassMember(member, typeDeclaration.Identifier.Text),
-                EnumDeclarationSyntax => this.AsEnumMember(member),
+                InterfaceDeclarationSyntax => AsInterfaceMember(member),
+                TypeDeclarationSyntax typeDeclaration => AsClassMember(member, typeDeclaration.Identifier.Text),
+                EnumDeclarationSyntax => AsEnumMember(member),
                 BaseNamespaceDeclarationSyntax => AsNamespaceMember(member),
                 CompilationUnitSyntax => AsNamespaceMember(member),
                 _ => null,
@@ -1649,7 +1655,7 @@ private static SyntaxTokenList AsModifierList(Accessibility accessibility, Decla
             return SyntaxFactory.TokenList(list);
         }
 
-        private static TypeParameterListSyntax AsTypeParameterList(IEnumerable<string> typeParameterNames)
+        private static TypeParameterListSyntax? AsTypeParameterList(IEnumerable<string>? typeParameterNames)
         {
             var typeParameters = typeParameterNames != null
                 ? SyntaxFactory.TypeParameterList(SyntaxFactory.SeparatedList(typeParameterNames.Select(name => SyntaxFactory.TypeParameter(name))))
@@ -1663,7 +1669,7 @@ private static TypeParameterListSyntax AsTypeParameterList(IEnumerable<string> t
             return typeParameters;
         }
 
-        public override SyntaxNode WithTypeParameters(SyntaxNode declaration, IEnumerable<string> typeParameterNames)
+        public override SyntaxNode WithTypeParameters(SyntaxNode declaration, IEnumerable<string>? typeParameterNames)
         {
             var typeParameters = AsTypeParameterList(typeParameterNames);
 
@@ -1688,7 +1694,7 @@ internal override SyntaxNode WithExplicitInterfaceImplementations(SyntaxNode dec
         private static ExplicitInterfaceSpecifierSyntax CreateExplicitInterfaceSpecifier(ImmutableArray<ISymbol> explicitInterfaceImplementations)
             => SyntaxFactory.ExplicitInterfaceSpecifier(explicitInterfaceImplementations[0].ContainingType.GenerateNameSyntax());
 
-        public override SyntaxNode WithTypeConstraint(SyntaxNode declaration, string typeParameterName, SpecialTypeConstraintKind kinds, IEnumerable<SyntaxNode> types)
+        public override SyntaxNode WithTypeConstraint(SyntaxNode declaration, string typeParameterName, SpecialTypeConstraintKind kinds, IEnumerable<SyntaxNode>? types)
             => declaration switch
             {
                 MethodDeclarationSyntax method => method.WithConstraintClauses(WithTypeConstraints(method.ConstraintClauses, typeParameterName, kinds, types)),
@@ -1698,7 +1704,7 @@ public override SyntaxNode WithTypeConstraint(SyntaxNode declaration, string typ
             };
 
         private static SyntaxList<TypeParameterConstraintClauseSyntax> WithTypeConstraints(
-            SyntaxList<TypeParameterConstraintClauseSyntax> clauses, string typeParameterName, SpecialTypeConstraintKind kinds, IEnumerable<SyntaxNode> types)
+            SyntaxList<TypeParameterConstraintClauseSyntax> clauses, string typeParameterName, SpecialTypeConstraintKind kinds, IEnumerable<SyntaxNode>? types)
         {
             var constraints = types != null
                 ? SyntaxFactory.SeparatedList<TypeParameterConstraintSyntax>(types.Select(t => SyntaxFactory.TypeConstraint((TypeSyntax)t)))
@@ -1805,7 +1811,7 @@ private SyntaxNode WithNameInternal(SyntaxNode declaration, string name)
             };
         }
 
-        public override SyntaxNode GetType(SyntaxNode declaration)
+        public override SyntaxNode? GetType(SyntaxNode declaration)
         {
             switch (declaration.Kind())
             {
@@ -1841,11 +1847,11 @@ public override SyntaxNode GetType(SyntaxNode declaration)
             return null;
         }
 
-        private static TypeSyntax NotVoid(TypeSyntax type)
+        private static TypeSyntax? NotVoid(TypeSyntax type)
             => type is PredefinedTypeSyntax pd && pd.Keyword.IsKind(SyntaxKind.VoidKeyword) ? null : type;
 
         public override SyntaxNode WithType(SyntaxNode declaration, SyntaxNode type)
-            => this.Isolate(declaration, d => WithTypeInternal(d, type));
+            => Isolate(declaration, d => WithTypeInternal(d, type));
 
         private static SyntaxNode WithTypeInternal(SyntaxNode declaration, SyntaxNode type)
             => declaration.Kind() switch
@@ -1864,46 +1870,39 @@ private static SyntaxNode WithTypeInternal(SyntaxNode declaration, SyntaxNode ty
             };
 
         private SyntaxNode Isolate(SyntaxNode declaration, Func<SyntaxNode, SyntaxNode> editor)
-        {
-            var isolated = this.AsIsolatedDeclaration(declaration);
-
-            return PreserveTrivia(isolated, editor);
-        }
+            => PreserveTrivia(AsIsolatedDeclaration(declaration), editor);
 
         private SyntaxNode AsIsolatedDeclaration(SyntaxNode declaration)
         {
-            if (declaration != null)
+            switch (declaration.Kind())
             {
-                switch (declaration.Kind())
-                {
-                    case SyntaxKind.VariableDeclaration:
-                        var vd = (VariableDeclarationSyntax)declaration;
-                        if (vd.Parent != null && vd.Variables.Count == 1)
-                        {
-                            return this.AsIsolatedDeclaration(vd.Parent);
-                        }
+                case SyntaxKind.VariableDeclaration:
+                    var vd = (VariableDeclarationSyntax)declaration;
+                    if (vd.Parent != null && vd.Variables.Count == 1)
+                    {
+                        return AsIsolatedDeclaration(vd.Parent);
+                    }
 
-                        break;
+                    break;
 
-                    case SyntaxKind.VariableDeclarator:
-                        var v = (VariableDeclaratorSyntax)declaration;
-                        if (v.Parent != null && v.Parent.Parent != null)
-                        {
-                            return this.ClearTrivia(WithVariable(v.Parent.Parent, v));
-                        }
+                case SyntaxKind.VariableDeclarator:
+                    var v = (VariableDeclaratorSyntax)declaration;
+                    if (v.Parent != null && v.Parent.Parent != null)
+                    {
+                        return ClearTrivia(WithVariable(v.Parent.Parent, v));
+                    }
 
-                        break;
+                    break;
 
-                    case SyntaxKind.Attribute:
-                        var attr = (AttributeSyntax)declaration;
-                        if (attr.Parent != null)
-                        {
-                            var attrList = (AttributeListSyntax)attr.Parent;
-                            return attrList.WithAttributes(SyntaxFactory.SingletonSeparatedList(attr)).WithTarget(null);
-                        }
+                case SyntaxKind.Attribute:
+                    var attr = (AttributeSyntax)declaration;
+                    if (attr.Parent != null)
+                    {
+                        var attrList = (AttributeListSyntax)attr.Parent;
+                        return attrList.WithAttributes(SyntaxFactory.SingletonSeparatedList(attr)).WithTarget(null);
+                    }
 
-                        break;
-                }
+                    break;
             }
 
             return declaration;
@@ -1920,7 +1919,7 @@ private static SyntaxNode WithVariable(SyntaxNode declaration, VariableDeclarato
             return declaration;
         }
 
-        private static VariableDeclarationSyntax GetVariableDeclaration(SyntaxNode declaration)
+        private static VariableDeclarationSyntax? GetVariableDeclaration(SyntaxNode declaration)
             => declaration.Kind() switch
             {
                 SyntaxKind.FieldDeclaration => ((FieldDeclarationSyntax)declaration).Declaration,
@@ -1948,6 +1947,7 @@ private static SyntaxNode GetFullDeclaration(SyntaxNode declaration)
                         || CSharpAccessibilityFacts.ParentIsEventFieldDeclaration(vd)
                         || CSharpAccessibilityFacts.ParentIsLocalDeclarationStatement(vd))
                     {
+                        Contract.ThrowIfNull(vd.Parent);
                         return vd.Parent;
                     }
                     else
@@ -1968,9 +1968,9 @@ private static SyntaxNode GetFullDeclaration(SyntaxNode declaration)
             return declaration;
         }
 
-        private SyntaxNode AsNodeLike(SyntaxNode existingNode, SyntaxNode newNode)
+        private SyntaxNode? AsNodeLike(SyntaxNode existingNode, SyntaxNode newNode)
         {
-            switch (this.GetDeclarationKind(existingNode))
+            switch (GetDeclarationKind(existingNode))
             {
                 case DeclarationKind.Class:
                 case DeclarationKind.Interface:
@@ -1978,10 +1978,10 @@ private SyntaxNode AsNodeLike(SyntaxNode existingNode, SyntaxNode newNode)
                 case DeclarationKind.Enum:
                 case DeclarationKind.Namespace:
                 case DeclarationKind.CompilationUnit:
-                    var container = this.GetDeclaration(existingNode.Parent);
+                    var container = GetDeclaration(existingNode.Parent);
                     if (container != null)
                     {
-                        return this.AsMemberOf(container, newNode);
+                        return AsMemberOf(container, newNode);
                     }
 
                     break;
@@ -2051,7 +2051,8 @@ private class AddMissingTokensRewriter : CSharpSyntaxRewriter
             public AddMissingTokensRewriter(bool recurse)
                 => _recurse = recurse;
 
-            public override SyntaxNode Visit(SyntaxNode node)
+            [return: NotNullIfNotNull("node")]
+            public override SyntaxNode? Visit(SyntaxNode? node)
             {
                 if (!_recurse && !_firstVisit)
                 {
@@ -2074,7 +2075,7 @@ public override SyntaxToken VisitToken(SyntaxToken token)
             }
         }
 
-        internal override SyntaxNode GetParameterListNode(SyntaxNode declaration)
+        internal override SyntaxNode? GetParameterListNode(SyntaxNode declaration)
             => declaration.GetParameterList();
 
         private static SyntaxNode WithParameterList(SyntaxNode declaration, BaseParameterListSyntax list)
@@ -2120,7 +2121,7 @@ private static SyntaxNode WithParameterList(SyntaxNode declaration, BaseParamete
             }
         }
 
-        public override SyntaxNode GetExpression(SyntaxNode declaration)
+        public override SyntaxNode? GetExpression(SyntaxNode declaration)
         {
             switch (declaration.Kind())
             {
@@ -2180,10 +2181,10 @@ private static SyntaxNode WithExpressionInternal(SyntaxNode declaration, SyntaxN
             switch (declaration.Kind())
             {
                 case SyntaxKind.ParenthesizedLambdaExpression:
-                    return ((ParenthesizedLambdaExpressionSyntax)declaration).WithBody((CSharpSyntaxNode)expr ?? CreateBlock(null));
+                    return ((ParenthesizedLambdaExpressionSyntax)declaration).WithBody((CSharpSyntaxNode)expr ?? CreateBlock());
 
                 case SyntaxKind.SimpleLambdaExpression:
-                    return ((SimpleLambdaExpressionSyntax)declaration).WithBody((CSharpSyntaxNode)expr ?? CreateBlock(null));
+                    return ((SimpleLambdaExpressionSyntax)declaration).WithBody((CSharpSyntaxNode)expr ?? CreateBlock());
 
                 case SyntaxKind.PropertyDeclaration:
                     var pd = (PropertyDeclarationSyntax)declaration;
@@ -2227,7 +2228,7 @@ private static SyntaxNode WithExpressionInternal(SyntaxNode declaration, SyntaxN
                     {
                         if (expression == null)
                         {
-                            return WithEqualsValue(declaration, null);
+                            return WithEqualsValue(declaration, initializer: null);
                         }
                         else
                         {
@@ -2246,7 +2247,7 @@ private static SyntaxNode WithExpressionInternal(SyntaxNode declaration, SyntaxN
             }
         }
 
-        private static EqualsValueClauseSyntax GetEqualsValue(SyntaxNode declaration)
+        private static EqualsValueClauseSyntax? GetEqualsValue(SyntaxNode declaration)
         {
             switch (declaration.Kind())
             {
@@ -2286,7 +2287,7 @@ private static EqualsValueClauseSyntax GetEqualsValue(SyntaxNode declaration)
             return null;
         }
 
-        private static SyntaxNode WithEqualsValue(SyntaxNode declaration, EqualsValueClauseSyntax eq)
+        private static SyntaxNode WithEqualsValue(SyntaxNode declaration, EqualsValueClauseSyntax? initializer)
         {
             switch (declaration.Kind())
             {
@@ -2294,18 +2295,18 @@ private static SyntaxNode WithEqualsValue(SyntaxNode declaration, EqualsValueCla
                     var fd = (FieldDeclarationSyntax)declaration;
                     if (fd.Declaration.Variables.Count == 1)
                     {
-                        return ReplaceWithTrivia(declaration, fd.Declaration.Variables[0], fd.Declaration.Variables[0].WithInitializer(eq));
+                        return ReplaceWithTrivia(declaration, fd.Declaration.Variables[0], fd.Declaration.Variables[0].WithInitializer(initializer));
                     }
 
                     break;
                 case SyntaxKind.PropertyDeclaration:
                     var pd = (PropertyDeclarationSyntax)declaration;
-                    return pd.WithInitializer(eq);
+                    return pd.WithInitializer(initializer);
                 case SyntaxKind.LocalDeclarationStatement:
                     var ld = (LocalDeclarationStatementSyntax)declaration;
                     if (ld.Declaration.Variables.Count == 1)
                     {
-                        return ReplaceWithTrivia(declaration, ld.Declaration.Variables[0], ld.Declaration.Variables[0].WithInitializer(eq));
+                        return ReplaceWithTrivia(declaration, ld.Declaration.Variables[0], ld.Declaration.Variables[0].WithInitializer(initializer));
                     }
 
                     break;
@@ -2313,14 +2314,14 @@ private static SyntaxNode WithEqualsValue(SyntaxNode declaration, EqualsValueCla
                     var vd = (VariableDeclarationSyntax)declaration;
                     if (vd.Variables.Count == 1)
                     {
-                        return ReplaceWithTrivia(declaration, vd.Variables[0], vd.Variables[0].WithInitializer(eq));
+                        return ReplaceWithTrivia(declaration, vd.Variables[0], vd.Variables[0].WithInitializer(initializer));
                     }
 
                     break;
                 case SyntaxKind.VariableDeclarator:
-                    return ((VariableDeclaratorSyntax)declaration).WithInitializer(eq);
+                    return ((VariableDeclaratorSyntax)declaration).WithInitializer(initializer);
                 case SyntaxKind.Parameter:
-                    return ((ParameterSyntax)declaration).WithDefault(eq);
+                    return ((ParameterSyntax)declaration).WithDefault(initializer);
             }
 
             return declaration;
@@ -2423,7 +2424,7 @@ public override SyntaxNode InsertAccessors(SyntaxNode declaration, int index, IE
             return WithAccessorList(declaration, newList);
         }
 
-        internal static AccessorListSyntax GetAccessorList(SyntaxNode declaration)
+        internal static AccessorListSyntax? GetAccessorList(SyntaxNode declaration)
             => (declaration as BasePropertyDeclarationSyntax)?.AccessorList;
 
         private static bool CanHaveAccessors(SyntaxNode declaration)
@@ -2445,10 +2446,10 @@ private static SyntaxNode WithAccessorList(SyntaxNode declaration, AccessorListS
         private static AccessorListSyntax AsAccessorList(IEnumerable<SyntaxNode> nodes, SyntaxKind parentKind)
         {
             return SyntaxFactory.AccessorList(
-                SyntaxFactory.List(nodes.Select(n => AsAccessor(n, parentKind)).Where(n => n != null)));
+                SyntaxFactory.List(nodes.Select(n => AsAccessor(n, parentKind)).WhereNotNull()));
         }
 
-        private static AccessorDeclarationSyntax AsAccessor(SyntaxNode node, SyntaxKind parentKind)
+        private static AccessorDeclarationSyntax? AsAccessor(SyntaxNode node, SyntaxKind parentKind)
         {
             switch (parentKind)
             {
@@ -2476,16 +2477,16 @@ private static AccessorDeclarationSyntax AsAccessor(SyntaxNode node, SyntaxKind
             return null;
         }
 
-        private static AccessorDeclarationSyntax GetAccessor(SyntaxNode declaration, SyntaxKind kind)
+        private static AccessorDeclarationSyntax? GetAccessor(SyntaxNode declaration, SyntaxKind kind)
         {
             var accessorList = GetAccessorList(declaration);
             return accessorList?.Accessors.FirstOrDefault(a => a.IsKind(kind));
         }
 
         private SyntaxNode WithAccessor(SyntaxNode declaration, SyntaxKind kind, AccessorDeclarationSyntax accessor)
-            => this.WithAccessor(declaration, GetAccessorList(declaration), kind, accessor);
+            => WithAccessor(declaration, GetAccessorList(declaration), kind, accessor);
 
-        private SyntaxNode WithAccessor(SyntaxNode declaration, AccessorListSyntax accessorList, SyntaxKind kind, AccessorDeclarationSyntax accessor)
+        private SyntaxNode WithAccessor(SyntaxNode declaration, AccessorListSyntax? accessorList, SyntaxKind kind, AccessorDeclarationSyntax? accessor)
         {
             if (accessorList != null)
             {
@@ -2581,10 +2582,10 @@ private static SyntaxNode AddBaseList(SyntaxNode declaration, BaseListSyntax bas
             var newDecl = WithBaseList(declaration, baseList);
 
             // move trivia from type identifier to after base list
-            return ShiftTrivia(newDecl, GetBaseList(newDecl));
+            return ShiftTrivia(newDecl, GetBaseList(newDecl)!);
         }
 
-        private static BaseListSyntax GetBaseList(SyntaxNode declaration)
+        private static BaseListSyntax? GetBaseList(SyntaxNode declaration)
             => declaration is TypeDeclarationSyntax typeDeclaration
                 ? typeDeclaration.BaseList
                 : null;
@@ -2598,18 +2599,22 @@ private static SyntaxNode WithBaseList(SyntaxNode declaration, BaseListSyntax ba
 
         #region Remove, Replace, Insert
 
-        public override SyntaxNode ReplaceNode(SyntaxNode root, SyntaxNode declaration, SyntaxNode newDeclaration)
+        public override SyntaxNode ReplaceNode(SyntaxNode root, SyntaxNode declaration, SyntaxNode? newDeclaration)
         {
-            newDeclaration = this.AsNodeLike(declaration, newDeclaration);
+            if (newDeclaration == null)
+            {
+                return RemoveNode(root, declaration);
+            }
 
+            newDeclaration = AsNodeLike(declaration, newDeclaration);
             if (newDeclaration == null)
             {
-                return this.RemoveNode(root, declaration);
+                return RemoveNode(root, declaration);
             }
 
             if (root.Span.Contains(declaration.Span))
             {
-                var newFullDecl = this.AsIsolatedDeclaration(newDeclaration);
+                var newFullDecl = AsIsolatedDeclaration(newDeclaration);
                 var fullDecl = GetFullDeclaration(declaration);
 
                 // special handling for replacing at location of sub-declaration
@@ -2626,10 +2631,10 @@ public override SyntaxNode ReplaceNode(SyntaxNode root, SyntaxNode declaration,
                     }
 
                     // replace sub declaration by splitting full declaration and inserting between
-                    var index = this.IndexOf(GetSubDeclarations(fullDecl), declaration);
+                    var index = IndexOf(GetSubDeclarations(fullDecl), declaration);
 
                     // replace declaration with multiple declarations
-                    return ReplaceRange(root, fullDecl, this.SplitAndReplace(fullDecl, index, new[] { newDeclaration }));
+                    return ReplaceRange(root, fullDecl, SplitAndReplace(fullDecl, index, new[] { newDeclaration }));
                 }
 
                 // attempt normal replace
@@ -2658,7 +2663,7 @@ private static bool AreInlineReplaceableSubDeclarations(SyntaxNode decl1, Syntax
             return false;
         }
 
-        private static bool AreSimilarExceptForSubDeclarations(SyntaxNode decl1, SyntaxNode decl2)
+        private static bool AreSimilarExceptForSubDeclarations(SyntaxNode? decl1, SyntaxNode? decl2)
         {
             if (decl1 == decl2)
             {
@@ -2748,7 +2753,7 @@ public override SyntaxNode InsertNodesBefore(SyntaxNode root, SyntaxNode declara
 
             if (root.Span.Contains(declaration.Span))
             {
-                return this.Isolate(root.TrackNodes(declaration), r => this.InsertNodesBeforeInternal(r, r.GetCurrentNode(declaration), newDeclarations));
+                return this.Isolate(root.TrackNodes(declaration), r => this.InsertNodesBeforeInternal(r, r.GetCurrentNode(declaration)!, newDeclarations));
             }
             else
             {
@@ -2787,7 +2792,7 @@ public override SyntaxNode InsertNodesAfter(SyntaxNode root, SyntaxNode declarat
 
             if (root.Span.Contains(declaration.Span))
             {
-                return this.Isolate(root.TrackNodes(declaration), r => this.InsertNodesAfterInternal(r, r.GetCurrentNode(declaration), newDeclarations));
+                return this.Isolate(root.TrackNodes(declaration), r => this.InsertNodesAfterInternal(r, r.GetCurrentNode(declaration)!, newDeclarations));
             }
             else
             {
@@ -2827,7 +2832,7 @@ private IEnumerable<SyntaxNode> SplitAndInsert(SyntaxNode multiPartDeclaration,
         }
 
         private SyntaxNode WithSubDeclarationsRemoved(SyntaxNode declaration, int index, int count)
-            => this.RemoveNodes(declaration, GetSubDeclarations(declaration).Skip(index).Take(count));
+            => RemoveNodes(declaration, GetSubDeclarations(declaration).Skip(index).Take(count));
 
         private static IReadOnlyList<SyntaxNode> GetSubDeclarations(SyntaxNode declaration)
             => declaration.Kind() switch
@@ -2841,10 +2846,12 @@ private static IReadOnlyList<SyntaxNode> GetSubDeclarations(SyntaxNode declarati
             };
 
         public override SyntaxNode RemoveNode(SyntaxNode root, SyntaxNode node)
-            => this.RemoveNode(root, node, DefaultRemoveOptions);
+            => RemoveNode(root, node, DefaultRemoveOptions);
 
         public override SyntaxNode RemoveNode(SyntaxNode root, SyntaxNode node, SyntaxRemoveOptions options)
         {
+            Contract.ThrowIfTrue(ReferenceEquals(root, node));
+
             if (node.Parent.IsKind(SyntaxKind.GlobalStatement))
             {
                 // Remove the entire global statement as part of the edit
@@ -2854,16 +2861,18 @@ public override SyntaxNode RemoveNode(SyntaxNode root, SyntaxNode node, SyntaxRe
             if (root.Span.Contains(node.Span))
             {
                 // node exists within normal span of the root (not in trivia)
-                return this.Isolate(root.TrackNodes(node), r => this.RemoveNodeInternal(r, r.GetCurrentNode(node), options));
+                return Isolate(root.TrackNodes(node), r => RemoveNodeInternal(r, r.GetCurrentNode(node)!, options));
             }
             else
             {
-                return this.RemoveNodeInternal(root, node, options);
+                return RemoveNodeInternal(root, node, options);
             }
         }
 
         private SyntaxNode RemoveNodeInternal(SyntaxNode root, SyntaxNode declaration, SyntaxRemoveOptions options)
         {
+            Contract.ThrowIfTrue(ReferenceEquals(root, declaration));
+
             switch (declaration.Kind())
             {
                 case SyntaxKind.Attribute:
@@ -2871,7 +2880,7 @@ private SyntaxNode RemoveNodeInternal(SyntaxNode root, SyntaxNode declaration, S
                     if (attr.Parent is AttributeListSyntax attrList && attrList.Attributes.Count == 1)
                     {
                         // remove entire list if only one attribute
-                        return this.RemoveNodeInternal(root, attrList, options);
+                        return RemoveNodeInternal(root, attrList, options);
                     }
 
                     break;
@@ -2880,7 +2889,7 @@ private SyntaxNode RemoveNodeInternal(SyntaxNode root, SyntaxNode declaration, S
                     if (declaration.Parent != null && ((AttributeArgumentListSyntax)declaration.Parent).Arguments.Count == 1)
                     {
                         // remove entire argument list if only one argument
-                        return this.RemoveNodeInternal(root, declaration.Parent, options);
+                        return RemoveNodeInternal(root, declaration.Parent, options);
                     }
 
                     break;
@@ -2890,7 +2899,7 @@ private SyntaxNode RemoveNodeInternal(SyntaxNode root, SyntaxNode declaration, S
                     if (full != declaration && GetDeclarationCount(full) == 1)
                     {
                         // remove full declaration if only one declarator
-                        return this.RemoveNodeInternal(root, full, options);
+                        return RemoveNodeInternal(root, full, options);
                     }
 
                     break;
@@ -2899,7 +2908,7 @@ private SyntaxNode RemoveNodeInternal(SyntaxNode root, SyntaxNode declaration, S
                     if (declaration.Parent is BaseListSyntax baseList && baseList.Types.Count == 1)
                     {
                         // remove entire base list if this is the only base type.
-                        return this.RemoveNodeInternal(root, baseList, options);
+                        return RemoveNodeInternal(root, baseList, options);
                     }
 
                     break;
@@ -2911,7 +2920,7 @@ private SyntaxNode RemoveNodeInternal(SyntaxNode root, SyntaxNode declaration, S
                         switch (parent.Kind())
                         {
                             case SyntaxKind.SimpleBaseType:
-                                return this.RemoveNodeInternal(root, parent, options);
+                                return RemoveNodeInternal(root, parent, options);
                         }
                     }
 
@@ -2960,18 +2969,18 @@ public override SyntaxNode AwaitExpression(SyntaxNode expression)
         public override SyntaxNode NameOfExpression(SyntaxNode expression)
             => this.InvocationExpression(s_nameOfIdentifier, expression);
 
-        public override SyntaxNode ReturnStatement(SyntaxNode expressionOpt = null)
-            => SyntaxFactory.ReturnStatement((ExpressionSyntax)expressionOpt);
+        public override SyntaxNode ReturnStatement(SyntaxNode? expression = null)
+            => SyntaxFactory.ReturnStatement((ExpressionSyntax?)expression);
 
-        public override SyntaxNode ThrowStatement(SyntaxNode expressionOpt = null)
-            => SyntaxFactory.ThrowStatement((ExpressionSyntax)expressionOpt);
+        public override SyntaxNode ThrowStatement(SyntaxNode? expression = null)
+            => SyntaxFactory.ThrowStatement((ExpressionSyntax?)expression);
 
         public override SyntaxNode ThrowExpression(SyntaxNode expression)
             => SyntaxFactory.ThrowExpression((ExpressionSyntax)expression);
 
         internal override bool SupportsThrowExpression() => true;
 
-        public override SyntaxNode IfStatement(SyntaxNode condition, IEnumerable<SyntaxNode> trueStatements, IEnumerable<SyntaxNode> falseStatements = null)
+        public override SyntaxNode IfStatement(SyntaxNode condition, IEnumerable<SyntaxNode> trueStatements, IEnumerable<SyntaxNode>? falseStatements = null)
         {
             if (falseStatements == null)
             {
@@ -2992,10 +3001,10 @@ public override SyntaxNode IfStatement(SyntaxNode condition, IEnumerable<SyntaxN
             }
         }
 
-        private static BlockSyntax CreateBlock(IEnumerable<SyntaxNode> statements)
+        private static BlockSyntax CreateBlock(IEnumerable<SyntaxNode>? statements = null)
             => SyntaxFactory.Block(AsStatementList(statements)).WithAdditionalAnnotations(Simplifier.Annotation);
 
-        private static SyntaxList<StatementSyntax> AsStatementList(IEnumerable<SyntaxNode> nodes)
+        private static SyntaxList<StatementSyntax> AsStatementList(IEnumerable<SyntaxNode>? nodes)
             => nodes == null ? default : SyntaxFactory.List(nodes.Select(AsStatement));
 
         private static StatementSyntax AsStatement(SyntaxNode node)
@@ -3011,8 +3020,11 @@ private static StatementSyntax AsStatement(SyntaxNode node)
         public override SyntaxNode ExpressionStatement(SyntaxNode expression)
             => SyntaxFactory.ExpressionStatement((ExpressionSyntax)expression);
 
-        internal override SyntaxNode MemberAccessExpressionWorker(SyntaxNode expression, SyntaxNode simpleName)
+        internal override SyntaxNode MemberAccessExpressionWorker(SyntaxNode? expression, SyntaxNode simpleName)
         {
+            // can only be null in VB
+            Contract.ThrowIfNull(expression);
+
             return SyntaxFactory.MemberAccessExpression(
                 SyntaxKind.SimpleMemberAccessExpression,
                 ParenthesizeLeft((ExpressionSyntax)expression),
@@ -3227,8 +3239,8 @@ public override SyntaxNode ThisExpression()
         public override SyntaxNode BaseExpression()
             => SyntaxFactory.BaseExpression();
 
-        public override SyntaxNode LiteralExpression(object value)
-            => ExpressionGenerator.GenerateNonEnumValueExpression(null, value, canUseFieldReference: true);
+        public override SyntaxNode LiteralExpression(object? value)
+            => ExpressionGenerator.GenerateNonEnumValueExpression(type: null, value, canUseFieldReference: true);
 
         public override SyntaxNode TypedConstantExpression(TypedConstant value)
             => ExpressionGenerator.GenerateExpression(value);
@@ -3326,21 +3338,21 @@ public override SyntaxNode NullableTypeExpression(SyntaxNode type)
         internal override SyntaxNode CreateTupleType(IEnumerable<SyntaxNode> elements)
             => SyntaxFactory.TupleType(SyntaxFactory.SeparatedList(elements.Cast<TupleElementSyntax>()));
 
-        public override SyntaxNode TupleElementExpression(SyntaxNode type, string name = null)
+        public override SyntaxNode TupleElementExpression(SyntaxNode type, string? name = null)
             => SyntaxFactory.TupleElement((TypeSyntax)type, name?.ToIdentifierToken() ?? default);
 
-        public override SyntaxNode Argument(string nameOpt, RefKind refKind, SyntaxNode expression)
+        public override SyntaxNode Argument(string? name, RefKind refKind, SyntaxNode expression)
         {
             return SyntaxFactory.Argument(
-                nameOpt == null ? null : SyntaxFactory.NameColon(nameOpt),
+                name == null ? null : SyntaxFactory.NameColon(name),
                 GetArgumentModifiers(refKind),
                 (ExpressionSyntax)expression);
         }
 
-        public override SyntaxNode LocalDeclarationStatement(SyntaxNode type, string name, SyntaxNode initializer, bool isConst)
+        public override SyntaxNode LocalDeclarationStatement(SyntaxNode? type, string name, SyntaxNode? initializer, bool isConst)
             => CSharpSyntaxGeneratorInternal.Instance.LocalDeclarationStatement(type, name.ToIdentifierToken(), initializer, isConst);
 
-        public override SyntaxNode UsingStatement(SyntaxNode type, string name, SyntaxNode expression, IEnumerable<SyntaxNode> statements)
+        public override SyntaxNode UsingStatement(SyntaxNode? type, string name, SyntaxNode expression, IEnumerable<SyntaxNode> statements)
         {
             return SyntaxFactory.UsingStatement(
                 CSharpSyntaxGeneratorInternal.VariableDeclaration(type, name.ToIdentifierToken(), expression),
@@ -3363,7 +3375,7 @@ public override SyntaxNode LockStatement(SyntaxNode expression, IEnumerable<Synt
                 statement: CreateBlock(statements));
         }
 
-        public override SyntaxNode TryCatchStatement(IEnumerable<SyntaxNode> tryStatements, IEnumerable<SyntaxNode> catchClauses, IEnumerable<SyntaxNode> finallyStatements = null)
+        public override SyntaxNode TryCatchStatement(IEnumerable<SyntaxNode>? tryStatements, IEnumerable<SyntaxNode>? catchClauses, IEnumerable<SyntaxNode>? finallyStatements = null)
         {
             return SyntaxFactory.TryStatement(
                 CreateBlock(tryStatements),
@@ -3434,7 +3446,7 @@ public override SyntaxNode ExitSwitchStatement()
         internal override SyntaxNode ScopeBlock(IEnumerable<SyntaxNode> statements)
             => SyntaxFactory.Block(statements.Cast<StatementSyntax>());
 
-        public override SyntaxNode ValueReturningLambdaExpression(IEnumerable<SyntaxNode> parameterDeclarations, SyntaxNode expression)
+        public override SyntaxNode ValueReturningLambdaExpression(IEnumerable<SyntaxNode>? parameterDeclarations, SyntaxNode expression)
         {
             var parameters = parameterDeclarations?.Cast<ParameterSyntax>().ToList();
 
@@ -3451,17 +3463,17 @@ public override SyntaxNode ValueReturningLambdaExpression(IEnumerable<SyntaxNode
         private static bool IsSimpleLambdaParameter(SyntaxNode node)
             => node is ParameterSyntax p && p.Type == null && p.Default == null && p.Modifiers.Count == 0;
 
-        public override SyntaxNode VoidReturningLambdaExpression(IEnumerable<SyntaxNode> lambdaParameters, SyntaxNode expression)
+        public override SyntaxNode VoidReturningLambdaExpression(IEnumerable<SyntaxNode>? lambdaParameters, SyntaxNode expression)
             => this.ValueReturningLambdaExpression(lambdaParameters, expression);
 
-        public override SyntaxNode ValueReturningLambdaExpression(IEnumerable<SyntaxNode> parameterDeclarations, IEnumerable<SyntaxNode> statements)
+        public override SyntaxNode ValueReturningLambdaExpression(IEnumerable<SyntaxNode>? parameterDeclarations, IEnumerable<SyntaxNode> statements)
             => this.ValueReturningLambdaExpression(parameterDeclarations, CreateBlock(statements));
 
-        public override SyntaxNode VoidReturningLambdaExpression(IEnumerable<SyntaxNode> lambdaParameters, IEnumerable<SyntaxNode> statements)
+        public override SyntaxNode VoidReturningLambdaExpression(IEnumerable<SyntaxNode>? lambdaParameters, IEnumerable<SyntaxNode> statements)
             => this.ValueReturningLambdaExpression(lambdaParameters, statements);
 
-        public override SyntaxNode LambdaParameter(string identifier, SyntaxNode type = null)
-            => this.ParameterDeclaration(identifier, type, null, RefKind.None);
+        public override SyntaxNode LambdaParameter(string identifier, SyntaxNode? type = null)
+            => this.ParameterDeclaration(identifier, type, initializer: null, RefKind.None);
 
         internal override SyntaxNode IdentifierName(SyntaxToken identifier)
             => SyntaxFactory.IdentifierName(identifier);
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/ConstructorGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/ConstructorGenerator.cs
index 43aab56086cce..32175324fbd4e 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/ConstructorGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/ConstructorGenerator.cs
@@ -2,11 +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.
 
-#nullable disable
-
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
+using System.Threading;
 using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
@@ -20,40 +19,38 @@ namespace Microsoft.CodeAnalysis.CSharp.CodeGeneration
 {
     internal static class ConstructorGenerator
     {
-        private static MemberDeclarationSyntax LastConstructorOrField(SyntaxList<MemberDeclarationSyntax> members)
+        private static MemberDeclarationSyntax? LastConstructorOrField(SyntaxList<MemberDeclarationSyntax> members)
             => LastConstructor(members) ?? LastField(members);
 
         internal static TypeDeclarationSyntax AddConstructorTo(
             TypeDeclarationSyntax destination,
             IMethodSymbol constructor,
-            CodeGenerationOptions options,
-            IList<bool> availableIndices)
+            CSharpCodeGenerationOptions options,
+            IList<bool>? availableIndices,
+            CancellationToken cancellationToken)
         {
-            var constructorDeclaration = GenerateConstructorDeclaration(
-                constructor, options, destination?.SyntaxTree.Options ?? options.ParseOptions);
+            var constructorDeclaration = GenerateConstructorDeclaration(constructor, options, cancellationToken);
 
             // Generate after the last constructor, or after the last field, or at the start of the
             // type.
             var members = Insert(destination.Members, constructorDeclaration, options,
                 availableIndices, after: LastConstructorOrField, before: FirstMember);
 
-            return AddMembersTo(destination, members);
+            return AddMembersTo(destination, members, cancellationToken);
         }
 
         internal static ConstructorDeclarationSyntax GenerateConstructorDeclaration(
             IMethodSymbol constructor,
-            CodeGenerationOptions options,
-            ParseOptions parseOptions)
+            CSharpCodeGenerationOptions options,
+            CancellationToken cancellationToken)
         {
-            options ??= CodeGenerationOptions.Default;
-
             var reusableSyntax = GetReuseableSyntaxNodeForSymbol<ConstructorDeclarationSyntax>(constructor, options);
             if (reusableSyntax != null)
             {
                 return reusableSyntax;
             }
 
-            var hasNoBody = !options.GenerateMethodBodies;
+            var hasNoBody = !options.Context.GenerateMethodBodies;
 
             var declaration = SyntaxFactory.ConstructorDeclaration(
                 attributeLists: AttributeGenerator.GenerateAttributeLists(constructor.GetAttributes(), options),
@@ -64,21 +61,21 @@ internal static ConstructorDeclarationSyntax GenerateConstructorDeclaration(
                 body: hasNoBody ? null : GenerateBlock(constructor),
                 semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : default);
 
-            declaration = UseExpressionBodyIfDesired(options, declaration, parseOptions);
+            declaration = UseExpressionBodyIfDesired(options, declaration);
 
             return AddFormatterAndCodeGeneratorAnnotationsTo(
-                ConditionallyAddDocumentationCommentTo(declaration, constructor, options));
+                ConditionallyAddDocumentationCommentTo(declaration, constructor, options, cancellationToken));
         }
 
         private static ConstructorDeclarationSyntax UseExpressionBodyIfDesired(
-            CodeGenerationOptions options, ConstructorDeclarationSyntax declaration, ParseOptions parseOptions)
+            CSharpCodeGenerationOptions options, ConstructorDeclarationSyntax declaration)
         {
             if (declaration.ExpressionBody == null)
             {
-                var expressionBodyPreference = options.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedConstructors).Value;
-                if (declaration.Body.TryConvertToArrowExpressionBody(
-                        declaration.Kind(), parseOptions, expressionBodyPreference,
-                        out var expressionBody, out var semicolonToken))
+                var expressionBodyPreference = options.Preferences.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedConstructors).Value;
+                if (declaration.Body?.TryConvertToArrowExpressionBody(
+                    declaration.Kind(), options.Preferences.LanguageVersion, expressionBodyPreference,
+                    out var expressionBody, out var semicolonToken) == true)
                 {
                     return declaration.WithBody(null)
                                       .WithExpressionBody(expressionBody)
@@ -89,7 +86,7 @@ private static ConstructorDeclarationSyntax UseExpressionBodyIfDesired(
             return declaration;
         }
 
-        private static ConstructorInitializerSyntax GenerateConstructorInitializer(
+        private static ConstructorInitializerSyntax? GenerateConstructorInitializer(
             IMethodSymbol constructor)
         {
             var thisArguments = CodeGenerationConstructorInfo.GetThisConstructorArgumentsOpt(constructor);
@@ -117,7 +114,7 @@ private static BlockSyntax GenerateBlock(
             return SyntaxFactory.Block(statements);
         }
 
-        private static SyntaxTokenList GenerateModifiers(IMethodSymbol constructor, CodeGenerationOptions options)
+        private static SyntaxTokenList GenerateModifiers(IMethodSymbol constructor, CSharpCodeGenerationOptions options)
         {
             var tokens = ArrayBuilder<SyntaxToken>.GetInstance();
 
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/ConversionGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/ConversionGenerator.cs
index 119cf3b817310..f3cb76841308a 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/ConversionGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/ConversionGenerator.cs
@@ -2,9 +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.
 
-#nullable disable
-
 using System.Collections.Generic;
+using System.Threading;
 using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
@@ -20,33 +19,31 @@ internal static class ConversionGenerator
         internal static TypeDeclarationSyntax AddConversionTo(
             TypeDeclarationSyntax destination,
             IMethodSymbol method,
-            CodeGenerationOptions options,
-            IList<bool> availableIndices)
+            CSharpCodeGenerationOptions options,
+            IList<bool>? availableIndices,
+            CancellationToken cancellationToken)
         {
-            var methodDeclaration = GenerateConversionDeclaration(
-                method, options, destination?.SyntaxTree.Options ?? options.ParseOptions);
-
+            var methodDeclaration = GenerateConversionDeclaration(method, options, cancellationToken);
             var members = Insert(destination.Members, methodDeclaration, options, availableIndices, after: LastOperator);
 
-            return AddMembersTo(destination, members);
+            return AddMembersTo(destination, members, cancellationToken);
         }
 
         internal static ConversionOperatorDeclarationSyntax GenerateConversionDeclaration(
             IMethodSymbol method,
-            CodeGenerationOptions options,
-            ParseOptions parseOptions)
+            CSharpCodeGenerationOptions options,
+            CancellationToken cancellationToken)
         {
-            var declaration = GenerateConversionDeclarationWorker(method, options, parseOptions);
+            var declaration = GenerateConversionDeclarationWorker(method, options);
             return AddFormatterAndCodeGeneratorAnnotationsTo(AddAnnotationsTo(method,
-                ConditionallyAddDocumentationCommentTo(declaration, method, options)));
+                ConditionallyAddDocumentationCommentTo(declaration, method, options, cancellationToken)));
         }
 
         private static ConversionOperatorDeclarationSyntax GenerateConversionDeclarationWorker(
             IMethodSymbol method,
-            CodeGenerationOptions options,
-            ParseOptions parseOptions)
+            CSharpCodeGenerationOptions options)
         {
-            var hasNoBody = !options.GenerateMethodBodies || method.IsExtern;
+            var hasNoBody = !options.Context.GenerateMethodBodies || method.IsExtern;
 
             var reusableSyntax = GetReuseableSyntaxNodeForSymbol<ConversionOperatorDeclarationSyntax>(method, options);
             if (reusableSyntax != null)
@@ -68,21 +65,21 @@ private static ConversionOperatorDeclarationSyntax GenerateConversionDeclaration
                 body: hasNoBody ? null : StatementGenerator.GenerateBlock(method),
                 semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : new SyntaxToken());
 
-            declaration = UseExpressionBodyIfDesired(options, declaration, parseOptions);
+            declaration = UseExpressionBodyIfDesired(options, declaration);
 
             return declaration;
         }
 
         private static ConversionOperatorDeclarationSyntax UseExpressionBodyIfDesired(
-            CodeGenerationOptions options, ConversionOperatorDeclarationSyntax declaration, ParseOptions parseOptions)
+            CSharpCodeGenerationOptions options, ConversionOperatorDeclarationSyntax declaration)
         {
             if (declaration.ExpressionBody == null)
             {
-                var expressionBodyPreference = options.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedOperators).Value;
+                var expressionBodyPreference = options.Preferences.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedOperators).Value;
 
-                if (declaration.Body.TryConvertToArrowExpressionBody(
-                        declaration.Kind(), parseOptions, expressionBodyPreference,
-                        out var expressionBody, out var semicolonToken))
+                if (declaration.Body?.TryConvertToArrowExpressionBody(
+                    declaration.Kind(), options.Preferences.LanguageVersion, expressionBodyPreference,
+                    out var expressionBody, out var semicolonToken) == true)
                 {
                     return declaration.WithBody(null)
                                       .WithExpressionBody(expressionBody)
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/DestructorGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/DestructorGenerator.cs
index f0aa39dbd139a..24272cf761875 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/DestructorGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/DestructorGenerator.cs
@@ -2,9 +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.
 
-#nullable disable
-
 using System.Collections.Generic;
+using System.Threading;
 using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -16,37 +15,36 @@ namespace Microsoft.CodeAnalysis.CSharp.CodeGeneration
 {
     internal static class DestructorGenerator
     {
-        private static MemberDeclarationSyntax LastConstructorOrField(SyntaxList<MemberDeclarationSyntax> members)
+        private static MemberDeclarationSyntax? LastConstructorOrField(SyntaxList<MemberDeclarationSyntax> members)
             => LastConstructor(members) ?? LastField(members);
 
         internal static TypeDeclarationSyntax AddDestructorTo(
             TypeDeclarationSyntax destination,
             IMethodSymbol destructor,
-            CodeGenerationOptions options,
-            IList<bool> availableIndices)
+            CSharpCodeGenerationOptions options,
+            IList<bool>? availableIndices,
+            CancellationToken cancellationToken)
         {
-            var destructorDeclaration = GenerateDestructorDeclaration(destructor, options);
+            var destructorDeclaration = GenerateDestructorDeclaration(destructor, options, cancellationToken);
 
             // Generate after the last constructor, or after the last field, or at the start of the
             // type.
             var members = Insert(destination.Members, destructorDeclaration, options,
                 availableIndices, after: LastConstructorOrField, before: FirstMember);
 
-            return AddMembersTo(destination, members);
+            return AddMembersTo(destination, members, cancellationToken);
         }
 
         internal static DestructorDeclarationSyntax GenerateDestructorDeclaration(
-            IMethodSymbol destructor, CodeGenerationOptions options)
+            IMethodSymbol destructor, CSharpCodeGenerationOptions options, CancellationToken cancellationToken)
         {
-            options ??= CodeGenerationOptions.Default;
-
             var reusableSyntax = GetReuseableSyntaxNodeForSymbol<DestructorDeclarationSyntax>(destructor, options);
             if (reusableSyntax != null)
             {
                 return reusableSyntax;
             }
 
-            var hasNoBody = !options.GenerateMethodBodies;
+            var hasNoBody = !options.Context.GenerateMethodBodies;
 
             var declaration = SyntaxFactory.DestructorDeclaration(
                 attributeLists: AttributeGenerator.GenerateAttributeLists(destructor.GetAttributes(), options),
@@ -58,7 +56,7 @@ internal static DestructorDeclarationSyntax GenerateDestructorDeclaration(
                 semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : default);
 
             return AddFormatterAndCodeGeneratorAnnotationsTo(
-                ConditionallyAddDocumentationCommentTo(declaration, destructor, options));
+                ConditionallyAddDocumentationCommentTo(declaration, destructor, options, cancellationToken));
         }
 
         private static BlockSyntax GenerateBlock(
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/EnumMemberGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/EnumMemberGenerator.cs
index 1c483a6a29744..3ade36c33c5fe 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/EnumMemberGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/EnumMemberGenerator.cs
@@ -2,11 +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.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -19,12 +18,12 @@ namespace Microsoft.CodeAnalysis.CSharp.CodeGeneration
 {
     internal static class EnumMemberGenerator
     {
-        internal static EnumDeclarationSyntax AddEnumMemberTo(EnumDeclarationSyntax destination, IFieldSymbol enumMember, CodeGenerationOptions options)
+        internal static EnumDeclarationSyntax AddEnumMemberTo(EnumDeclarationSyntax destination, IFieldSymbol enumMember, CSharpCodeGenerationOptions options, CancellationToken cancellationToken)
         {
             var members = new List<SyntaxNodeOrToken>();
             members.AddRange(destination.Members.GetWithSeparators());
 
-            var member = GenerateEnumMemberDeclaration(enumMember, destination, options);
+            var member = GenerateEnumMemberDeclaration(enumMember, destination, options, cancellationToken);
 
             if (members.Count == 0)
             {
@@ -50,8 +49,9 @@ internal static EnumDeclarationSyntax AddEnumMemberTo(EnumDeclarationSyntax dest
 
         public static EnumMemberDeclarationSyntax GenerateEnumMemberDeclaration(
             IFieldSymbol enumMember,
-            EnumDeclarationSyntax destinationOpt,
-            CodeGenerationOptions options)
+            EnumDeclarationSyntax? destination,
+            CSharpCodeGenerationOptions options,
+            CancellationToken cancellationToken)
         {
             var reusableSyntax = GetReuseableSyntaxNodeForSymbol<EnumMemberDeclarationSyntax>(enumMember, options);
             if (reusableSyntax != null)
@@ -59,15 +59,15 @@ public static EnumMemberDeclarationSyntax GenerateEnumMemberDeclaration(
                 return reusableSyntax;
             }
 
-            var value = CreateEnumMemberValue(destinationOpt, enumMember);
+            var value = CreateEnumMemberValue(destination, enumMember);
             var member = SyntaxFactory.EnumMemberDeclaration(enumMember.Name.ToIdentifierToken())
                 .WithEqualsValue(value == null ? null : SyntaxFactory.EqualsValueClause(value: value));
 
             return AddFormatterAndCodeGeneratorAnnotationsTo(
-                ConditionallyAddDocumentationCommentTo(member, enumMember, options));
+                ConditionallyAddDocumentationCommentTo(member, enumMember, options, cancellationToken));
         }
 
-        private static ExpressionSyntax CreateEnumMemberValue(EnumDeclarationSyntax destinationOpt, IFieldSymbol enumMember)
+        private static ExpressionSyntax? CreateEnumMemberValue(EnumDeclarationSyntax? destination, IFieldSymbol enumMember)
         {
             if (!enumMember.HasConstantValue)
             {
@@ -88,9 +88,9 @@ not long and
 
             var value = IntegerUtilities.ToInt64(enumMember.ConstantValue);
 
-            if (destinationOpt != null)
+            if (destination != null)
             {
-                if (destinationOpt.Members.Count == 0)
+                if (destination.Members.Count == 0)
                 {
                     if (value == 0)
                     {
@@ -101,17 +101,17 @@ not long and
                 {
                     // Don't generate an initializer if no other members have them, and our value
                     // would be correctly inferred from our position.
-                    if (destinationOpt.Members.Count == value &&
-                        destinationOpt.Members.All(m => m.EqualsValue == null))
+                    if (destination.Members.Count == value &&
+                        destination.Members.All(m => m.EqualsValue == null))
                     {
                         return null;
                     }
 
                     // Existing members, try to stay consistent with their style.
-                    var lastMember = destinationOpt.Members.LastOrDefault(m => m.EqualsValue != null);
+                    var lastMember = destination.Members.LastOrDefault(m => m.EqualsValue != null);
                     if (lastMember != null)
                     {
-                        var lastExpression = lastMember.EqualsValue.Value;
+                        var lastExpression = lastMember.EqualsValue!.Value;
                         if (lastExpression.Kind() == SyntaxKind.LeftShiftExpression &&
                             IntegerUtilities.HasOneBitSet(value))
                         {
@@ -132,7 +132,7 @@ not long and
                                 }
                             }
                         }
-                        else if (lastExpression.IsKind(SyntaxKind.NumericLiteralExpression, out LiteralExpressionSyntax numericLiteral))
+                        else if (lastExpression.IsKind(SyntaxKind.NumericLiteralExpression, out LiteralExpressionSyntax? numericLiteral))
                         {
                             var numericToken = numericLiteral.Token;
                             var numericText = numericToken.ToString();
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/EventGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/EventGenerator.cs
index d2f1bcb78b6a7..3ee60fd8332c3 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/EventGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/EventGenerator.cs
@@ -2,10 +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.
 
-#nullable disable
-
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -20,7 +19,7 @@ namespace Microsoft.CodeAnalysis.CSharp.CodeGeneration
 {
     internal static class EventGenerator
     {
-        private static MemberDeclarationSyntax AfterMember(
+        private static MemberDeclarationSyntax? AfterMember(
             SyntaxList<MemberDeclarationSyntax> members,
             MemberDeclarationSyntax eventDeclaration)
         {
@@ -43,7 +42,7 @@ private static MemberDeclarationSyntax AfterMember(
             return null;
         }
 
-        private static MemberDeclarationSyntax BeforeMember(
+        private static MemberDeclarationSyntax? BeforeMember(
             SyntaxList<MemberDeclarationSyntax> members,
             MemberDeclarationSyntax eventDeclaration)
         {
@@ -61,10 +60,11 @@ private static MemberDeclarationSyntax BeforeMember(
         internal static CompilationUnitSyntax AddEventTo(
             CompilationUnitSyntax destination,
             IEventSymbol @event,
-            CodeGenerationOptions options,
-            IList<bool> availableIndices)
+            CSharpCodeGenerationOptions options,
+            IList<bool> availableIndices,
+            CancellationToken cancellationToken)
         {
-            var declaration = GenerateEventDeclaration(@event, CodeGenerationDestination.CompilationUnit, options);
+            var declaration = GenerateEventDeclaration(@event, CodeGenerationDestination.CompilationUnit, options, cancellationToken);
 
             // Place the event depending on its shape.  Field style events go with fields, property
             // style events go with properties.  If there 
@@ -76,10 +76,11 @@ internal static CompilationUnitSyntax AddEventTo(
         internal static TypeDeclarationSyntax AddEventTo(
             TypeDeclarationSyntax destination,
             IEventSymbol @event,
-            CodeGenerationOptions options,
-            IList<bool> availableIndices)
+            CSharpCodeGenerationOptions options,
+            IList<bool>? availableIndices,
+            CancellationToken cancellationToken)
         {
-            var declaration = GenerateEventDeclaration(@event, GetDestination(destination), options);
+            var declaration = GenerateEventDeclaration(@event, GetDestination(destination), options, cancellationToken);
 
             var members = Insert(destination.Members, declaration, options, availableIndices,
                 after: list => AfterMember(list, declaration),
@@ -88,11 +89,11 @@ internal static TypeDeclarationSyntax AddEventTo(
             // Find the best place to put the field.  It should go after the last field if we already
             // have fields, or at the beginning of the file if we don't.
 
-            return AddMembersTo(destination, members);
+            return AddMembersTo(destination, members, cancellationToken);
         }
 
         public static MemberDeclarationSyntax GenerateEventDeclaration(
-            IEventSymbol @event, CodeGenerationDestination destination, CodeGenerationOptions options)
+            IEventSymbol @event, CodeGenerationDestination destination, CSharpCodeGenerationOptions options, CancellationToken cancellationToken)
         {
             var reusableSyntax = GetReuseableSyntaxNodeForSymbol<MemberDeclarationSyntax>(@event, options);
             if (reusableSyntax != null)
@@ -100,15 +101,15 @@ public static MemberDeclarationSyntax GenerateEventDeclaration(
                 return reusableSyntax;
             }
 
-            var declaration = !options.GenerateMethodBodies || @event.IsAbstract || @event.AddMethod == null || @event.RemoveMethod == null
+            var declaration = !options.Context.GenerateMethodBodies || @event.IsAbstract || @event.AddMethod == null || @event.RemoveMethod == null
                 ? GenerateEventFieldDeclaration(@event, destination, options)
                 : GenerateEventDeclarationWorker(@event, destination, options);
 
-            return ConditionallyAddDocumentationCommentTo(declaration, @event, options);
+            return ConditionallyAddDocumentationCommentTo(declaration, @event, options, cancellationToken);
         }
 
         private static MemberDeclarationSyntax GenerateEventFieldDeclaration(
-            IEventSymbol @event, CodeGenerationDestination destination, CodeGenerationOptions options)
+            IEventSymbol @event, CodeGenerationDestination destination, CSharpCodeGenerationOptions options)
         {
             return AddFormatterAndCodeGeneratorAnnotationsTo(
                 AddAnnotationsTo(@event,
@@ -121,7 +122,7 @@ private static MemberDeclarationSyntax GenerateEventFieldDeclaration(
         }
 
         private static MemberDeclarationSyntax GenerateEventDeclarationWorker(
-            IEventSymbol @event, CodeGenerationDestination destination, CodeGenerationOptions options)
+            IEventSymbol @event, CodeGenerationDestination destination, CSharpCodeGenerationOptions options)
         {
             var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(@event.ExplicitInterfaceImplementations);
 
@@ -135,9 +136,9 @@ private static MemberDeclarationSyntax GenerateEventDeclarationWorker(
         }
 
         private static AccessorListSyntax GenerateAccessorList(
-            IEventSymbol @event, CodeGenerationDestination destination, CodeGenerationOptions options)
+            IEventSymbol @event, CodeGenerationDestination destination, CSharpCodeGenerationOptions options)
         {
-            var accessors = new List<AccessorDeclarationSyntax>
+            var accessors = new List<AccessorDeclarationSyntax?>
             {
                 GenerateAccessorDeclaration(@event, @event.AddMethod, SyntaxKind.AddAccessorDeclaration, destination, options),
                 GenerateAccessorDeclaration(@event, @event.RemoveMethod, SyntaxKind.RemoveAccessorDeclaration, destination, options),
@@ -146,14 +147,14 @@ private static AccessorListSyntax GenerateAccessorList(
             return SyntaxFactory.AccessorList(accessors.WhereNotNull().ToSyntaxList());
         }
 
-        private static AccessorDeclarationSyntax GenerateAccessorDeclaration(
+        private static AccessorDeclarationSyntax? GenerateAccessorDeclaration(
             IEventSymbol @event,
-            IMethodSymbol accessor,
+            IMethodSymbol? accessor,
             SyntaxKind kind,
             CodeGenerationDestination destination,
-            CodeGenerationOptions options)
+            CSharpCodeGenerationOptions options)
         {
-            var hasBody = options.GenerateMethodBodies && HasAccessorBodies(@event, destination, accessor);
+            var hasBody = options.Context.GenerateMethodBodies && HasAccessorBodies(@event, destination, accessor);
             return accessor == null
                 ? null
                 : GenerateAccessorDeclaration(accessor, kind, hasBody);
@@ -178,7 +179,7 @@ private static BlockSyntax GenerateBlock(IMethodSymbol accessor)
         private static bool HasAccessorBodies(
             IEventSymbol @event,
             CodeGenerationDestination destination,
-            IMethodSymbol accessor)
+            IMethodSymbol? accessor)
         {
             return destination != CodeGenerationDestination.InterfaceType &&
                 !@event.IsAbstract &&
@@ -187,7 +188,7 @@ private static bool HasAccessorBodies(
         }
 
         private static SyntaxTokenList GenerateModifiers(
-            IEventSymbol @event, CodeGenerationDestination destination, CodeGenerationOptions options)
+            IEventSymbol @event, CodeGenerationDestination destination, CSharpCodeGenerationOptions options)
         {
             var tokens = ArrayBuilder<SyntaxToken>.GetInstance();
 
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/ExpressionGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/ExpressionGenerator.cs
index 412c384fb1037..743f078104b95 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/ExpressionGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/ExpressionGenerator.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Globalization;
@@ -52,18 +50,19 @@ private static ExpressionSyntax GenerateNullLiteral()
             => SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
 
         internal static ExpressionSyntax GenerateExpression(
-            ITypeSymbol type,
-            object value,
+            ITypeSymbol? type,
+            object? value,
             bool canUseFieldReference)
         {
-            if (value != null)
+            if (type != null && value != null)
             {
                 if (type.TypeKind == TypeKind.Enum)
                 {
                     var enumType = (INamedTypeSymbol)type;
-                    return (ExpressionSyntax)CSharpFlagsEnumGenerator.Instance.TryCreateEnumConstantValue(enumType, value);
+                    return (ExpressionSyntax)CSharpFlagsEnumGenerator.Instance.CreateEnumConstantValue(enumType, value);
                 }
-                else if (type.IsNullable())
+
+                if (type.IsNullable())
                 {
                     // If the type of the argument is T?, then the type of the supplied default value can either be T 
                     // (e.g. int? x = 5) or it can be T? (e.g. SomeStruct? x = null). The below statement handles the case
@@ -75,23 +74,23 @@ internal static ExpressionSyntax GenerateExpression(
             return GenerateNonEnumValueExpression(type, value, canUseFieldReference);
         }
 
-        internal static ExpressionSyntax GenerateNonEnumValueExpression(ITypeSymbol type, object value, bool canUseFieldReference)
+        internal static ExpressionSyntax GenerateNonEnumValueExpression(ITypeSymbol? type, object? value, bool canUseFieldReference)
             => value switch
             {
                 bool val => GenerateBooleanLiteralExpression(val),
                 string val => GenerateStringLiteralExpression(val),
                 char val => GenerateCharLiteralExpression(val),
-                sbyte val => GenerateLiteralExpression(type, val, LiteralSpecialValues.SByteSpecialValues, null, canUseFieldReference, (s, v) => SyntaxFactory.Literal(s, v), x => x < 0, x => (sbyte)-x, "128"),
-                short val => GenerateLiteralExpression(type, val, LiteralSpecialValues.Int16SpecialValues, null, canUseFieldReference, (s, v) => SyntaxFactory.Literal(s, v), x => x < 0, x => (short)-x, "32768"),
-                int val => GenerateLiteralExpression(type, val, LiteralSpecialValues.Int32SpecialValues, null, canUseFieldReference, SyntaxFactory.Literal, x => x < 0, x => -x, "2147483648"),
-                long val => GenerateLiteralExpression(type, val, LiteralSpecialValues.Int64SpecialValues, null, canUseFieldReference, SyntaxFactory.Literal, x => x < 0, x => -x, "9223372036854775808"),
-                byte val => GenerateNonNegativeLiteralExpression(type, val, LiteralSpecialValues.ByteSpecialValues, null, canUseFieldReference, (s, v) => SyntaxFactory.Literal(s, v)),
-                ushort val => GenerateNonNegativeLiteralExpression(type, val, LiteralSpecialValues.UInt16SpecialValues, null, canUseFieldReference, (s, v) => SyntaxFactory.Literal(s, (uint)v)),
-                uint val => GenerateNonNegativeLiteralExpression(type, val, LiteralSpecialValues.UInt32SpecialValues, null, canUseFieldReference, SyntaxFactory.Literal),
-                ulong val => GenerateNonNegativeLiteralExpression(type, val, LiteralSpecialValues.UInt64SpecialValues, null, canUseFieldReference, SyntaxFactory.Literal),
+                sbyte val => GenerateLiteralExpression(type, val, LiteralSpecialValues.SByteSpecialValues, formatString: null, canUseFieldReference, (s, v) => SyntaxFactory.Literal(s, v), x => x < 0, x => (sbyte)-x, "128"),
+                short val => GenerateLiteralExpression(type, val, LiteralSpecialValues.Int16SpecialValues, formatString: null, canUseFieldReference, (s, v) => SyntaxFactory.Literal(s, v), x => x < 0, x => (short)-x, "32768"),
+                int val => GenerateLiteralExpression(type, val, LiteralSpecialValues.Int32SpecialValues, formatString: null, canUseFieldReference, SyntaxFactory.Literal, x => x < 0, x => -x, "2147483648"),
+                long val => GenerateLiteralExpression(type, val, LiteralSpecialValues.Int64SpecialValues, formatString: null, canUseFieldReference, SyntaxFactory.Literal, x => x < 0, x => -x, "9223372036854775808"),
+                byte val => GenerateNonNegativeLiteralExpression(type, val, LiteralSpecialValues.ByteSpecialValues, formatString: null, canUseFieldReference, (s, v) => SyntaxFactory.Literal(s, v)),
+                ushort val => GenerateNonNegativeLiteralExpression(type, val, LiteralSpecialValues.UInt16SpecialValues, formatString: null, canUseFieldReference, (s, v) => SyntaxFactory.Literal(s, (uint)v)),
+                uint val => GenerateNonNegativeLiteralExpression(type, val, LiteralSpecialValues.UInt32SpecialValues, formatString: null, canUseFieldReference, SyntaxFactory.Literal),
+                ulong val => GenerateNonNegativeLiteralExpression(type, val, LiteralSpecialValues.UInt64SpecialValues, formatString: null, canUseFieldReference, SyntaxFactory.Literal),
                 float val => GenerateSingleLiteralExpression(type, val, canUseFieldReference),
                 double val => GenerateDoubleLiteralExpression(type, val, canUseFieldReference),
-                decimal val => GenerateLiteralExpression(type, val, LiteralSpecialValues.DecimalSpecialValues, null, canUseFieldReference, SyntaxFactory.Literal, x => x < 0, x => -x, null),
+                decimal val => GenerateLiteralExpression(type, val, LiteralSpecialValues.DecimalSpecialValues, formatString: null, canUseFieldReference, SyntaxFactory.Literal, x => x < 0, x => -x, integerMinValueString: null),
                 _ => type == null || type.IsReferenceType || type.IsPointerType() || type.IsNullable()
                     ? GenerateNullLiteral()
                     : (ExpressionSyntax)CSharpSyntaxGenerator.Instance.DefaultExpression(type),
@@ -118,7 +117,7 @@ private static ExpressionSyntax GenerateCharLiteralExpression(char val)
                 SyntaxKind.CharacterLiteralExpression, SyntaxFactory.Literal(literal, val));
         }
 
-        private static string DetermineSuffix(ITypeSymbol type, object value)
+        private static string DetermineSuffix(ITypeSymbol? type, object value)
         {
             if (value is float)
             {
@@ -126,8 +125,8 @@ private static string DetermineSuffix(ITypeSymbol type, object value)
 
                 var isNotSingle = !IsSpecialType(type, SpecialType.System_Single);
                 var containsDoubleCharacter =
-                    stringValue.Contains("E") || stringValue.Contains("e") || stringValue.Contains(".") ||
-                    stringValue.Contains("+") || stringValue.Contains("-");
+                    stringValue.Contains('E') || stringValue.Contains('e') || stringValue.Contains('.') ||
+                    stringValue.Contains('+') || stringValue.Contains('-');
 
                 if (isNotSingle || containsDoubleCharacter)
                 {
@@ -172,50 +171,50 @@ private static string DetermineSuffix(ITypeSymbol type, object value)
             return string.Empty;
         }
 
-        private static ExpressionSyntax GenerateDoubleLiteralExpression(ITypeSymbol type, double value, bool canUseFieldReference)
+        private static ExpressionSyntax GenerateDoubleLiteralExpression(ITypeSymbol? type, double value, bool canUseFieldReference)
         {
             if (!canUseFieldReference)
             {
                 if (double.IsNaN(value))
                 {
                     return SyntaxFactory.BinaryExpression(SyntaxKind.DivideExpression,
-                        GenerateDoubleLiteralExpression(null, 0.0, false),
-                        GenerateDoubleLiteralExpression(null, 0.0, false));
+                        GenerateDoubleLiteralExpression(type: null, 0.0, canUseFieldReference: false),
+                        GenerateDoubleLiteralExpression(type: null, 0.0, canUseFieldReference: false));
                 }
                 else if (double.IsPositiveInfinity(value))
                 {
                     return SyntaxFactory.BinaryExpression(SyntaxKind.DivideExpression,
-                        GenerateDoubleLiteralExpression(null, 1.0, false),
-                        GenerateDoubleLiteralExpression(null, 0.0, false));
+                        GenerateDoubleLiteralExpression(type: null, 1.0, canUseFieldReference: false),
+                        GenerateDoubleLiteralExpression(type: null, 0.0, canUseFieldReference: false));
                 }
                 else if (double.IsNegativeInfinity(value))
                 {
                     return SyntaxFactory.BinaryExpression(SyntaxKind.DivideExpression,
                         SyntaxFactory.PrefixUnaryExpression(SyntaxKind.UnaryMinusExpression, GenerateDoubleLiteralExpression(null, 1.0, false)),
-                        GenerateDoubleLiteralExpression(null, 0.0, false));
+                        GenerateDoubleLiteralExpression(type: null, 0.0, canUseFieldReference: false));
                 }
             }
 
             return GenerateLiteralExpression(
-                type, value, LiteralSpecialValues.DoubleSpecialValues, "R", canUseFieldReference,
-                SyntaxFactory.Literal, x => x < 0, x => -x, null);
+                type, value, LiteralSpecialValues.DoubleSpecialValues, formatString: "R", canUseFieldReference,
+                SyntaxFactory.Literal, x => x < 0, x => -x, integerMinValueString: null);
         }
 
-        private static ExpressionSyntax GenerateSingleLiteralExpression(ITypeSymbol type, float value, bool canUseFieldReference)
+        private static ExpressionSyntax GenerateSingleLiteralExpression(ITypeSymbol? type, float value, bool canUseFieldReference)
         {
             if (!canUseFieldReference)
             {
                 if (float.IsNaN(value))
                 {
                     return SyntaxFactory.BinaryExpression(SyntaxKind.DivideExpression,
-                        GenerateSingleLiteralExpression(null, 0.0F, false),
-                        GenerateSingleLiteralExpression(null, 0.0F, false));
+                        GenerateSingleLiteralExpression(type: null, 0.0F, canUseFieldReference: false),
+                        GenerateSingleLiteralExpression(type: null, 0.0F, canUseFieldReference: false));
                 }
                 else if (float.IsPositiveInfinity(value))
                 {
                     return SyntaxFactory.BinaryExpression(SyntaxKind.DivideExpression,
-                        GenerateSingleLiteralExpression(null, 1.0F, false),
-                        GenerateSingleLiteralExpression(null, 0.0F, false));
+                        GenerateSingleLiteralExpression(type: null, 1.0F, canUseFieldReference: false),
+                        GenerateSingleLiteralExpression(type: null, 0.0F, canUseFieldReference: false));
                 }
                 else if (float.IsNegativeInfinity(value))
                 {
@@ -226,27 +225,27 @@ private static ExpressionSyntax GenerateSingleLiteralExpression(ITypeSymbol type
             }
 
             return GenerateLiteralExpression(
-                type, value, LiteralSpecialValues.SingleSpecialValues, "R", canUseFieldReference,
+                type, value, LiteralSpecialValues.SingleSpecialValues, formatString: "R", canUseFieldReference,
                 SyntaxFactory.Literal, x => x < 0, x => -x, null);
         }
 
         private static ExpressionSyntax GenerateNonNegativeLiteralExpression<T>(
-            ITypeSymbol type, T value, IEnumerable<KeyValuePair<T, string>> constants,
-            string formatString, bool canUseFieldReference,
+            ITypeSymbol? type, T value, IEnumerable<KeyValuePair<T, string>> constants,
+            string? formatString, bool canUseFieldReference,
             Func<string, T, SyntaxToken> tokenFactory)
             where T : IEquatable<T>
         {
             return GenerateLiteralExpression(
                 type, value, constants, formatString, canUseFieldReference,
-                tokenFactory, isNegative: x => false, negate: t => throw new InvalidOperationException(), null);
+                tokenFactory, isNegative: x => false, negate: t => throw new InvalidOperationException(), integerMinValueString: null);
         }
 
         private static ExpressionSyntax GenerateLiteralExpression<T>(
-            ITypeSymbol type, T value, IEnumerable<KeyValuePair<T, string>> constants,
-            string formatString, bool canUseFieldReference,
+            ITypeSymbol? type, T value, IEnumerable<KeyValuePair<T, string>> constants,
+            string? formatString, bool canUseFieldReference,
             Func<string, T, SyntaxToken> tokenFactory,
             Func<T, bool> isNegative, Func<T, T> negate,
-            string integerMinValueString)
+            string? integerMinValueString)
             where T : IEquatable<T>
         {
             if (canUseFieldReference)
@@ -267,7 +266,7 @@ private static ExpressionSyntax GenerateLiteralExpression<T>(
             var suffix = DetermineSuffix(type, nonNegativeValue);
 
             var stringValue = negative && nonNegativeValue.Equals(value)
-                ? integerMinValueString
+                ? (integerMinValueString ?? throw ExceptionUtilities.Unreachable)
                 : ((IFormattable)nonNegativeValue).ToString(formatString, CultureInfo.InvariantCulture) + suffix;
 
             var literal = SyntaxFactory.LiteralExpression(
@@ -278,7 +277,8 @@ private static ExpressionSyntax GenerateLiteralExpression<T>(
                 : literal;
         }
 
-        private static ExpressionSyntax GenerateFieldReference<T>(ITypeSymbol type, T value, IEnumerable<KeyValuePair<T, string>> constants)
+        private static ExpressionSyntax? GenerateFieldReference<T>(ITypeSymbol? type, T value, IEnumerable<KeyValuePair<T, string>> constants)
+            where T : IEquatable<T>
         {
             foreach (var constant in constants)
             {
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/FieldGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/FieldGenerator.cs
index 85bc9ef09ec06..99b01782afe1b 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/FieldGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/FieldGenerator.cs
@@ -2,10 +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.
 
-#nullable disable
-
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -52,10 +51,11 @@ private static MemberDeclarationSyntax LastField(
         internal static CompilationUnitSyntax AddFieldTo(
             CompilationUnitSyntax destination,
             IFieldSymbol field,
-            CodeGenerationOptions options,
-            IList<bool> availableIndices)
+            CSharpCodeGenerationOptions options,
+            IList<bool>? availableIndices,
+            CancellationToken cancellationToken)
         {
-            var declaration = GenerateFieldDeclaration(field, options);
+            var declaration = GenerateFieldDeclaration(field, options, cancellationToken);
 
             // Place the field after the last field or const, or at the start of the type
             // declaration.
@@ -67,21 +67,22 @@ internal static CompilationUnitSyntax AddFieldTo(
         internal static TypeDeclarationSyntax AddFieldTo(
             TypeDeclarationSyntax destination,
             IFieldSymbol field,
-            CodeGenerationOptions options,
-            IList<bool> availableIndices)
+            CSharpCodeGenerationOptions options,
+            IList<bool>? availableIndices,
+            CancellationToken cancellationToken)
         {
-            var declaration = GenerateFieldDeclaration(field, options);
+            var declaration = GenerateFieldDeclaration(field, options, cancellationToken);
 
             // Place the field after the last field or const, or at the start of the type
             // declaration.
             var members = Insert(destination.Members, declaration, options, availableIndices,
                 after: m => LastField(m, declaration), before: FirstMember);
 
-            return AddMembersTo(destination, members);
+            return AddMembersTo(destination, members, cancellationToken);
         }
 
         public static FieldDeclarationSyntax GenerateFieldDeclaration(
-            IFieldSymbol field, CodeGenerationOptions options)
+            IFieldSymbol field, CSharpCodeGenerationOptions options, CancellationToken cancellationToken)
         {
             var reusableSyntax = GetReuseableSyntaxNodeForSymbol<FieldDeclarationSyntax>(field, options);
             if (reusableSyntax != null)
@@ -102,10 +103,10 @@ public static FieldDeclarationSyntax GenerateFieldDeclaration(
                         AddAnnotationsTo(field, SyntaxFactory.VariableDeclarator(field.Name.ToIdentifierToken(), null, initializer)))));
 
             return AddFormatterAndCodeGeneratorAnnotationsTo(
-                ConditionallyAddDocumentationCommentTo(fieldDeclaration, field, options));
+                ConditionallyAddDocumentationCommentTo(fieldDeclaration, field, options, cancellationToken));
         }
 
-        private static EqualsValueClauseSyntax GenerateEqualsValue(IFieldSymbol field)
+        private static EqualsValueClauseSyntax? GenerateEqualsValue(IFieldSymbol field)
         {
             if (field.HasConstantValue)
             {
@@ -116,7 +117,7 @@ private static EqualsValueClauseSyntax GenerateEqualsValue(IFieldSymbol field)
             return null;
         }
 
-        private static SyntaxTokenList GenerateModifiers(IFieldSymbol field, CodeGenerationOptions options)
+        private static SyntaxTokenList GenerateModifiers(IFieldSymbol field, CSharpCodeGenerationOptions options)
         {
             var tokens = ArrayBuilder<SyntaxToken>.GetInstance();
 
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
index 0b30c1abcbd72..976acdbdf65ed 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/MethodGenerator.cs
@@ -2,11 +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.
 
-#nullable disable
-
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Threading;
 using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
@@ -27,12 +26,12 @@ internal static class MethodGenerator
         internal static BaseNamespaceDeclarationSyntax AddMethodTo(
             BaseNamespaceDeclarationSyntax destination,
             IMethodSymbol method,
-            CodeGenerationOptions options,
-            IList<bool> availableIndices)
+            CSharpCodeGenerationOptions options,
+            IList<bool>? availableIndices,
+            CancellationToken cancellationToken)
         {
-            var declaration = GenerateMethodDeclaration(
-                method, CodeGenerationDestination.Namespace, options,
-                destination?.SyntaxTree.Options ?? options.ParseOptions);
+            var declaration = GenerateMethodDeclaration(method, CodeGenerationDestination.Namespace, options, cancellationToken);
+
             var members = Insert(destination.Members, declaration, options, availableIndices, after: LastMethod);
             return destination.WithMembers(members.ToSyntaxList());
         }
@@ -40,12 +39,14 @@ internal static BaseNamespaceDeclarationSyntax AddMethodTo(
         internal static CompilationUnitSyntax AddMethodTo(
             CompilationUnitSyntax destination,
             IMethodSymbol method,
-            CodeGenerationOptions options,
-            IList<bool> availableIndices)
+            CSharpCodeGenerationOptions options,
+            IList<bool>? availableIndices,
+            CancellationToken cancellationToken)
         {
             var declaration = GenerateMethodDeclaration(
                 method, CodeGenerationDestination.CompilationUnit, options,
-                destination?.SyntaxTree.Options ?? options.ParseOptions);
+                cancellationToken);
+
             var members = Insert(destination.Members, declaration, options, availableIndices, after: LastMethod);
             return destination.WithMembers(members.ToSyntaxList());
         }
@@ -53,26 +54,24 @@ internal static CompilationUnitSyntax AddMethodTo(
         internal static TypeDeclarationSyntax AddMethodTo(
             TypeDeclarationSyntax destination,
             IMethodSymbol method,
-            CodeGenerationOptions options,
-            IList<bool> availableIndices)
+            CSharpCodeGenerationOptions options,
+            IList<bool>? availableIndices,
+            CancellationToken cancellationToken)
         {
             var methodDeclaration = GenerateMethodDeclaration(
-                method, GetDestination(destination), options,
-                destination?.SyntaxTree.Options ?? options.ParseOptions);
+                method, GetDestination(destination), options, cancellationToken);
 
             // Create a clone of the original type with the new method inserted. 
             var members = Insert(destination.Members, methodDeclaration, options, availableIndices, after: LastMethod);
 
-            return AddMembersTo(destination, members);
+            return AddMembersTo(destination, members, cancellationToken);
         }
 
         public static MethodDeclarationSyntax GenerateMethodDeclaration(
             IMethodSymbol method, CodeGenerationDestination destination,
-            CodeGenerationOptions options,
-            ParseOptions parseOptions)
+            CSharpCodeGenerationOptions options,
+            CancellationToken cancellationToken)
         {
-            options ??= CodeGenerationOptions.Default;
-
             var reusableSyntax = GetReuseableSyntaxNodeForSymbol<MethodDeclarationSyntax>(method, options);
             if (reusableSyntax != null)
             {
@@ -80,19 +79,18 @@ public static MethodDeclarationSyntax GenerateMethodDeclaration(
             }
 
             var declaration = GenerateMethodDeclarationWorker(
-                method, destination, options, parseOptions);
+                method, destination, options);
 
             return AddAnnotationsTo(method,
-                ConditionallyAddDocumentationCommentTo(declaration, method, options));
+                ConditionallyAddDocumentationCommentTo(declaration, method, options, cancellationToken));
         }
 
         public static LocalFunctionStatementSyntax GenerateLocalFunctionDeclaration(
-            IMethodSymbol method, CodeGenerationDestination destination,
-            CodeGenerationOptions options,
-            ParseOptions parseOptions)
+            IMethodSymbol method,
+            CodeGenerationDestination destination,
+            CSharpCodeGenerationOptions options,
+            CancellationToken cancellationToken)
         {
-            options ??= CodeGenerationOptions.Default;
-
             var reusableSyntax = GetReuseableSyntaxNodeForSymbol<LocalFunctionStatementSyntax>(method, options);
             if (reusableSyntax != null)
             {
@@ -100,21 +98,21 @@ public static LocalFunctionStatementSyntax GenerateLocalFunctionDeclaration(
             }
 
             var declaration = GenerateLocalFunctionDeclarationWorker(
-                method, destination, options, parseOptions);
+                method, destination, options);
 
             return AddAnnotationsTo(method,
-                ConditionallyAddDocumentationCommentTo(declaration, method, options));
+                ConditionallyAddDocumentationCommentTo(declaration, method, options, cancellationToken));
         }
 
         private static MethodDeclarationSyntax GenerateMethodDeclarationWorker(
             IMethodSymbol method, CodeGenerationDestination destination,
-            CodeGenerationOptions options, ParseOptions parseOptions)
+            CSharpCodeGenerationOptions options)
         {
             // Don't rely on destination to decide if method body should be generated.
             // Users of this service need to express their intention explicitly, either by  
             // setting `CodeGenerationOptions.GenerateMethodBodies` to true, or making 
             // `method` abstract. This would provide more flexibility.
-            var hasNoBody = !options.GenerateMethodBodies || method.IsAbstract;
+            var hasNoBody = !options.Context.GenerateMethodBodies || method.IsAbstract;
 
             var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(method.ExplicitInterfaceImplementations);
 
@@ -131,13 +129,13 @@ private static MethodDeclarationSyntax GenerateMethodDeclarationWorker(
                 expressionBody: null,
                 semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : default);
 
-            methodDeclaration = UseExpressionBodyIfDesired(options, methodDeclaration, parseOptions);
+            methodDeclaration = UseExpressionBodyIfDesired(options, methodDeclaration);
             return AddFormatterAndCodeGeneratorAnnotationsTo(methodDeclaration);
         }
 
         private static LocalFunctionStatementSyntax GenerateLocalFunctionDeclarationWorker(
             IMethodSymbol method, CodeGenerationDestination destination,
-            CodeGenerationOptions options, ParseOptions parseOptions)
+            CSharpCodeGenerationOptions options)
         {
             var localFunctionDeclaration = SyntaxFactory.LocalFunctionStatement(
                 modifiers: GenerateModifiers(method, destination, options),
@@ -150,19 +148,20 @@ private static LocalFunctionStatementSyntax GenerateLocalFunctionDeclarationWork
                 expressionBody: null,
                 semicolonToken: default);
 
-            localFunctionDeclaration = UseExpressionBodyIfDesired(options, localFunctionDeclaration, parseOptions);
+            localFunctionDeclaration = UseExpressionBodyIfDesired(options, localFunctionDeclaration);
             return AddFormatterAndCodeGeneratorAnnotationsTo(localFunctionDeclaration);
         }
 
         private static MethodDeclarationSyntax UseExpressionBodyIfDesired(
-            CodeGenerationOptions options, MethodDeclarationSyntax methodDeclaration, ParseOptions parseOptions)
+            CSharpCodeGenerationOptions options, MethodDeclarationSyntax methodDeclaration)
         {
             if (methodDeclaration.ExpressionBody == null)
             {
-                var expressionBodyPreference = options.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedMethods).Value;
-                if (methodDeclaration.Body.TryConvertToArrowExpressionBody(
-                        methodDeclaration.Kind(), parseOptions, expressionBodyPreference,
-                        out var expressionBody, out var semicolonToken))
+                var expressionBodyPreference = options.Preferences.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedMethods).Value;
+
+                if (methodDeclaration.Body?.TryConvertToArrowExpressionBody(
+                    methodDeclaration.Kind(), options.Preferences.LanguageVersion, expressionBodyPreference,
+                    out var expressionBody, out var semicolonToken) == true)
                 {
                     return methodDeclaration.WithBody(null)
                                             .WithExpressionBody(expressionBody)
@@ -174,14 +173,15 @@ private static MethodDeclarationSyntax UseExpressionBodyIfDesired(
         }
 
         private static LocalFunctionStatementSyntax UseExpressionBodyIfDesired(
-            CodeGenerationOptions options, LocalFunctionStatementSyntax localFunctionDeclaration, ParseOptions parseOptions)
+            CSharpCodeGenerationOptions options, LocalFunctionStatementSyntax localFunctionDeclaration)
         {
             if (localFunctionDeclaration.ExpressionBody == null)
             {
-                var expressionBodyPreference = options.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedLocalFunctions).Value;
-                if (localFunctionDeclaration.Body.TryConvertToArrowExpressionBody(
-                        localFunctionDeclaration.Kind(), parseOptions, expressionBodyPreference,
-                        out var expressionBody, out var semicolonToken))
+                var expressionBodyPreference = options.Preferences.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedLocalFunctions).Value;
+
+                if (localFunctionDeclaration.Body?.TryConvertToArrowExpressionBody(
+                    localFunctionDeclaration.Kind(), options.Preferences.LanguageVersion, expressionBodyPreference,
+                    out var expressionBody, out var semicolonToken) == true)
                 {
                     return localFunctionDeclaration.WithBody(null)
                                                  .WithExpressionBody(expressionBody)
@@ -193,7 +193,7 @@ private static LocalFunctionStatementSyntax UseExpressionBodyIfDesired(
         }
 
         private static SyntaxList<AttributeListSyntax> GenerateAttributes(
-            IMethodSymbol method, CodeGenerationOptions options, bool isExplicit)
+            IMethodSymbol method, CSharpCodeGenerationOptions options, bool isExplicit)
         {
             var attributes = new List<AttributeListSyntax>();
 
@@ -247,14 +247,14 @@ private static SyntaxList<TypeParameterConstraintClauseSyntax> GenerateDefaultCo
             return SyntaxFactory.List(listOfClauses);
         }
 
-        private static TypeParameterListSyntax GenerateTypeParameterList(
-            IMethodSymbol method, CodeGenerationOptions options)
+        private static TypeParameterListSyntax? GenerateTypeParameterList(
+            IMethodSymbol method, CSharpCodeGenerationOptions options)
         {
             return TypeParameterGenerator.GenerateTypeParameterList(method.TypeParameters, options);
         }
 
         private static SyntaxTokenList GenerateModifiers(
-            IMethodSymbol method, CodeGenerationDestination destination, CodeGenerationOptions options)
+            IMethodSymbol method, CodeGenerationDestination destination, CSharpCodeGenerationOptions options)
         {
             var tokens = ArrayBuilder<SyntaxToken>.GetInstance();
 
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/NamedTypeGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/NamedTypeGenerator.cs
index fbe7425610b39..70e8a4b6bbbac 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/NamedTypeGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/NamedTypeGenerator.cs
@@ -23,22 +23,22 @@ public static TypeDeclarationSyntax AddNamedTypeTo(
             ICodeGenerationService service,
             TypeDeclarationSyntax destination,
             INamedTypeSymbol namedType,
-            CodeGenerationOptions options,
-            IList<bool> availableIndices,
+            CSharpCodeGenerationOptions options,
+            IList<bool>? availableIndices,
             CancellationToken cancellationToken)
         {
             var declaration = GenerateNamedTypeDeclaration(service, namedType, GetDestination(destination), options, cancellationToken);
             var members = Insert(destination.Members, declaration, options, availableIndices);
 
-            return AddMembersTo(destination, members);
+            return AddMembersTo(destination, members, cancellationToken);
         }
 
         public static BaseNamespaceDeclarationSyntax AddNamedTypeTo(
             ICodeGenerationService service,
             BaseNamespaceDeclarationSyntax destination,
             INamedTypeSymbol namedType,
-            CodeGenerationOptions options,
-            IList<bool> availableIndices,
+            CSharpCodeGenerationOptions options,
+            IList<bool>? availableIndices,
             CancellationToken cancellationToken)
         {
             var declaration = GenerateNamedTypeDeclaration(service, namedType, CodeGenerationDestination.Namespace, options, cancellationToken);
@@ -52,8 +52,8 @@ public static CompilationUnitSyntax AddNamedTypeTo(
             ICodeGenerationService service,
             CompilationUnitSyntax destination,
             INamedTypeSymbol namedType,
-            CodeGenerationOptions options,
-            IList<bool> availableIndices,
+            CSharpCodeGenerationOptions options,
+            IList<bool>? availableIndices,
             CancellationToken cancellationToken)
         {
             var declaration = GenerateNamedTypeDeclaration(service, namedType, CodeGenerationDestination.CompilationUnit, options, cancellationToken);
@@ -65,11 +65,9 @@ public static MemberDeclarationSyntax GenerateNamedTypeDeclaration(
             ICodeGenerationService service,
             INamedTypeSymbol namedType,
             CodeGenerationDestination destination,
-            CodeGenerationOptions options,
+            CSharpCodeGenerationOptions options,
             CancellationToken cancellationToken)
         {
-            options ??= CodeGenerationOptions.Default;
-
             var declaration = GetDeclarationSyntaxWithoutMembers(namedType, destination, options);
 
             // If we are generating members then make sure to exclude properties that cannot be generated.
@@ -88,9 +86,9 @@ public static MemberDeclarationSyntax GenerateNamedTypeDeclaration(
                 // If we're generating a ComImport type, then do not attempt to do any
                 // reordering of members.
                 if (namedType.IsComImport)
-                    options = options.With(autoInsertionLocation: false, sortMembers: false);
+                    options = options.WithContext(options.Context.With(autoInsertionLocation: false, sortMembers: false));
 
-                if (options.GenerateMembers && namedType.TypeKind != TypeKind.Delegate)
+                if (options.Context.GenerateMembers && namedType.TypeKind != TypeKind.Delegate)
                     declaration = service.AddMembers(declaration, members, options, cancellationToken);
             }
 
@@ -99,12 +97,12 @@ public static MemberDeclarationSyntax GenerateNamedTypeDeclaration(
 
         private static RecordDeclarationSyntax GenerateRecordMembers(
             ICodeGenerationService service,
-            CodeGenerationOptions options,
+            CSharpCodeGenerationOptions options,
             RecordDeclarationSyntax recordDeclaration,
             ImmutableArray<ISymbol> members,
             CancellationToken cancellationToken)
         {
-            if (!options.GenerateMembers)
+            if (!options.Context.GenerateMembers)
                 members = ImmutableArray<ISymbol>.Empty;
 
             // For a record, add record parameters if we have a primary constructor.
@@ -139,7 +137,7 @@ public static MemberDeclarationSyntax UpdateNamedTypeDeclaration(
             ICodeGenerationService service,
             MemberDeclarationSyntax declaration,
             IList<ISymbol> newMembers,
-            CodeGenerationOptions options,
+            CSharpCodeGenerationOptions options,
             CancellationToken cancellationToken)
         {
             declaration = RemoveAllMembers(declaration);
@@ -150,7 +148,7 @@ public static MemberDeclarationSyntax UpdateNamedTypeDeclaration(
         private static MemberDeclarationSyntax GetDeclarationSyntaxWithoutMembers(
             INamedTypeSymbol namedType,
             CodeGenerationDestination destination,
-            CodeGenerationOptions options)
+            CSharpCodeGenerationOptions options)
         {
             var reusableDeclarationSyntax = GetReuseableSyntaxNodeForSymbol<MemberDeclarationSyntax>(namedType, options);
             return reusableDeclarationSyntax == null
@@ -180,7 +178,7 @@ private static MemberDeclarationSyntax RemoveAllMembers(MemberDeclarationSyntax
         private static MemberDeclarationSyntax GetDeclarationSyntaxWithoutMembersWorker(
             INamedTypeSymbol namedType,
             CodeGenerationDestination destination,
-            CodeGenerationOptions options)
+            CSharpCodeGenerationOptions options)
         {
             if (namedType.TypeKind == TypeKind.Enum)
             {
@@ -224,7 +222,7 @@ private static MemberDeclarationSyntax GetDeclarationSyntaxWithoutMembersWorker(
         private static DelegateDeclarationSyntax GenerateDelegateDeclaration(
             INamedTypeSymbol namedType,
             CodeGenerationDestination destination,
-            CodeGenerationOptions options)
+            CSharpCodeGenerationOptions options)
         {
             var invokeMethod = namedType.DelegateInvokeMethod;
             Contract.ThrowIfNull(invokeMethod);
@@ -242,7 +240,7 @@ private static DelegateDeclarationSyntax GenerateDelegateDeclaration(
         private static EnumDeclarationSyntax GenerateEnumDeclaration(
             INamedTypeSymbol namedType,
             CodeGenerationDestination destination,
-            CodeGenerationOptions options)
+            CSharpCodeGenerationOptions options)
         {
             var baseList = namedType.EnumUnderlyingType != null && namedType.EnumUnderlyingType.SpecialType != SpecialType.System_Int32
                 ? SyntaxFactory.BaseList(SyntaxFactory.SingletonSeparatedList<BaseTypeSyntax>(SyntaxFactory.SimpleBaseType(namedType.EnumUnderlyingType.GenerateTypeSyntax())))
@@ -257,7 +255,7 @@ private static EnumDeclarationSyntax GenerateEnumDeclaration(
         }
 
         private static SyntaxList<AttributeListSyntax> GenerateAttributeDeclarations(
-            INamedTypeSymbol namedType, CodeGenerationOptions options)
+            INamedTypeSymbol namedType, CSharpCodeGenerationOptions options)
         {
             return AttributeGenerator.GenerateAttributeLists(namedType.GetAttributes(), options);
         }
@@ -265,7 +263,7 @@ private static SyntaxList<AttributeListSyntax> GenerateAttributeDeclarations(
         private static SyntaxTokenList GenerateModifiers(
             INamedTypeSymbol namedType,
             CodeGenerationDestination destination,
-            CodeGenerationOptions options)
+            CSharpCodeGenerationOptions options)
         {
             var tokens = ArrayBuilder<SyntaxToken>.GetInstance();
 
@@ -308,8 +306,8 @@ private static SyntaxTokenList GenerateModifiers(
             return tokens.ToSyntaxTokenListAndFree();
         }
 
-        private static TypeParameterListSyntax GenerateTypeParameterList(
-            INamedTypeSymbol namedType, CodeGenerationOptions options)
+        private static TypeParameterListSyntax? GenerateTypeParameterList(
+            INamedTypeSymbol namedType, CSharpCodeGenerationOptions options)
         {
             return TypeParameterGenerator.GenerateTypeParameterList(namedType.TypeParameters, options);
         }
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/NamespaceGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/NamespaceGenerator.cs
index acda791c41932..9dc6b5a800226 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/NamespaceGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/NamespaceGenerator.cs
@@ -24,14 +24,14 @@ public static BaseNamespaceDeclarationSyntax AddNamespaceTo(
             ICodeGenerationService service,
             BaseNamespaceDeclarationSyntax destination,
             INamespaceSymbol @namespace,
-            CodeGenerationOptions options,
-            IList<bool> availableIndices,
+            CSharpCodeGenerationOptions options,
+            IList<bool>? availableIndices,
             CancellationToken cancellationToken)
         {
             var declaration = GenerateNamespaceDeclaration(
                 service, @namespace,
                 CodeGenerationDestination.Namespace,
-                options, destination.SyntaxTree.Options ?? options.ParseOptions,
+                options,
                 cancellationToken);
             if (declaration is not BaseNamespaceDeclarationSyntax namespaceDeclaration)
                 throw new ArgumentException(CSharpWorkspaceResources.Namespace_can_not_be_added_in_this_destination);
@@ -44,15 +44,17 @@ public static CompilationUnitSyntax AddNamespaceTo(
             ICodeGenerationService service,
             CompilationUnitSyntax destination,
             INamespaceSymbol @namespace,
-            CodeGenerationOptions options,
-            IList<bool> availableIndices,
+            CSharpCodeGenerationOptions options,
+            IList<bool>? availableIndices,
             CancellationToken cancellationToken)
         {
             var declaration = GenerateNamespaceDeclaration(
-                service, @namespace,
+                service,
+                @namespace,
                 CodeGenerationDestination.CompilationUnit,
-                options, destination.SyntaxTree.Options ?? options.ParseOptions,
+                options,
                 cancellationToken);
+
             if (declaration is not BaseNamespaceDeclarationSyntax namespaceDeclaration)
                 throw new ArgumentException(CSharpWorkspaceResources.Namespace_can_not_be_added_in_this_destination);
 
@@ -64,17 +66,15 @@ internal static SyntaxNode GenerateNamespaceDeclaration(
             ICodeGenerationService service,
             INamespaceSymbol @namespace,
             CodeGenerationDestination destination,
-            CodeGenerationOptions options,
-            ParseOptions? parseOptions,
+            CSharpCodeGenerationOptions options,
             CancellationToken cancellationToken)
         {
-            options ??= CodeGenerationOptions.Default;
             GetNameAndInnermostNamespace(@namespace, options, out var name, out var innermostNamespace);
 
             var declaration = GetDeclarationSyntaxWithoutMembers(
-                @namespace, innermostNamespace, name, destination, options, parseOptions);
+                @namespace, innermostNamespace, name, destination, options);
 
-            declaration = options.GenerateMembers
+            declaration = options.Context.GenerateMembers
                 ? service.AddMembers(declaration, innermostNamespace.GetMembers(), options, cancellationToken)
                 : declaration;
 
@@ -85,7 +85,7 @@ public static SyntaxNode UpdateCompilationUnitOrNamespaceDeclaration(
             ICodeGenerationService service,
             SyntaxNode declaration,
             IList<ISymbol> newMembers,
-            CodeGenerationOptions options,
+            CSharpCodeGenerationOptions options,
             CancellationToken cancellationToken)
         {
             declaration = RemoveAllMembers(declaration);
@@ -96,8 +96,7 @@ public static SyntaxNode UpdateCompilationUnitOrNamespaceDeclaration(
         private static SyntaxNode GenerateNamespaceDeclarationWorker(
             string name, INamespaceSymbol innermostNamespace,
             CodeGenerationDestination destination,
-            CodeGenerationOptions options,
-            ParseOptions? parseOptions)
+            CSharpCodeGenerationOptions options)
         {
             var usings = GenerateUsingDirectives(innermostNamespace);
 
@@ -106,8 +105,8 @@ private static SyntaxNode GenerateNamespaceDeclarationWorker(
                 return SyntaxFactory.CompilationUnit().WithUsings(usings);
 
             if (destination == CodeGenerationDestination.CompilationUnit &&
-                options.Options?.GetOption(CSharpCodeStyleOptions.NamespaceDeclarations).Value == NamespaceDeclarationPreference.FileScoped &&
-                ((CSharpParseOptions?)parseOptions)?.LanguageVersion >= LanguageVersion.CSharp10)
+                options.Preferences.Options.GetOption(CSharpCodeStyleOptions.NamespaceDeclarations).Value == NamespaceDeclarationPreference.FileScoped &&
+                options.Preferences.LanguageVersion >= LanguageVersion.CSharp10)
             {
                 return SyntaxFactory.FileScopedNamespaceDeclaration(SyntaxFactory.ParseName(name)).WithUsings(usings);
             }
@@ -120,12 +119,11 @@ private static SyntaxNode GetDeclarationSyntaxWithoutMembers(
             INamespaceSymbol innermostNamespace,
             string name,
             CodeGenerationDestination destination,
-            CodeGenerationOptions options,
-            ParseOptions? parseOptions)
+            CSharpCodeGenerationOptions options)
         {
             var reusableSyntax = GetReuseableSyntaxNodeForSymbol<SyntaxNode>(@namespace, options);
             return reusableSyntax == null
-                ? GenerateNamespaceDeclarationWorker(name, innermostNamespace, destination, options, parseOptions)
+                ? GenerateNamespaceDeclarationWorker(name, innermostNamespace, destination, options)
                 : RemoveAllMembers(reusableSyntax);
         }
 
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/OperatorGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/OperatorGenerator.cs
index 570cdbf4041d7..ee6d9ae5190bb 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/OperatorGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/OperatorGenerator.cs
@@ -2,10 +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.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
@@ -22,21 +21,20 @@ internal static class OperatorGenerator
         internal static TypeDeclarationSyntax AddOperatorTo(
             TypeDeclarationSyntax destination,
             IMethodSymbol method,
-            CodeGenerationOptions options,
-            IList<bool> availableIndices)
+            CSharpCodeGenerationOptions options,
+            IList<bool>? availableIndices,
+            CancellationToken cancellationToken)
         {
-            var methodDeclaration = GenerateOperatorDeclaration(
-                method, options, destination?.SyntaxTree.Options ?? options.ParseOptions);
-
+            var methodDeclaration = GenerateOperatorDeclaration(method, options, cancellationToken);
             var members = Insert(destination.Members, methodDeclaration, options, availableIndices, after: LastOperator);
 
-            return AddMembersTo(destination, members);
+            return AddMembersTo(destination, members, cancellationToken);
         }
 
         internal static OperatorDeclarationSyntax GenerateOperatorDeclaration(
             IMethodSymbol method,
-            CodeGenerationOptions options,
-            ParseOptions parseOptions)
+            CSharpCodeGenerationOptions options,
+            CancellationToken cancellationToken)
         {
             var reusableSyntax = GetReuseableSyntaxNodeForSymbol<OperatorDeclarationSyntax>(method, options);
             if (reusableSyntax != null)
@@ -44,22 +42,23 @@ internal static OperatorDeclarationSyntax GenerateOperatorDeclaration(
                 return reusableSyntax;
             }
 
-            var declaration = GenerateOperatorDeclarationWorker(method, options, parseOptions);
-            declaration = UseExpressionBodyIfDesired(options, declaration, parseOptions);
+            var declaration = GenerateOperatorDeclarationWorker(method, options);
+            declaration = UseExpressionBodyIfDesired(options, declaration);
 
             return AddAnnotationsTo(method,
-                ConditionallyAddDocumentationCommentTo(declaration, method, options));
+                ConditionallyAddDocumentationCommentTo(declaration, method, options, cancellationToken));
         }
 
         private static OperatorDeclarationSyntax UseExpressionBodyIfDesired(
-            CodeGenerationOptions options, OperatorDeclarationSyntax declaration, ParseOptions parseOptions)
+            CSharpCodeGenerationOptions options, OperatorDeclarationSyntax declaration)
         {
             if (declaration.ExpressionBody == null)
             {
-                var expressionBodyPreference = options.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedOperators).Value;
-                if (declaration.Body.TryConvertToArrowExpressionBody(
-                        declaration.Kind(), parseOptions, expressionBodyPreference,
-                        out var expressionBody, out var semicolonToken))
+                var expressionBodyPreference = options.Preferences.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedOperators).Value;
+
+                if (declaration.Body?.TryConvertToArrowExpressionBody(
+                    declaration.Kind(), options.Preferences.LanguageVersion, expressionBodyPreference,
+                    out var expressionBody, out var semicolonToken) == true)
                 {
                     return declaration.WithBody(null)
                                       .WithExpressionBody(expressionBody)
@@ -72,10 +71,9 @@ private static OperatorDeclarationSyntax UseExpressionBodyIfDesired(
 
         private static OperatorDeclarationSyntax GenerateOperatorDeclarationWorker(
             IMethodSymbol method,
-            CodeGenerationOptions options,
-            ParseOptions parseOptions)
+            CSharpCodeGenerationOptions options)
         {
-            var hasNoBody = !options.GenerateMethodBodies || method.IsExtern || method.IsAbstract;
+            var hasNoBody = !options.Context.GenerateMethodBodies || method.IsExtern || method.IsAbstract;
 
             var operatorSyntaxKind = SyntaxFacts.GetOperatorKind(method.MetadataName);
             if (operatorSyntaxKind == SyntaxKind.None)
@@ -97,7 +95,7 @@ private static OperatorDeclarationSyntax GenerateOperatorDeclarationWorker(
                 expressionBody: null,
                 semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : new SyntaxToken());
 
-            operatorDecl = UseExpressionBodyIfDesired(options, operatorDecl, parseOptions);
+            operatorDecl = UseExpressionBodyIfDesired(options, operatorDecl);
             return operatorDecl;
         }
 
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/ParameterGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/ParameterGenerator.cs
index 8303e82b2a70d..106030f2ea566 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/ParameterGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/ParameterGenerator.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
@@ -22,7 +20,7 @@ internal static class ParameterGenerator
         public static ParameterListSyntax GenerateParameterList(
             ImmutableArray<IParameterSymbol> parameterDefinitions,
             bool isExplicit,
-            CodeGenerationOptions options)
+            CSharpCodeGenerationOptions options)
         {
             return GenerateParameterList((IEnumerable<IParameterSymbol>)parameterDefinitions, isExplicit, options);
         }
@@ -30,7 +28,7 @@ public static ParameterListSyntax GenerateParameterList(
         public static ParameterListSyntax GenerateParameterList(
             IEnumerable<IParameterSymbol> parameterDefinitions,
             bool isExplicit,
-            CodeGenerationOptions options)
+            CSharpCodeGenerationOptions options)
         {
             var parameters = GetParameters(parameterDefinitions, isExplicit, options);
 
@@ -40,7 +38,7 @@ public static ParameterListSyntax GenerateParameterList(
         public static BracketedParameterListSyntax GenerateBracketedParameterList(
             ImmutableArray<IParameterSymbol> parameterDefinitions,
             bool isExplicit,
-            CodeGenerationOptions options)
+            CSharpCodeGenerationOptions options)
         {
             return GenerateBracketedParameterList((IList<IParameterSymbol>)parameterDefinitions, isExplicit, options);
         }
@@ -48,7 +46,7 @@ public static BracketedParameterListSyntax GenerateBracketedParameterList(
         public static BracketedParameterListSyntax GenerateBracketedParameterList(
             IEnumerable<IParameterSymbol> parameterDefinitions,
             bool isExplicit,
-            CodeGenerationOptions options)
+            CSharpCodeGenerationOptions options)
         {
             // Bracketed parameter lists come from indexers.  Those don't have type parameters, so we
             // could never have a typeParameterMapping.
@@ -61,7 +59,7 @@ public static BracketedParameterListSyntax GenerateBracketedParameterList(
         internal static ImmutableArray<ParameterSyntax> GetParameters(
             IEnumerable<IParameterSymbol> parameterDefinitions,
             bool isExplicit,
-            CodeGenerationOptions options)
+            CSharpCodeGenerationOptions options)
         {
             var result = ArrayBuilder<ParameterSyntax>.GetInstance();
             var seenOptional = false;
@@ -78,7 +76,7 @@ internal static ImmutableArray<ParameterSyntax> GetParameters(
             return result.ToImmutableAndFree();
         }
 
-        internal static ParameterSyntax GetParameter(IParameterSymbol p, CodeGenerationOptions options, bool isExplicit, bool isFirstParam, bool seenOptional)
+        internal static ParameterSyntax GetParameter(IParameterSymbol p, CSharpCodeGenerationOptions options, bool isExplicit, bool isFirstParam, bool seenOptional)
         {
             var reusableSyntax = GetReuseableSyntaxNodeForSymbol<ParameterSyntax>(p, options);
             if (reusableSyntax != null)
@@ -113,7 +111,7 @@ parameter.ContainingSymbol is IMethodSymbol methodSymbol &&
             return list;
         }
 
-        private static EqualsValueClauseSyntax GenerateEqualsValueClause(
+        private static EqualsValueClauseSyntax? GenerateEqualsValueClause(
             IParameterSymbol parameter,
             bool isExplicit,
             bool seenOptional)
@@ -138,13 +136,13 @@ private static EqualsValueClauseSyntax GenerateEqualsValueClause(
 
         private static ExpressionSyntax GenerateEqualsValueClauseWorker(
             IParameterSymbol parameter,
-            object value)
+            object? value)
         {
             return ExpressionGenerator.GenerateExpression(parameter.Type, value, canUseFieldReference: true);
         }
 
         private static SyntaxList<AttributeListSyntax> GenerateAttributes(
-            IParameterSymbol parameter, bool isExplicit, CodeGenerationOptions options)
+            IParameterSymbol parameter, bool isExplicit, CSharpCodeGenerationOptions options)
         {
             if (isExplicit)
             {
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/PropertyGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/PropertyGenerator.cs
index 9746a0c526809..6262f32e08917 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/PropertyGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/PropertyGenerator.cs
@@ -2,10 +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.
 
-#nullable disable
-
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using System.Threading;
 using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
@@ -25,7 +25,7 @@ internal static class PropertyGenerator
         public static bool CanBeGenerated(IPropertySymbol property)
             => property.IsIndexer || property.Parameters.Length == 0;
 
-        private static MemberDeclarationSyntax LastPropertyOrField(
+        private static MemberDeclarationSyntax? LastPropertyOrField(
             SyntaxList<MemberDeclarationSyntax> members)
         {
             var lastProperty = members.LastOrDefault(m => m is PropertyDeclarationSyntax);
@@ -35,12 +35,13 @@ private static MemberDeclarationSyntax LastPropertyOrField(
         internal static CompilationUnitSyntax AddPropertyTo(
             CompilationUnitSyntax destination,
             IPropertySymbol property,
-            CodeGenerationOptions options,
-            IList<bool> availableIndices)
+            CSharpCodeGenerationOptions options,
+            IList<bool>? availableIndices,
+            CancellationToken cancellationToken)
         {
             var declaration = GeneratePropertyOrIndexer(
                 property, CodeGenerationDestination.CompilationUnit, options,
-                destination?.SyntaxTree.Options ?? options.ParseOptions);
+                cancellationToken);
 
             var members = Insert(destination.Members, declaration, options,
                 availableIndices, after: LastPropertyOrField, before: FirstMember);
@@ -50,11 +51,11 @@ internal static CompilationUnitSyntax AddPropertyTo(
         internal static TypeDeclarationSyntax AddPropertyTo(
             TypeDeclarationSyntax destination,
             IPropertySymbol property,
-            CodeGenerationOptions options,
-            IList<bool> availableIndices)
+            CSharpCodeGenerationOptions options,
+            IList<bool>? availableIndices,
+            CancellationToken cancellationToken)
         {
-            var declaration = GeneratePropertyOrIndexer(property, GetDestination(destination),
-                options, destination?.SyntaxTree.Options ?? options.ParseOptions);
+            var declaration = GeneratePropertyOrIndexer(property, GetDestination(destination), options, cancellationToken);
 
             // Create a clone of the original type with the new method inserted. 
             var members = Insert(destination.Members, declaration, options,
@@ -62,14 +63,14 @@ internal static TypeDeclarationSyntax AddPropertyTo(
 
             // Find the best place to put the field.  It should go after the last field if we already
             // have fields, or at the beginning of the file if we don't.
-            return AddMembersTo(destination, members);
+            return AddMembersTo(destination, members, cancellationToken);
         }
 
         public static MemberDeclarationSyntax GeneratePropertyOrIndexer(
             IPropertySymbol property,
             CodeGenerationDestination destination,
-            CodeGenerationOptions options,
-            ParseOptions parseOptions)
+            CSharpCodeGenerationOptions options,
+            CancellationToken cancellationToken)
         {
             var reusableSyntax = GetReuseableSyntaxNodeForSymbol<MemberDeclarationSyntax>(property, options);
             if (reusableSyntax != null)
@@ -78,17 +79,16 @@ public static MemberDeclarationSyntax GeneratePropertyOrIndexer(
             }
 
             var declaration = property.IsIndexer
-                ? GenerateIndexerDeclaration(property, destination, options, parseOptions)
-                : GeneratePropertyDeclaration(property, destination, options, parseOptions);
+                ? GenerateIndexerDeclaration(property, destination, options)
+                : GeneratePropertyDeclaration(property, destination, options);
 
-            return ConditionallyAddDocumentationCommentTo(declaration, property, options);
+            return ConditionallyAddDocumentationCommentTo(declaration, property, options, cancellationToken);
         }
 
         private static MemberDeclarationSyntax GenerateIndexerDeclaration(
             IPropertySymbol property,
             CodeGenerationDestination destination,
-            CodeGenerationOptions options,
-            ParseOptions parseOptions)
+            CSharpCodeGenerationOptions options)
         {
             var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(property.ExplicitInterfaceImplementations);
 
@@ -98,8 +98,8 @@ private static MemberDeclarationSyntax GenerateIndexerDeclaration(
                     type: GenerateTypeSyntax(property),
                     explicitInterfaceSpecifier: explicitInterfaceSpecifier,
                     parameterList: ParameterGenerator.GenerateBracketedParameterList(property.Parameters, explicitInterfaceSpecifier != null, options),
-                    accessorList: GenerateAccessorList(property, destination, options, parseOptions));
-            declaration = UseExpressionBodyIfDesired(options, declaration, parseOptions);
+                    accessorList: GenerateAccessorList(property, destination, options));
+            declaration = UseExpressionBodyIfDesired(options, declaration);
 
             return AddFormatterAndCodeGeneratorAnnotationsTo(
                 AddAnnotationsTo(property, declaration));
@@ -107,7 +107,7 @@ private static MemberDeclarationSyntax GenerateIndexerDeclaration(
 
         private static MemberDeclarationSyntax GeneratePropertyDeclaration(
            IPropertySymbol property, CodeGenerationDestination destination,
-           CodeGenerationOptions options, ParseOptions parseOptions)
+           CSharpCodeGenerationOptions options)
         {
             var initializer = CodeGenerationPropertyInfo.GetInitializer(property) is ExpressionSyntax initializerNode
                 ? SyntaxFactory.EqualsValueClause(initializerNode)
@@ -115,7 +115,7 @@ private static MemberDeclarationSyntax GeneratePropertyDeclaration(
 
             var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(property.ExplicitInterfaceImplementations);
 
-            var accessorList = GenerateAccessorList(property, destination, options, parseOptions);
+            var accessorList = GenerateAccessorList(property, destination, options);
 
             var propertyDeclaration = SyntaxFactory.PropertyDeclaration(
                 attributeLists: AttributeGenerator.GenerateAttributeLists(property.GetAttributes(), options),
@@ -127,7 +127,7 @@ private static MemberDeclarationSyntax GeneratePropertyDeclaration(
                 expressionBody: null,
                 initializer: initializer);
 
-            propertyDeclaration = UseExpressionBodyIfDesired(options, propertyDeclaration, parseOptions);
+            propertyDeclaration = UseExpressionBodyIfDesired(options, propertyDeclaration);
 
             return AddFormatterAndCodeGeneratorAnnotationsTo(
                 AddAnnotationsTo(property, propertyDeclaration));
@@ -152,18 +152,18 @@ private static TypeSyntax GenerateTypeSyntax(IPropertySymbol property)
         }
 
         private static bool TryGetExpressionBody(
-            BasePropertyDeclarationSyntax baseProperty, ParseOptions options, ExpressionBodyPreference preference,
-            out ArrowExpressionClauseSyntax arrowExpression, out SyntaxToken semicolonToken)
+            BasePropertyDeclarationSyntax baseProperty, LanguageVersion languageVersion, ExpressionBodyPreference preference,
+            [NotNullWhen(true)] out ArrowExpressionClauseSyntax? arrowExpression, out SyntaxToken semicolonToken)
         {
             var accessorList = baseProperty.AccessorList;
             if (preference != ExpressionBodyPreference.Never &&
-                accessorList.Accessors.Count == 1)
+                accessorList?.Accessors.Count == 1)
             {
                 var accessor = accessorList.Accessors[0];
                 if (accessor.IsKind(SyntaxKind.GetAccessorDeclaration))
                 {
                     return TryGetArrowExpressionBody(
-                        baseProperty.Kind(), accessor, options, preference,
+                        baseProperty.Kind(), accessor, languageVersion, preference,
                         out arrowExpression, out semicolonToken);
                 }
             }
@@ -174,15 +174,15 @@ private static bool TryGetExpressionBody(
         }
 
         private static PropertyDeclarationSyntax UseExpressionBodyIfDesired(
-            CodeGenerationOptions options, PropertyDeclarationSyntax declaration, ParseOptions parseOptions)
+            CSharpCodeGenerationOptions options, PropertyDeclarationSyntax declaration)
         {
             if (declaration.ExpressionBody == null)
             {
-                var expressionBodyPreference = options.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties).Value;
+                var expressionBodyPreference = options.Preferences.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties).Value;
                 if (declaration.Initializer == null)
                 {
                     if (TryGetExpressionBody(
-                            declaration, parseOptions, expressionBodyPreference,
+                            declaration, options.Preferences.LanguageVersion, expressionBodyPreference,
                             out var expressionBody, out var semicolonToken))
                     {
                         declaration = declaration.WithAccessorList(null)
@@ -196,13 +196,14 @@ private static PropertyDeclarationSyntax UseExpressionBodyIfDesired(
         }
 
         private static IndexerDeclarationSyntax UseExpressionBodyIfDesired(
-            CodeGenerationOptions options, IndexerDeclarationSyntax declaration, ParseOptions parseOptions)
+            CSharpCodeGenerationOptions options, IndexerDeclarationSyntax declaration)
         {
             if (declaration.ExpressionBody == null)
             {
-                var expressionBodyPreference = options.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers).Value;
+                var expressionBodyPreference = options.Preferences.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers).Value;
+
                 if (TryGetExpressionBody(
-                        declaration, parseOptions, expressionBodyPreference,
+                        declaration, options.Preferences.LanguageVersion, expressionBodyPreference,
                         out var expressionBody, out var semicolonToken))
                 {
                     declaration = declaration.WithAccessorList(null)
@@ -215,14 +216,15 @@ private static IndexerDeclarationSyntax UseExpressionBodyIfDesired(
         }
 
         private static AccessorDeclarationSyntax UseExpressionBodyIfDesired(
-            CodeGenerationOptions options, AccessorDeclarationSyntax declaration, ParseOptions parseOptions)
+            CSharpCodeGenerationOptions options, AccessorDeclarationSyntax declaration)
         {
             if (declaration.ExpressionBody == null)
             {
-                var expressionBodyPreference = options.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors).Value;
-                if (declaration.Body.TryConvertToArrowExpressionBody(
-                        declaration.Kind(), parseOptions, expressionBodyPreference,
-                        out var expressionBody, out var semicolonToken))
+                var expressionBodyPreference = options.Preferences.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors).Value;
+
+                if (declaration.Body?.TryConvertToArrowExpressionBody(
+                    declaration.Kind(), options.Preferences.LanguageVersion, expressionBodyPreference,
+                    out var expressionBody, out var semicolonToken) == true)
                 {
                     declaration = declaration.WithBody(null)
                                              .WithExpressionBody(expressionBody)
@@ -234,8 +236,8 @@ private static AccessorDeclarationSyntax UseExpressionBodyIfDesired(
         }
 
         private static bool TryGetArrowExpressionBody(
-            SyntaxKind declaratoinKind, AccessorDeclarationSyntax accessor, ParseOptions options, ExpressionBodyPreference preference,
-            out ArrowExpressionClauseSyntax arrowExpression, out SyntaxToken semicolonToken)
+            SyntaxKind declaratoinKind, AccessorDeclarationSyntax accessor, LanguageVersion languageVersion, ExpressionBodyPreference preference,
+            [NotNullWhen(true)] out ArrowExpressionClauseSyntax? arrowExpression, out SyntaxToken semicolonToken)
         {
             // If the accessor has an expression body already, then use that as the expression body
             // for the property.
@@ -246,19 +248,26 @@ private static bool TryGetArrowExpressionBody(
                 return true;
             }
 
+            if (accessor.Body == null)
+            {
+                arrowExpression = null;
+                semicolonToken = default;
+                return false;
+            }
+
             return accessor.Body.TryConvertToArrowExpressionBody(
-                declaratoinKind, options, preference, out arrowExpression, out semicolonToken);
+                declaratoinKind, languageVersion, preference, out arrowExpression, out semicolonToken);
         }
 
-        private static AccessorListSyntax GenerateAccessorList(
+        private static AccessorListSyntax? GenerateAccessorList(
             IPropertySymbol property, CodeGenerationDestination destination,
-            CodeGenerationOptions options, ParseOptions parseOptions)
+            CSharpCodeGenerationOptions options)
         {
             var setAccessorKind = property.SetMethod?.IsInitOnly == true ? SyntaxKind.InitAccessorDeclaration : SyntaxKind.SetAccessorDeclaration;
-            var accessors = new List<AccessorDeclarationSyntax>
+            var accessors = new[]
             {
-                GenerateAccessorDeclaration(property, property.GetMethod, SyntaxKind.GetAccessorDeclaration, destination, options, parseOptions),
-                GenerateAccessorDeclaration(property, property.SetMethod, setAccessorKind, destination, options, parseOptions),
+                GenerateAccessorDeclaration(property, property.GetMethod, SyntaxKind.GetAccessorDeclaration, destination, options),
+                GenerateAccessorDeclaration(property, property.SetMethod, setAccessorKind, destination, options),
             };
 
             return accessors[0] == null && accessors[1] == null
@@ -266,18 +275,17 @@ private static AccessorListSyntax GenerateAccessorList(
                 : SyntaxFactory.AccessorList(accessors.WhereNotNull().ToSyntaxList());
         }
 
-        private static AccessorDeclarationSyntax GenerateAccessorDeclaration(
+        private static AccessorDeclarationSyntax? GenerateAccessorDeclaration(
             IPropertySymbol property,
-            IMethodSymbol accessor,
+            IMethodSymbol? accessor,
             SyntaxKind kind,
             CodeGenerationDestination destination,
-            CodeGenerationOptions options,
-            ParseOptions parseOptions)
+            CSharpCodeGenerationOptions options)
         {
-            var hasBody = options.GenerateMethodBodies && HasAccessorBodies(property, destination, accessor);
+            var hasBody = options.Context.GenerateMethodBodies && HasAccessorBodies(property, destination, accessor);
             return accessor == null
                 ? null
-                : GenerateAccessorDeclaration(property, accessor, kind, hasBody, options, parseOptions);
+                : GenerateAccessorDeclaration(property, accessor, kind, hasBody, options);
         }
 
         private static AccessorDeclarationSyntax GenerateAccessorDeclaration(
@@ -285,15 +293,14 @@ private static AccessorDeclarationSyntax GenerateAccessorDeclaration(
             IMethodSymbol accessor,
             SyntaxKind kind,
             bool hasBody,
-            CodeGenerationOptions options,
-            ParseOptions parseOptions)
+            CSharpCodeGenerationOptions options)
         {
             var declaration = SyntaxFactory.AccessorDeclaration(kind)
                                            .WithModifiers(GenerateAccessorModifiers(property, accessor, options))
                                            .WithBody(hasBody ? GenerateBlock(accessor) : null)
                                            .WithSemicolonToken(hasBody ? default : SyntaxFactory.Token(SyntaxKind.SemicolonToken));
 
-            declaration = UseExpressionBodyIfDesired(options, declaration, parseOptions);
+            declaration = UseExpressionBodyIfDesired(options, declaration);
 
             return AddAnnotationsTo(accessor, declaration);
         }
@@ -307,7 +314,7 @@ private static BlockSyntax GenerateBlock(IMethodSymbol accessor)
         private static bool HasAccessorBodies(
             IPropertySymbol property,
             CodeGenerationDestination destination,
-            IMethodSymbol accessor)
+            IMethodSymbol? accessor)
         {
             return destination != CodeGenerationDestination.InterfaceType &&
                 !property.IsAbstract &&
@@ -318,7 +325,7 @@ private static bool HasAccessorBodies(
         private static SyntaxTokenList GenerateAccessorModifiers(
             IPropertySymbol property,
             IMethodSymbol accessor,
-            CodeGenerationOptions options)
+            CSharpCodeGenerationOptions options)
         {
             var modifiers = ArrayBuilder<SyntaxToken>.GetInstance();
 
@@ -338,7 +345,7 @@ private static SyntaxTokenList GenerateAccessorModifiers(
         }
 
         private static SyntaxTokenList GenerateModifiers(
-            IPropertySymbol property, CodeGenerationDestination destination, CodeGenerationOptions options)
+            IPropertySymbol property, CodeGenerationDestination destination, CSharpCodeGenerationOptions options)
         {
             var tokens = ArrayBuilder<SyntaxToken>.GetInstance();
 
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/StatementGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/StatementGenerator.cs
index 38b2e498be732..0121e42dbb684 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/StatementGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/StatementGenerator.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System.Collections.Generic;
 using System.Linq;
 using Microsoft.CodeAnalysis.CodeGeneration;
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/TypeParameterGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/TypeParameterGenerator.cs
index 8c7f055b91118..070704832e56d 100644
--- a/src/Workspaces/CSharp/Portable/CodeGeneration/TypeParameterGenerator.cs
+++ b/src/Workspaces/CSharp/Portable/CodeGeneration/TypeParameterGenerator.cs
@@ -1,9 +1,8 @@
-// Licensed to the .NET Foundation under one or more agreements.
+
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System.Collections.Immutable;
 using System.Linq;
 using Microsoft.CodeAnalysis.CodeGeneration;
@@ -14,8 +13,8 @@ namespace Microsoft.CodeAnalysis.CSharp.CodeGeneration
 {
     internal static class TypeParameterGenerator
     {
-        public static TypeParameterListSyntax GenerateTypeParameterList(
-            ImmutableArray<ITypeParameterSymbol> typeParameters, CodeGenerationOptions options)
+        public static TypeParameterListSyntax? GenerateTypeParameterList(
+            ImmutableArray<ITypeParameterSymbol> typeParameters, CSharpCodeGenerationOptions options)
         {
             return typeParameters.Length == 0
                 ? null
@@ -23,7 +22,7 @@ public static TypeParameterListSyntax GenerateTypeParameterList(
                     SyntaxFactory.SeparatedList(typeParameters.Select(t => GenerateTypeParameter(t, options))));
         }
 
-        private static TypeParameterSyntax GenerateTypeParameter(ITypeParameterSymbol symbol, CodeGenerationOptions options)
+        private static TypeParameterSyntax GenerateTypeParameter(ITypeParameterSymbol symbol, CSharpCodeGenerationOptions options)
         {
             var varianceKeyword =
                 symbol.Variance == VarianceKind.In ? SyntaxFactory.Token(SyntaxKind.InKeyword) :
diff --git a/src/Workspaces/Core/Portable/CodeGeneration/AbstractCodeGenerationService.cs b/src/Workspaces/Core/Portable/CodeGeneration/AbstractCodeGenerationService.cs
index 8c393950bbab5..6927b71945832 100644
--- a/src/Workspaces/Core/Portable/CodeGeneration/AbstractCodeGenerationService.cs
+++ b/src/Workspaces/Core/Portable/CodeGeneration/AbstractCodeGenerationService.cs
@@ -4,12 +4,14 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.LanguageServices;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Simplification;
@@ -17,76 +19,126 @@
 
 namespace Microsoft.CodeAnalysis.CodeGeneration
 {
-    internal abstract partial class AbstractCodeGenerationService : ICodeGenerationService
+    internal abstract partial class AbstractCodeGenerationService<TCodeGenerationOptions> : ICodeGenerationService
+        where TCodeGenerationOptions : CodeGenerationOptions
     {
         private readonly ISymbolDeclarationService _symbolDeclarationService;
-        protected readonly Workspace Workspace;
 
         protected AbstractCodeGenerationService(
-            ISymbolDeclarationService symbolDeclarationService,
-            Workspace workspace)
+            ISymbolDeclarationService symbolDeclarationService)
         {
             _symbolDeclarationService = symbolDeclarationService;
-            Workspace = workspace;
         }
 
-        public TDeclarationNode AddEvent<TDeclarationNode>(TDeclarationNode destination, IEventSymbol @event, CodeGenerationOptions? options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
-            => WithAnnotations(AddEvent(destination, @event, options ?? CodeGenerationOptions.Default, GetAvailableInsertionIndices(destination, cancellationToken)), options);
+        public abstract CodeGenerationPreferences GetPreferences(ParseOptions parseOptions, OptionSet documentOptions);
 
-        public TDeclarationNode AddField<TDeclarationNode>(TDeclarationNode destination, IFieldSymbol field, CodeGenerationOptions? options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
-            => WithAnnotations(AddField(destination, field, options ?? CodeGenerationOptions.Default, GetAvailableInsertionIndices(destination, cancellationToken)), options);
+        #region ICodeGenerationService
 
-        public TDeclarationNode AddMethod<TDeclarationNode>(TDeclarationNode destination, IMethodSymbol method, CodeGenerationOptions? options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
-            => WithAnnotations(AddMethod(destination, method, options ?? CodeGenerationOptions.Default, GetAvailableInsertionIndices(destination, cancellationToken)), options);
+        public TDeclarationNode AddEvent<TDeclarationNode>(TDeclarationNode destination, IEventSymbol @event, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
+            => WithAnnotations(AddEvent(destination, @event, (TCodeGenerationOptions)options, GetAvailableInsertionIndices(destination, cancellationToken), cancellationToken), options);
 
-        public TDeclarationNode AddProperty<TDeclarationNode>(TDeclarationNode destination, IPropertySymbol property, CodeGenerationOptions? options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
-            => WithAnnotations(AddProperty(destination, property, options ?? CodeGenerationOptions.Default, GetAvailableInsertionIndices(destination, cancellationToken)), options);
+        public TDeclarationNode AddField<TDeclarationNode>(TDeclarationNode destination, IFieldSymbol field, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
+            => WithAnnotations(AddField(destination, field, (TCodeGenerationOptions)options, GetAvailableInsertionIndices(destination, cancellationToken), cancellationToken), options);
 
-        public TDeclarationNode AddNamedType<TDeclarationNode>(TDeclarationNode destination, INamedTypeSymbol namedType, CodeGenerationOptions? options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
-            => WithAnnotations(AddNamedType(destination, namedType, options ?? CodeGenerationOptions.Default, GetAvailableInsertionIndices(destination, cancellationToken), cancellationToken), options);
+        public TDeclarationNode AddMethod<TDeclarationNode>(TDeclarationNode destination, IMethodSymbol method, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
+            => WithAnnotations(AddMethod(destination, method, (TCodeGenerationOptions)options, GetAvailableInsertionIndices(destination, cancellationToken), cancellationToken), options);
 
-        public TDeclarationNode AddNamespace<TDeclarationNode>(TDeclarationNode destination, INamespaceSymbol @namespace, CodeGenerationOptions? options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
-            => WithAnnotations(AddNamespace(destination, @namespace, options ?? CodeGenerationOptions.Default, GetAvailableInsertionIndices(destination, cancellationToken), cancellationToken), options);
+        public TDeclarationNode AddProperty<TDeclarationNode>(TDeclarationNode destination, IPropertySymbol property, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
+            => WithAnnotations(AddProperty(destination, property, (TCodeGenerationOptions)options, GetAvailableInsertionIndices(destination, cancellationToken), cancellationToken), options);
 
-        public TDeclarationNode AddMembers<TDeclarationNode>(TDeclarationNode destination, IEnumerable<ISymbol> members, CodeGenerationOptions? options, CancellationToken cancellationToken)
+        public TDeclarationNode AddNamedType<TDeclarationNode>(TDeclarationNode destination, INamedTypeSymbol namedType, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
+            => WithAnnotations(AddNamedType(destination, namedType, (TCodeGenerationOptions)options, GetAvailableInsertionIndices(destination, cancellationToken), cancellationToken), options);
+
+        public TDeclarationNode AddNamespace<TDeclarationNode>(TDeclarationNode destination, INamespaceSymbol @namespace, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
+            => WithAnnotations(AddNamespace(destination, @namespace, (TCodeGenerationOptions)options, GetAvailableInsertionIndices(destination, cancellationToken), cancellationToken), options);
+
+        public TDeclarationNode AddMembers<TDeclarationNode>(TDeclarationNode destination, IEnumerable<ISymbol> members, CodeGenerationOptions options, CancellationToken cancellationToken)
             where TDeclarationNode : SyntaxNode
-        {
-            return WithAnnotations(AddMembers(destination, members, GetAvailableInsertionIndices(destination, cancellationToken), options ?? CodeGenerationOptions.Default, cancellationToken), options);
-        }
+            => WithAnnotations(AddMembers(destination, members, GetAvailableInsertionIndices(destination, cancellationToken), (TCodeGenerationOptions)options, cancellationToken), options);
 
-        private static TNode WithAnnotations<TNode>(TNode node, CodeGenerationOptions? options) where TNode : SyntaxNode
+        private static TNode WithAnnotations<TNode>(TNode node, CodeGenerationOptions options) where TNode : SyntaxNode
         {
-            return options?.AddImports ?? true
+            return options.Context.AddImports
                 ? node.WithAdditionalAnnotations(Simplifier.AddImportsAnnotation)
                 : node;
         }
 
-        protected abstract TDeclarationNode AddEvent<TDeclarationNode>(TDeclarationNode destination, IEventSymbol @event, CodeGenerationOptions? options, IList<bool>? availableIndices) where TDeclarationNode : SyntaxNode;
-        protected abstract TDeclarationNode AddField<TDeclarationNode>(TDeclarationNode destination, IFieldSymbol field, CodeGenerationOptions? options, IList<bool>? availableIndices) where TDeclarationNode : SyntaxNode;
-        protected abstract TDeclarationNode AddMethod<TDeclarationNode>(TDeclarationNode destination, IMethodSymbol method, CodeGenerationOptions? options, IList<bool>? availableIndices) where TDeclarationNode : SyntaxNode;
-        protected abstract TDeclarationNode AddProperty<TDeclarationNode>(TDeclarationNode destination, IPropertySymbol property, CodeGenerationOptions? options, IList<bool>? availableIndices) where TDeclarationNode : SyntaxNode;
-        protected abstract TDeclarationNode AddNamedType<TDeclarationNode>(TDeclarationNode destination, INamedTypeSymbol namedType, CodeGenerationOptions? options, IList<bool>? availableIndices, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
-        protected abstract TDeclarationNode AddNamespace<TDeclarationNode>(TDeclarationNode destination, INamespaceSymbol @namespace, CodeGenerationOptions? options, IList<bool>? availableIndices, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
+        public SyntaxNode CreateEventDeclaration(IEventSymbol @event, CodeGenerationDestination destination, CodeGenerationOptions options, CancellationToken cancellationToken)
+            => CreateEventDeclaration(@event, destination, (TCodeGenerationOptions)options, cancellationToken);
+
+        public SyntaxNode CreateFieldDeclaration(IFieldSymbol field, CodeGenerationDestination destination, CodeGenerationOptions options, CancellationToken cancellationToken)
+            => CreateFieldDeclaration(field, destination, (TCodeGenerationOptions)options, cancellationToken);
+
+        public SyntaxNode? CreateMethodDeclaration(IMethodSymbol method, CodeGenerationDestination destination, CodeGenerationOptions options, CancellationToken cancellationToken)
+            => CreateMethodDeclaration(method, destination, (TCodeGenerationOptions)options, cancellationToken);
+
+        public SyntaxNode CreatePropertyDeclaration(IPropertySymbol property, CodeGenerationDestination destination, CodeGenerationOptions options, CancellationToken cancellationToken)
+            => CreatePropertyDeclaration(property, destination, (TCodeGenerationOptions)options, cancellationToken);
+
+        public SyntaxNode CreateNamedTypeDeclaration(INamedTypeSymbol namedType, CodeGenerationDestination destination, CodeGenerationOptions options, CancellationToken cancellationToken)
+            => CreateNamedTypeDeclaration(namedType, destination, (TCodeGenerationOptions)options, cancellationToken);
+
+        public SyntaxNode CreateNamespaceDeclaration(INamespaceSymbol @namespace, CodeGenerationDestination destination, CodeGenerationOptions options, CancellationToken cancellationToken)
+            => CreateNamespaceDeclaration(@namespace, destination, (TCodeGenerationOptions)options, cancellationToken);
+
+        public TDeclarationNode AddParameters<TDeclarationNode>(TDeclarationNode destination, IEnumerable<IParameterSymbol> parameters, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
+            => AddParameters(destination, parameters, (TCodeGenerationOptions)options, cancellationToken);
+
+        public TDeclarationNode AddAttributes<TDeclarationNode>(TDeclarationNode destination, IEnumerable<AttributeData> attributes, SyntaxToken? target, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
+            => AddAttributes(destination, attributes, target, (TCodeGenerationOptions)options, cancellationToken);
+
+        public TDeclarationNode RemoveAttribute<TDeclarationNode>(TDeclarationNode destination, SyntaxNode attributeToRemove, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
+            => RemoveAttribute(destination, attributeToRemove, (TCodeGenerationOptions)options, cancellationToken);
+
+        public TDeclarationNode RemoveAttribute<TDeclarationNode>(TDeclarationNode destination, AttributeData attributeToRemove, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
+            => RemoveAttribute(destination, attributeToRemove, (TCodeGenerationOptions)options, cancellationToken);
+
+        public TDeclarationNode UpdateDeclarationModifiers<TDeclarationNode>(TDeclarationNode declaration, IEnumerable<SyntaxToken> newModifiers, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
+            => UpdateDeclarationModifiers(declaration, newModifiers, (TCodeGenerationOptions)options, cancellationToken);
+
+        public TDeclarationNode UpdateDeclarationAccessibility<TDeclarationNode>(TDeclarationNode declaration, Accessibility newAccessibility, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
+            => UpdateDeclarationAccessibility(declaration, newAccessibility, (TCodeGenerationOptions)options, cancellationToken);
+
+        public TDeclarationNode UpdateDeclarationType<TDeclarationNode>(TDeclarationNode declaration, ITypeSymbol newType, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
+            => UpdateDeclarationType(declaration, newType, (TCodeGenerationOptions)options, cancellationToken);
+
+        public TDeclarationNode UpdateDeclarationMembers<TDeclarationNode>(TDeclarationNode declaration, IList<ISymbol> newMembers, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
+            => UpdateDeclarationMembers(declaration, newMembers, (TCodeGenerationOptions)options, cancellationToken);
+
+        public TDeclarationNode AddStatements<TDeclarationNode>(TDeclarationNode destination, IEnumerable<SyntaxNode> statements, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
+            => AddStatements(destination, statements, (TCodeGenerationOptions)options, cancellationToken);
+
+        #endregion
+
+        protected abstract TDeclarationNode AddEvent<TDeclarationNode>(TDeclarationNode destination, IEventSymbol @event, TCodeGenerationOptions options, IList<bool>? availableIndices, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
+        protected abstract TDeclarationNode AddField<TDeclarationNode>(TDeclarationNode destination, IFieldSymbol field, TCodeGenerationOptions options, IList<bool>? availableIndices, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
+        protected abstract TDeclarationNode AddMethod<TDeclarationNode>(TDeclarationNode destination, IMethodSymbol method, TCodeGenerationOptions options, IList<bool>? availableIndices, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
+        protected abstract TDeclarationNode AddProperty<TDeclarationNode>(TDeclarationNode destination, IPropertySymbol property, TCodeGenerationOptions options, IList<bool>? availableIndices, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
+        protected abstract TDeclarationNode AddNamedType<TDeclarationNode>(TDeclarationNode destination, INamedTypeSymbol namedType, TCodeGenerationOptions options, IList<bool>? availableIndices, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
+        protected abstract TDeclarationNode AddNamespace<TDeclarationNode>(TDeclarationNode destination, INamespaceSymbol @namespace, TCodeGenerationOptions options, IList<bool>? availableIndices, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
         protected abstract TDeclarationNode AddMembers<TDeclarationNode>(TDeclarationNode destination, IEnumerable<SyntaxNode> members) where TDeclarationNode : SyntaxNode;
 
-        public abstract TDeclarationNode AddParameters<TDeclarationNode>(TDeclarationNode destinationMember, IEnumerable<IParameterSymbol> parameters, CodeGenerationOptions? options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
-        public abstract TDeclarationNode AddAttributes<TDeclarationNode>(TDeclarationNode destination, IEnumerable<AttributeData> attributes, SyntaxToken? target, CodeGenerationOptions? options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
-        public abstract TDeclarationNode RemoveAttribute<TDeclarationNode>(TDeclarationNode destination, SyntaxNode attributeToRemove, CodeGenerationOptions? options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
-        public abstract TDeclarationNode RemoveAttribute<TDeclarationNode>(TDeclarationNode destination, AttributeData attributeToRemove, CodeGenerationOptions? options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
-        public abstract TDeclarationNode AddStatements<TDeclarationNode>(TDeclarationNode destinationMember, IEnumerable<SyntaxNode> statements, CodeGenerationOptions? options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
+        public abstract TDeclarationNode AddParameters<TDeclarationNode>(TDeclarationNode destinationMember, IEnumerable<IParameterSymbol> parameters, TCodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
+        public abstract TDeclarationNode AddAttributes<TDeclarationNode>(TDeclarationNode destination, IEnumerable<AttributeData> attributes, SyntaxToken? target, TCodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
+        public abstract TDeclarationNode RemoveAttribute<TDeclarationNode>(TDeclarationNode destination, SyntaxNode attributeToRemove, TCodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
+        public abstract TDeclarationNode RemoveAttribute<TDeclarationNode>(TDeclarationNode destination, AttributeData attributeToRemove, TCodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
+        public abstract TDeclarationNode AddStatements<TDeclarationNode>(TDeclarationNode destinationMember, IEnumerable<SyntaxNode> statements, TCodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
 
-        public abstract TDeclarationNode UpdateDeclarationModifiers<TDeclarationNode>(TDeclarationNode declaration, IEnumerable<SyntaxToken> newModifiers, CodeGenerationOptions? options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
-        public abstract TDeclarationNode UpdateDeclarationAccessibility<TDeclarationNode>(TDeclarationNode declaration, Accessibility newAccessibility, CodeGenerationOptions? options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
-        public abstract TDeclarationNode UpdateDeclarationType<TDeclarationNode>(TDeclarationNode declaration, ITypeSymbol newType, CodeGenerationOptions? options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
-        public abstract TDeclarationNode UpdateDeclarationMembers<TDeclarationNode>(TDeclarationNode declaration, IList<ISymbol> newMembers, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode;
+        public abstract TDeclarationNode UpdateDeclarationModifiers<TDeclarationNode>(TDeclarationNode declaration, IEnumerable<SyntaxToken> newModifiers, TCodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
+        public abstract TDeclarationNode UpdateDeclarationAccessibility<TDeclarationNode>(TDeclarationNode declaration, Accessibility newAccessibility, TCodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
+        public abstract TDeclarationNode UpdateDeclarationType<TDeclarationNode>(TDeclarationNode declaration, ITypeSymbol newType, TCodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
+        public abstract TDeclarationNode UpdateDeclarationMembers<TDeclarationNode>(TDeclarationNode declaration, IList<ISymbol> newMembers, TCodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
 
         public abstract CodeGenerationDestination GetDestination(SyntaxNode node);
-        public abstract SyntaxNode CreateEventDeclaration(IEventSymbol @event, CodeGenerationDestination destination, CodeGenerationOptions? options);
-        public abstract SyntaxNode CreateFieldDeclaration(IFieldSymbol field, CodeGenerationDestination destination, CodeGenerationOptions? options);
-        public abstract SyntaxNode CreateMethodDeclaration(IMethodSymbol method, CodeGenerationDestination destination, CodeGenerationOptions? options);
-        public abstract SyntaxNode CreatePropertyDeclaration(IPropertySymbol property, CodeGenerationDestination destination, CodeGenerationOptions? options);
-        public abstract SyntaxNode CreateNamedTypeDeclaration(INamedTypeSymbol namedType, CodeGenerationDestination destination, CodeGenerationOptions? options, CancellationToken cancellationToken);
-        public abstract SyntaxNode CreateNamespaceDeclaration(INamespaceSymbol @namespace, CodeGenerationDestination destination, CodeGenerationOptions? options, CancellationToken cancellationToken);
+        public abstract SyntaxNode CreateEventDeclaration(IEventSymbol @event, CodeGenerationDestination destination, TCodeGenerationOptions options, CancellationToken cancellationToken);
+        public abstract SyntaxNode CreateFieldDeclaration(IFieldSymbol field, CodeGenerationDestination destination, TCodeGenerationOptions options, CancellationToken cancellationToken);
+
+        // TODO: Change to not return null (https://github.com/dotnet/roslyn/issues/58243)
+        public abstract SyntaxNode? CreateMethodDeclaration(IMethodSymbol method, CodeGenerationDestination destination, TCodeGenerationOptions options, CancellationToken cancellationToken);
+
+        public abstract SyntaxNode CreatePropertyDeclaration(IPropertySymbol property, CodeGenerationDestination destination, TCodeGenerationOptions options, CancellationToken cancellationToken);
+        public abstract SyntaxNode CreateNamedTypeDeclaration(INamedTypeSymbol namedType, CodeGenerationDestination destination, TCodeGenerationOptions options, CancellationToken cancellationToken);
+        public abstract SyntaxNode CreateNamespaceDeclaration(INamespaceSymbol @namespace, CodeGenerationDestination destination, TCodeGenerationOptions options, CancellationToken cancellationToken);
 
         protected static T Cast<T>(object value)
             => (T)value;
@@ -167,14 +219,12 @@ not TDeclarationNode3 and
         private async Task<Document> GetEditAsync(
             Solution solution,
             INamespaceOrTypeSymbol destination,
-            Func<SyntaxNode, CodeGenerationOptions, IList<bool>?, CancellationToken, SyntaxNode> declarationTransform,
-            CodeGenerationOptions? options,
+            Func<SyntaxNode, TCodeGenerationOptions, IList<bool>?, CancellationToken, SyntaxNode> declarationTransform,
+            CodeGenerationContext context,
             CancellationToken cancellationToken)
         {
-            options ??= CodeGenerationOptions.Default;
-
             var (destinationDeclaration, availableIndices) =
-                await this.FindMostRelevantDeclarationAsync(solution, destination, options, cancellationToken).ConfigureAwait(false);
+                await this.FindMostRelevantDeclarationAsync(solution, destination, context, cancellationToken).ConfigureAwait(false);
 
             if (destinationDeclaration == null)
             {
@@ -183,13 +233,7 @@ private async Task<Document> GetEditAsync(
 
             var destinationTree = destinationDeclaration.SyntaxTree;
             var oldDocument = solution.GetRequiredDocument(destinationTree);
-
-            if (options.Options is null)
-            {
-                var documentOptions = await oldDocument.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
-                options = options.With(options: documentOptions);
-            }
-
+            var options = (TCodeGenerationOptions)await CodeGenerationOptions.FromDocumentAsync(context, oldDocument, cancellationToken).ConfigureAwait(false);
             var transformedDeclaration = declarationTransform(destinationDeclaration, options, availableIndices, cancellationToken);
 
             var root = await destinationTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
@@ -197,7 +241,7 @@ private async Task<Document> GetEditAsync(
 
             var newDocument = oldDocument.WithSyntaxRoot(currentRoot);
 
-            if (options.AddImports)
+            if (context.AddImports)
             {
                 newDocument = await ImportAdder.AddImportsFromSymbolAnnotationAsync(
                     newDocument,
@@ -212,7 +256,7 @@ protected TDeclarationNode AddMembers<TDeclarationNode>(
             TDeclarationNode destination,
             IEnumerable<ISymbol> members,
             IList<bool>? availableIndices,
-            CodeGenerationOptions options,
+            TCodeGenerationOptions options,
             CancellationToken cancellationToken)
             where TDeclarationNode : SyntaxNode
         {
@@ -226,7 +270,7 @@ protected TDeclarationNode AddMembers<TDeclarationNode>(
             // not want an explicit declaration. The only exception are fields generated from implicit tuple fields.
             var filteredMembers = membersList.Where(m => !m.IsImplicitlyDeclared || m.IsTupleField());
 
-            return options.AutoInsertionLocation
+            return options.Context.AutoInsertionLocation
                 ? AddMembersToAppropriateLocationInDestination(destination, filteredMembers, availableIndices, options, cancellationToken)
                 : AddMembersToEndOfDestination(destination, filteredMembers, options, cancellationToken);
         }
@@ -234,7 +278,7 @@ protected TDeclarationNode AddMembers<TDeclarationNode>(
         private TDeclarationSyntax AddMembersToEndOfDestination<TDeclarationSyntax>(
             TDeclarationSyntax destination,
             IEnumerable<ISymbol> members,
-            CodeGenerationOptions options,
+            TCodeGenerationOptions options,
             CancellationToken cancellationToken)
             where TDeclarationSyntax : SyntaxNode
         {
@@ -254,7 +298,7 @@ private TDeclarationSyntax AddMembersToEndOfDestination<TDeclarationSyntax>(
             // Metadata as source generates complete declarations and doesn't modify
             // existing ones. We can take the members to generate, sort them once,
             // and then add them in that order to the end of the destination.
-            if (!GeneratingEnum(members) && options.SortMembers)
+            if (!GeneratingEnum(members) && options.Context.SortMembers)
             {
                 newMembers.Sort(GetMemberComparer());
             }
@@ -266,7 +310,7 @@ private TDeclarationSyntax AddMembersToAppropriateLocationInDestination<TDeclara
             TDeclarationSyntax destination,
             IEnumerable<ISymbol> members,
             IList<bool>? availableIndices,
-            CodeGenerationOptions options,
+            TCodeGenerationOptions options,
             CancellationToken cancellationToken)
             where TDeclarationSyntax : SyntaxNode
         {
@@ -281,33 +325,33 @@ private TDeclarationSyntax AddMembersToAppropriateLocationInDestination<TDeclara
             return currentDestination;
         }
 
-        private SyntaxNode? GetNewMember(CodeGenerationOptions options, CodeGenerationDestination codeGenerationDestination, ISymbol member, CancellationToken cancellationToken)
+        private SyntaxNode? GetNewMember(TCodeGenerationOptions options, CodeGenerationDestination codeGenerationDestination, ISymbol member, CancellationToken cancellationToken)
             => member switch
             {
-                IEventSymbol @event => this.CreateEventDeclaration(@event, codeGenerationDestination, options),
-                IFieldSymbol field => this.CreateFieldDeclaration(field, codeGenerationDestination, options),
-                IPropertySymbol property => this.CreatePropertyDeclaration(property, codeGenerationDestination, options),
-                IMethodSymbol method => this.CreateMethodDeclaration(method, codeGenerationDestination, options),
-                INamedTypeSymbol namedType => this.CreateNamedTypeDeclaration(namedType, codeGenerationDestination, options, cancellationToken),
-                INamespaceSymbol @namespace => this.CreateNamespaceDeclaration(@namespace, codeGenerationDestination, options, cancellationToken),
+                IEventSymbol @event => CreateEventDeclaration(@event, codeGenerationDestination, options, cancellationToken),
+                IFieldSymbol field => CreateFieldDeclaration(field, codeGenerationDestination, options, cancellationToken),
+                IPropertySymbol property => CreatePropertyDeclaration(property, codeGenerationDestination, options, cancellationToken),
+                IMethodSymbol method => CreateMethodDeclaration(method, codeGenerationDestination, options, cancellationToken),
+                INamedTypeSymbol namedType => CreateNamedTypeDeclaration(namedType, codeGenerationDestination, options, cancellationToken),
+                INamespaceSymbol @namespace => CreateNamespaceDeclaration(@namespace, codeGenerationDestination, options, cancellationToken),
                 _ => null,
             };
 
         private TDeclarationNode UpdateDestination<TDeclarationNode>(
             IList<bool>? availableIndices,
-            CodeGenerationOptions options,
+            TCodeGenerationOptions options,
             TDeclarationNode currentDestination,
             ISymbol member,
             CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
         {
             return member switch
             {
-                IEventSymbol @event => this.AddEvent(currentDestination, @event, options, availableIndices),
-                IFieldSymbol field => this.AddField(currentDestination, field, options, availableIndices),
-                IPropertySymbol property => this.AddProperty(currentDestination, property, options, availableIndices),
-                IMethodSymbol method => this.AddMethod(currentDestination, method, options, availableIndices),
-                INamedTypeSymbol namedType => this.AddNamedType(currentDestination, namedType, options, availableIndices, cancellationToken),
-                INamespaceSymbol @namespace => this.AddNamespace(currentDestination, @namespace, options, availableIndices, cancellationToken),
+                IEventSymbol @event => AddEvent(currentDestination, @event, options, availableIndices, cancellationToken),
+                IFieldSymbol field => AddField(currentDestination, field, options, availableIndices, cancellationToken),
+                IPropertySymbol property => AddProperty(currentDestination, property, options, availableIndices, cancellationToken),
+                IMethodSymbol method => AddMethod(currentDestination, method, options, availableIndices, cancellationToken),
+                INamedTypeSymbol namedType => AddNamedType(currentDestination, namedType, options, availableIndices, cancellationToken),
+                INamespaceSymbol @namespace => AddNamespace(currentDestination, @namespace, options, availableIndices, cancellationToken),
                 _ => currentDestination,
             };
         }
@@ -320,58 +364,57 @@ private static bool GeneratingEnum(IEnumerable<ISymbol> members)
 
         protected abstract IComparer<SyntaxNode> GetMemberComparer();
 
-        protected static CodeGenerationOptions CreateOptionsForMultipleMembers(CodeGenerationOptions options)
+        protected static TCodeGenerationOptions CreateOptionsForMultipleMembers(TCodeGenerationOptions options)
         {
             // For now we ignore the afterThisLocation/beforeThisLocation if we're adding
             // multiple members.  In the future it would be nice to appropriately handle this.
             // The difficulty lies with ensuring that we properly understand the position we're
             // inserting into, even as we change the type by adding multiple members.  Not
             // impossible to figure out, but out of scope right now.
-            options = options.With(afterThisLocation: null, beforeThisLocation: null);
-            return options;
+            return (TCodeGenerationOptions)options.WithContext(options.Context.With(afterThisLocation: null, beforeThisLocation: null));
         }
 
         public virtual Task<Document> AddEventAsync(
             Solution solution, INamedTypeSymbol destination, IEventSymbol @event,
-            CodeGenerationOptions? options, CancellationToken cancellationToken)
+            CodeGenerationContext context, CancellationToken cancellationToken)
         {
             return GetEditAsync(
                 solution,
                 destination,
-                (t, opts, ai, ct) => AddEvent(t, @event, opts, ai),
-                options,
+                (t, opts, ai, ct) => AddEvent(t, @event, opts, ai, ct),
+                context,
                 cancellationToken);
         }
 
-        public Task<Document> AddFieldAsync(Solution solution, INamedTypeSymbol destination, IFieldSymbol field, CodeGenerationOptions? options, CancellationToken cancellationToken)
+        public Task<Document> AddFieldAsync(Solution solution, INamedTypeSymbol destination, IFieldSymbol field, CodeGenerationContext context, CancellationToken cancellationToken)
         {
             return GetEditAsync(
                 solution,
                 destination,
-                (t, opts, ai, ct) => AddField(t, field, opts, ai),
-                options,
+                (t, opts, ai, ct) => AddField(t, field, opts, ai, ct),
+                context,
                 cancellationToken);
         }
 
-        public Task<Document> AddPropertyAsync(Solution solution, INamedTypeSymbol destination, IPropertySymbol property, CodeGenerationOptions? options, CancellationToken cancellationToken)
+        public Task<Document> AddPropertyAsync(Solution solution, INamedTypeSymbol destination, IPropertySymbol property, CodeGenerationContext context, CancellationToken cancellationToken)
         {
             return GetEditAsync(
                 solution, destination,
-                (t, opts, ai, ct) => AddProperty(t, property, opts, ai),
-                options,
+                (t, opts, ai, ct) => AddProperty(t, property, opts, ai, ct),
+                context,
                 cancellationToken);
         }
 
-        public Task<Document> AddNamedTypeAsync(Solution solution, INamedTypeSymbol destination, INamedTypeSymbol namedType, CodeGenerationOptions? options, CancellationToken cancellationToken)
+        public Task<Document> AddNamedTypeAsync(Solution solution, INamedTypeSymbol destination, INamedTypeSymbol namedType, CodeGenerationContext context, CancellationToken cancellationToken)
         {
             return GetEditAsync(
                 solution, destination,
                 (t, opts, ai, ct) => AddNamedType(t, namedType, opts, ai, ct),
-                options,
+                context,
                 cancellationToken);
         }
 
-        public Task<Document> AddNamedTypeAsync(Solution solution, INamespaceSymbol destination, INamedTypeSymbol namedType, CodeGenerationOptions? options, CancellationToken cancellationToken)
+        public Task<Document> AddNamedTypeAsync(Solution solution, INamespaceSymbol destination, INamedTypeSymbol namedType, CodeGenerationContext options, CancellationToken cancellationToken)
         {
             return GetEditAsync(
                 solution, destination,
@@ -380,34 +423,34 @@ public Task<Document> AddNamedTypeAsync(Solution solution, INamespaceSymbol dest
                 cancellationToken);
         }
 
-        public Task<Document> AddNamespaceAsync(Solution solution, INamespaceSymbol destination, INamespaceSymbol @namespace, CodeGenerationOptions? options, CancellationToken cancellationToken)
+        public Task<Document> AddNamespaceAsync(Solution solution, INamespaceSymbol destination, INamespaceSymbol @namespace, CodeGenerationContext context, CancellationToken cancellationToken)
         {
             return GetEditAsync(
                 solution, destination,
                 (t, opts, ai, ct) => AddNamespace(t, @namespace, opts, ai, ct),
-                options,
+                context,
                 cancellationToken);
         }
 
-        public Task<Document> AddMethodAsync(Solution solution, INamedTypeSymbol destination, IMethodSymbol method, CodeGenerationOptions? options, CancellationToken cancellationToken)
+        public Task<Document> AddMethodAsync(Solution solution, INamedTypeSymbol destination, IMethodSymbol method, CodeGenerationContext context, CancellationToken cancellationToken)
         {
             return GetEditAsync(
                 solution, destination,
-                (t, opts, ai, ct) => AddMethod(t, method, opts, ai),
-                options,
+                (t, opts, ai, ct) => AddMethod(t, method, opts, ai, ct),
+                context,
                 cancellationToken);
         }
 
-        public Task<Document> AddMembersAsync(Solution solution, INamedTypeSymbol destination, IEnumerable<ISymbol> members, CodeGenerationOptions? options, CancellationToken cancellationToken)
+        public Task<Document> AddMembersAsync(Solution solution, INamedTypeSymbol destination, IEnumerable<ISymbol> members, CodeGenerationContext context, CancellationToken cancellationToken)
         {
             return GetEditAsync(
                 solution, destination,
                 (t, opts, ai, ct) => AddMembers(t, members, ai, opts, ct),
-                options,
+                context,
                 cancellationToken);
         }
 
-        public Task<Document> AddNamespaceOrTypeAsync(Solution solution, INamespaceSymbol destination, INamespaceOrTypeSymbol namespaceOrType, CodeGenerationOptions? options, CancellationToken cancellationToken)
+        public Task<Document> AddNamespaceOrTypeAsync(Solution solution, INamespaceSymbol destination, INamespaceOrTypeSymbol namespaceOrType, CodeGenerationContext context, CancellationToken cancellationToken)
         {
             if (namespaceOrType == null)
             {
@@ -416,16 +459,15 @@ public Task<Document> AddNamespaceOrTypeAsync(Solution solution, INamespaceSymbo
 
             if (namespaceOrType is INamespaceSymbol namespaceSymbol)
             {
-                return AddNamespaceAsync(solution, destination, namespaceSymbol, options, cancellationToken);
+                return AddNamespaceAsync(solution, destination, namespaceSymbol, context, cancellationToken);
             }
             else
             {
-                return AddNamedTypeAsync(solution, destination, (INamedTypeSymbol)namespaceOrType, options, cancellationToken);
+                return AddNamedTypeAsync(solution, destination, (INamedTypeSymbol)namespaceOrType, context, cancellationToken);
             }
         }
 
-        protected static void CheckLocation<TDeclarationNode>(
-            TDeclarationNode destinationMember, Location location) where TDeclarationNode : SyntaxNode
+        protected static void CheckLocation(SyntaxNode destinationMember, [NotNull] Location? location)
         {
             if (location == null)
             {
diff --git a/src/Workspaces/Core/Portable/CodeGeneration/AbstractCodeGenerationService_FindDeclaration.cs b/src/Workspaces/Core/Portable/CodeGeneration/AbstractCodeGenerationService_FindDeclaration.cs
index 7f1e9ed210207..b3c34ae5a3963 100644
--- a/src/Workspaces/Core/Portable/CodeGeneration/AbstractCodeGenerationService_FindDeclaration.cs
+++ b/src/Workspaces/Core/Portable/CodeGeneration/AbstractCodeGenerationService_FindDeclaration.cs
@@ -14,11 +14,11 @@
 
 namespace Microsoft.CodeAnalysis.CodeGeneration
 {
-    internal abstract partial class AbstractCodeGenerationService
+    internal abstract partial class AbstractCodeGenerationService<TCodeGenerationOptions>
     {
-        protected abstract IList<bool> GetAvailableInsertionIndices(SyntaxNode destination, CancellationToken cancellationToken);
+        protected abstract IList<bool>? GetAvailableInsertionIndices(SyntaxNode destination, CancellationToken cancellationToken);
 
-        private IList<bool> GetAvailableInsertionIndices<TDeclarationNode>(TDeclarationNode destination, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
+        private IList<bool>? GetAvailableInsertionIndices<TDeclarationNode>(TDeclarationNode destination, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
             => GetAvailableInsertionIndices((SyntaxNode)destination, cancellationToken);
 
         public bool CanAddTo(ISymbol destination, Solution solution, CancellationToken cancellationToken)
@@ -124,25 +124,24 @@ private bool CanAddTo(SyntaxNode? destination, Solution solution, CancellationTo
         public async Task<SyntaxNode?> FindMostRelevantNameSpaceOrTypeDeclarationAsync(
             Solution solution,
             INamespaceOrTypeSymbol namespaceOrType,
-            CodeGenerationOptions options,
+            CodeGenerationContext context,
             CancellationToken cancellationToken)
         {
-            var option = options ?? CodeGenerationOptions.Default;
-            var (declaration, _) = await FindMostRelevantDeclarationAsync(solution, namespaceOrType, option, cancellationToken).ConfigureAwait(false);
+            var (declaration, _) = await FindMostRelevantDeclarationAsync(solution, namespaceOrType, context, cancellationToken).ConfigureAwait(false);
             return declaration;
         }
 
         private async Task<(SyntaxNode? declaration, IList<bool>? availableIndices)> FindMostRelevantDeclarationAsync(
             Solution solution,
             INamespaceOrTypeSymbol namespaceOrType,
-            CodeGenerationOptions options,
+            CodeGenerationContext context,
             CancellationToken cancellationToken)
         {
             var declaration = (SyntaxNode?)null;
             IList<bool>? availableIndices = null;
 
             var symbol = namespaceOrType;
-            var locationOpt = options.BestLocation;
+            var locationOpt = context.BestLocation;
 
             var declarations = _symbolDeclarationService.GetDeclarations(symbol);
 
diff --git a/src/Workspaces/Core/Portable/CodeGeneration/AbstractFlagsEnumGenerator.cs b/src/Workspaces/Core/Portable/CodeGeneration/AbstractFlagsEnumGenerator.cs
index 70aa94f5e3471..4aae3c73ed5ce 100644
--- a/src/Workspaces/Core/Portable/CodeGeneration/AbstractFlagsEnumGenerator.cs
+++ b/src/Workspaces/Core/Portable/CodeGeneration/AbstractFlagsEnumGenerator.cs
@@ -13,10 +13,10 @@ namespace Microsoft.CodeAnalysis.CodeGeneration
     internal abstract class AbstractFlagsEnumGenerator : IComparer<(IFieldSymbol field, ulong value)>
     {
         protected abstract SyntaxGenerator GetSyntaxGenerator();
-        protected abstract SyntaxNode CreateExplicitlyCastedLiteralValue(INamedTypeSymbol enumType, SpecialType underlyingSpecialType, object? constantValue);
+        protected abstract SyntaxNode CreateExplicitlyCastedLiteralValue(INamedTypeSymbol enumType, SpecialType underlyingSpecialType, object constantValue);
         protected abstract bool IsValidName(INamedTypeSymbol enumType, string name);
 
-        public SyntaxNode? TryCreateEnumConstantValue(INamedTypeSymbol enumType, object constantValue)
+        public SyntaxNode CreateEnumConstantValue(INamedTypeSymbol enumType, object constantValue)
         {
             // Code copied from System.Enum.
             var isFlagsEnum = IsFlagsEnum(enumType);
@@ -61,7 +61,7 @@ private static bool IsFlagsEnum(INamedTypeSymbol typeSymbol)
             return false;
         }
 
-        private SyntaxNode? CreateFlagsEnumConstantValue(INamedTypeSymbol enumType, object constantValue)
+        private SyntaxNode CreateFlagsEnumConstantValue(INamedTypeSymbol enumType, object constantValue)
         {
             // These values are sorted by value. Don't change this.
             var allFieldsAndValues = new List<(IFieldSymbol field, ulong value)>();
@@ -71,7 +71,7 @@ private static bool IsFlagsEnum(INamedTypeSymbol typeSymbol)
             return CreateFlagsEnumConstantValue(enumType, constantValue, allFieldsAndValues, usedFieldsAndValues);
         }
 
-        private SyntaxNode? CreateFlagsEnumConstantValue(
+        private SyntaxNode CreateFlagsEnumConstantValue(
             INamedTypeSymbol enumType,
             object constantValue,
             List<(IFieldSymbol field, ulong value)> allFieldsAndValues,
@@ -120,23 +120,22 @@ private static bool IsFlagsEnum(INamedTypeSymbol typeSymbol)
                     }
                 }
 
+                Contract.ThrowIfNull(finalNode);
                 return finalNode;
             }
+
+            // We couldn't find fields to OR together to make the value.
+
+            // If we had 0 as the value, and there's an enum value equal to 0, then use that.
+            var zeroField = GetZeroField(allFieldsAndValues);
+            if (constantValueULong == 0 && zeroField != null)
+            {
+                return CreateMemberAccessExpression(zeroField, enumType, underlyingSpecialType);
+            }
             else
             {
-                // We couldn't find fields to OR together to make the value.
-
-                // If we had 0 as the value, and there's an enum value equal to 0, then use that.
-                var zeroField = GetZeroField(allFieldsAndValues);
-                if (constantValueULong == 0 && zeroField != null)
-                {
-                    return CreateMemberAccessExpression(zeroField, enumType, underlyingSpecialType);
-                }
-                else
-                {
-                    // Add anything else in as a literal value.
-                    return CreateExplicitlyCastedLiteralValue(enumType, underlyingSpecialType, constantValue);
-                }
+                // Add anything else in as a literal value.
+                return CreateExplicitlyCastedLiteralValue(enumType, underlyingSpecialType, constantValue);
             }
         }
 
@@ -152,6 +151,7 @@ private SyntaxNode CreateMemberAccessExpression(
             }
             else
             {
+                Contract.ThrowIfNull(field.ConstantValue);
                 return CreateExplicitlyCastedLiteralValue(enumType, underlyingSpecialType, field.ConstantValue);
             }
         }
diff --git a/src/Workspaces/Core/Portable/CodeGeneration/CodeGenerationContext.cs b/src/Workspaces/Core/Portable/CodeGeneration/CodeGenerationContext.cs
new file mode 100644
index 0000000000000..f1be39d46f4c0
--- /dev/null
+++ b/src/Workspaces/Core/Portable/CodeGeneration/CodeGenerationContext.cs
@@ -0,0 +1,225 @@
+// 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 Microsoft.CodeAnalysis.Simplification;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.CodeGeneration
+{
+    /// <summary>
+    /// General options for controlling the code produced by the <see cref="CodeGenerator"/> that apply to all documents.
+    /// </summary>
+    internal sealed class CodeGenerationContext
+    {
+        public static readonly CodeGenerationContext Default = new();
+
+        /// <summary>
+        /// A location used to determine the best place to generate a member.  This is only used for
+        /// determining which part of a partial type to generate in.  If a type only has one part, or
+        /// an API is used that specifies the type, then this is not used.  A part is preferred if
+        /// it surrounds this context location. If no part surrounds this location then a part is
+        /// preferred if it comes from the same SyntaxTree as this location.  If there is no
+        /// such part, then any part may be used for generation.
+        /// 
+        /// This option is not necessary if <see cref="AfterThisLocation"/> or <see cref="BeforeThisLocation"/> are
+        /// provided.
+        /// </summary>
+        public Location? ContextLocation { get; }
+
+        /// <summary>
+        /// A hint to the code generation service to specify where the generated code should be
+        /// placed.  Code will be generated after this location if the location is valid in the type
+        /// or symbol being generated into, and it is possible to generate the code after it.
+        /// 
+        /// If this option is provided, neither <see cref="ContextLocation"/> nor <see cref="BeforeThisLocation"/> are
+        /// needed.
+        /// </summary>
+        public Location? AfterThisLocation { get; }
+
+        /// <summary>
+        /// A hint to the code generation service to specify where the generated code should be
+        /// placed.  Code will be generated before this location if the location is valid in the type
+        /// or symbol being generated into, and it is possible to generate the code after it. 
+        /// 
+        /// If this option is provided, neither <see cref="ContextLocation"/> nor <see cref="AfterThisLocation"/> are
+        /// needed.
+        /// </summary>
+        public Location? BeforeThisLocation { get; }
+
+        /// <summary>
+        /// True if the code generation service should add <see cref="Simplifier.AddImportsAnnotation"/>,
+        /// and when not generating directly into a declaration, should try to automatically add imports to the file
+        /// for any generated code.
+        /// Defaults to true.
+        /// </summary>
+        public bool AddImports { get; }
+
+        /// <summary>
+        /// Contains additional imports to be automatically added.  This is useful for adding
+        /// imports that are part of a list of statements.
+        /// </summary>
+        public IEnumerable<INamespaceSymbol> AdditionalImports { get; }
+
+        /// <summary>
+        /// True if members of a symbol should also be generated along with the declaration.  If
+        /// false, only the symbol's declaration will be generated.
+        /// </summary>
+        public bool GenerateMembers { get; }
+
+        /// <summary>
+        /// True if the code generator should merge namespaces which only contain other namespaces
+        /// into a single declaration with a dotted name.  False if the nesting should be preserved
+        /// and each namespace declaration should be nested and should only have a single non-dotted
+        /// name.
+        /// 
+        /// Merging can only occur if the namespace only contains a single member that is also a
+        /// namespace.
+        /// </summary>
+        public bool MergeNestedNamespaces { get; }
+
+        /// <summary>
+        /// True if the code generation should put multiple attributes in a single attribute
+        /// declaration, or if should have a separate attribute declaration for each attribute.  For
+        /// example, in C# setting this to True this would produce "[Goo, Bar]" while setting it to
+        /// False would produce "[Goo][Bar]"
+        /// </summary>
+        public bool MergeAttributes { get; }
+
+        /// <summary>
+        /// True if the code generator should always generate accessibility modifiers, even if they
+        /// are the same as the defaults for that symbol.  For example, a private field in C# does
+        /// not need its accessibility specified as it will be private by default.  However, if this
+        /// option is set to true 'private' will still be generated.
+        /// </summary>
+        public bool GenerateDefaultAccessibility { get; }
+
+        /// <summary>
+        /// True if the code generator should generate empty bodies for methods along with the
+        /// method declaration.  If false, only method declarations will be generated.
+        /// </summary>
+        public bool GenerateMethodBodies { get; }
+
+        /// <summary>
+        /// True if the code generator should generate documentation comments where available
+        /// </summary>
+        public bool GenerateDocumentationComments { get; }
+
+        /// <summary>
+        /// True if the code generator should automatically attempt to choose the appropriate location
+        /// to insert members.  If false and a generation location is not specified by AfterThisLocation,
+        /// or BeforeThisLocation, members will be inserted at the end of the destination definition.
+        /// </summary>
+        public bool AutoInsertionLocation { get; }
+
+        /// <summary>
+        /// If <see cref="AutoInsertionLocation"/> is <see langword="false"/>, determines if members will be
+        /// sorted before being added to the end of the list of members.
+        /// </summary>
+        public bool SortMembers { get; }
+
+        /// <summary>
+        /// True if the code generator should attempt to reuse the syntax of the constituent entities, such as members, access modifier tokens, etc. while attempting to generate code.
+        /// If any of the member symbols have zero declaring syntax references (non-source symbols) OR two or more declaring syntax references (partial definitions), then syntax is not reused.
+        /// If false, then the code generator will always synthesize a new syntax node and ignore the declaring syntax references.
+        /// </summary>
+        public bool ReuseSyntax { get; }
+
+        public CodeGenerationContext(
+            Location? contextLocation = null,
+            Location? afterThisLocation = null,
+            Location? beforeThisLocation = null,
+            bool addImports = true,
+            IEnumerable<INamespaceSymbol>? additionalImports = null,
+            bool generateMembers = true,
+            bool mergeNestedNamespaces = true,
+            bool mergeAttributes = true,
+            bool generateDefaultAccessibility = true,
+            bool generateMethodBodies = true,
+            bool generateDocumentationComments = false,
+            bool autoInsertionLocation = true,
+            bool sortMembers = true,
+            bool reuseSyntax = false)
+        {
+            CheckLocation(contextLocation, nameof(contextLocation));
+            CheckLocation(afterThisLocation, nameof(afterThisLocation));
+            CheckLocation(beforeThisLocation, nameof(beforeThisLocation));
+
+            ContextLocation = contextLocation;
+            AfterThisLocation = afterThisLocation;
+            BeforeThisLocation = beforeThisLocation;
+            AddImports = addImports;
+            AdditionalImports = additionalImports ?? SpecializedCollections.EmptyEnumerable<INamespaceSymbol>();
+            GenerateMembers = generateMembers;
+            MergeNestedNamespaces = mergeNestedNamespaces;
+            MergeAttributes = mergeAttributes;
+            GenerateDefaultAccessibility = generateDefaultAccessibility;
+            GenerateMethodBodies = generateMethodBodies;
+            GenerateDocumentationComments = generateDocumentationComments;
+            AutoInsertionLocation = autoInsertionLocation;
+            SortMembers = sortMembers;
+            ReuseSyntax = reuseSyntax;
+        }
+
+        private static void CheckLocation(Location? location, string name)
+        {
+            if (location != null && !location.IsInSource)
+            {
+                throw new ArgumentException(WorkspacesResources.Location_must_be_null_or_from_source, name);
+            }
+        }
+
+        internal Location? BestLocation
+            => this.AfterThisLocation ?? this.BeforeThisLocation ?? this.ContextLocation;
+
+        public CodeGenerationContext With(
+            Optional<Location> contextLocation = default,
+            Optional<Location?> afterThisLocation = default,
+            Optional<Location?> beforeThisLocation = default,
+            Optional<bool> addImports = default,
+            Optional<IEnumerable<INamespaceSymbol>> additionalImports = default,
+            Optional<bool> generateMembers = default,
+            Optional<bool> mergeNestedNamespaces = default,
+            Optional<bool> mergeAttributes = default,
+            Optional<bool> generateDefaultAccessibility = default,
+            Optional<bool> generateMethodBodies = default,
+            Optional<bool> generateDocumentationComments = default,
+            Optional<bool> autoInsertionLocation = default,
+            Optional<bool> sortMembers = default,
+            Optional<bool> reuseSyntax = default)
+        {
+            var newContextLocation = contextLocation.HasValue ? contextLocation.Value : this.ContextLocation;
+            var newAfterThisLocation = afterThisLocation.HasValue ? afterThisLocation.Value : this.AfterThisLocation;
+            var newBeforeThisLocation = beforeThisLocation.HasValue ? beforeThisLocation.Value : this.BeforeThisLocation;
+            var newAddImports = addImports.HasValue ? addImports.Value : this.AddImports;
+            var newAdditionalImports = additionalImports.HasValue ? additionalImports.Value : this.AdditionalImports;
+            var newGenerateMembers = generateMembers.HasValue ? generateMembers.Value : this.GenerateMembers;
+            var newMergeNestedNamespaces = mergeNestedNamespaces.HasValue ? mergeNestedNamespaces.Value : this.MergeNestedNamespaces;
+            var newMergeAttributes = mergeAttributes.HasValue ? mergeAttributes.Value : this.MergeAttributes;
+            var newGenerateDefaultAccessibility = generateDefaultAccessibility.HasValue ? generateDefaultAccessibility.Value : this.GenerateDefaultAccessibility;
+            var newGenerateMethodBodies = generateMethodBodies.HasValue ? generateMethodBodies.Value : this.GenerateMethodBodies;
+            var newGenerateDocumentationComments = generateDocumentationComments.HasValue ? generateDocumentationComments.Value : this.GenerateDocumentationComments;
+            var newAutoInsertionLocation = autoInsertionLocation.HasValue ? autoInsertionLocation.Value : this.AutoInsertionLocation;
+            var newSortMembers = sortMembers.HasValue ? sortMembers.Value : this.SortMembers;
+            var newReuseSyntax = reuseSyntax.HasValue ? reuseSyntax.Value : this.ReuseSyntax;
+
+            return new CodeGenerationContext(
+                newContextLocation,
+                newAfterThisLocation,
+                newBeforeThisLocation,
+                newAddImports,
+                newAdditionalImports,
+                newGenerateMembers,
+                newMergeNestedNamespaces,
+                newMergeAttributes,
+                newGenerateDefaultAccessibility,
+                newGenerateMethodBodies,
+                newGenerateDocumentationComments,
+                newAutoInsertionLocation,
+                newSortMembers,
+                newReuseSyntax);
+        }
+    }
+}
diff --git a/src/Workspaces/Core/Portable/CodeGeneration/CodeGenerationHelpers.cs b/src/Workspaces/Core/Portable/CodeGeneration/CodeGenerationHelpers.cs
index 3dfc278ba4ecd..5194dbd5f5e1e 100644
--- a/src/Workspaces/Core/Portable/CodeGeneration/CodeGenerationHelpers.cs
+++ b/src/Workspaces/Core/Portable/CodeGeneration/CodeGenerationHelpers.cs
@@ -52,7 +52,7 @@ public static void GetNameAndInnermostNamespace(
             out string name,
             out INamespaceSymbol innermostNamespace)
         {
-            if (options.GenerateMembers && options.MergeNestedNamespaces && @namespace.Name != string.Empty)
+            if (options.Context.GenerateMembers && options.Context.MergeNestedNamespaces && @namespace.Name != string.Empty)
             {
                 var names = new List<string>();
                 names.Add(@namespace.Name);
@@ -83,7 +83,7 @@ members[0] is INamespaceSymbol &&
             }
         }
 
-        public static bool IsSpecialType(ITypeSymbol type, SpecialType specialType)
+        public static bool IsSpecialType([NotNullWhen(true)] ITypeSymbol? type, SpecialType specialType)
             => type != null && type.SpecialType == specialType;
 
         public static int GetPreferredIndex(int index, IList<bool>? availableIndices, bool forward)
@@ -183,7 +183,7 @@ public static T RemoveLeadingDirectiveTrivia<T>(T node) where T : SyntaxNode
         {
             Contract.ThrowIfNull(attribute);
 
-            return options != null && options.ReuseSyntax && attribute.ApplicationSyntaxReference != null ?
+            return options.Context.ReuseSyntax && attribute.ApplicationSyntaxReference != null ?
                 attribute.ApplicationSyntaxReference.GetSyntax() as T :
                 null;
         }
@@ -192,93 +192,90 @@ public static int GetInsertionIndex<TDeclaration>(
             SyntaxList<TDeclaration> declarationList,
             TDeclaration declaration,
             CodeGenerationOptions options,
-            IList<bool> availableIndices,
+            IList<bool>? availableIndices,
             IComparer<TDeclaration> comparerWithoutNameCheck,
             IComparer<TDeclaration> comparerWithNameCheck,
-            Func<SyntaxList<TDeclaration>, TDeclaration>? after = null,
-            Func<SyntaxList<TDeclaration>, TDeclaration>? before = null)
+            Func<SyntaxList<TDeclaration>, TDeclaration?>? after = null,
+            Func<SyntaxList<TDeclaration>, TDeclaration?>? before = null)
             where TDeclaration : SyntaxNode
         {
             Contract.ThrowIfTrue(availableIndices != null && availableIndices.Count != declarationList.Count + 1);
 
-            if (options != null)
+            // Try to strictly obey the after option by inserting immediately after the member containing the location
+            if (options.Context.AfterThisLocation != null)
             {
-                // Try to strictly obey the after option by inserting immediately after the member containing the location
-                if (options.AfterThisLocation != null)
+                var afterMember = declarationList.LastOrDefault(m => m.SpanStart <= options.Context.AfterThisLocation.SourceSpan.Start);
+                if (afterMember != null)
                 {
-                    var afterMember = declarationList.LastOrDefault(m => m.SpanStart <= options.AfterThisLocation.SourceSpan.Start);
-                    if (afterMember != null)
+                    var index = declarationList.IndexOf(afterMember);
+                    index = GetPreferredIndex(index + 1, availableIndices, forward: true);
+                    if (index != -1)
                     {
-                        var index = declarationList.IndexOf(afterMember);
-                        index = GetPreferredIndex(index + 1, availableIndices, forward: true);
-                        if (index != -1)
-                        {
-                            return index;
-                        }
+                        return index;
                     }
                 }
+            }
 
-                // Try to strictly obey the before option by inserting immediately before the member containing the location
-                if (options.BeforeThisLocation != null)
+            // Try to strictly obey the before option by inserting immediately before the member containing the location
+            if (options.Context.BeforeThisLocation != null)
+            {
+                var beforeMember = declarationList.FirstOrDefault(m => m.Span.End >= options.Context.BeforeThisLocation.SourceSpan.End);
+                if (beforeMember != null)
                 {
-                    var beforeMember = declarationList.FirstOrDefault(m => m.Span.End >= options.BeforeThisLocation.SourceSpan.End);
-                    if (beforeMember != null)
+                    var index = declarationList.IndexOf(beforeMember);
+                    index = GetPreferredIndex(index, availableIndices, forward: false);
+                    if (index != -1)
                     {
-                        var index = declarationList.IndexOf(beforeMember);
-                        index = GetPreferredIndex(index, availableIndices, forward: false);
-                        if (index != -1)
-                        {
-                            return index;
-                        }
+                        return index;
                     }
                 }
+            }
 
-                if (options.AutoInsertionLocation)
+            if (options.Context.AutoInsertionLocation)
+            {
+                if (declarationList.IsEmpty())
                 {
-                    if (declarationList.IsEmpty())
-                    {
-                        return 0;
-                    }
+                    return 0;
+                }
 
-                    var desiredIndex = TryGetDesiredIndexIfGrouped(
-                        declarationList, declaration, availableIndices,
-                        comparerWithoutNameCheck, comparerWithNameCheck);
-                    if (desiredIndex.HasValue)
-                    {
-                        return desiredIndex.Value;
-                    }
+                var desiredIndex = TryGetDesiredIndexIfGrouped(
+                    declarationList, declaration, availableIndices,
+                    comparerWithoutNameCheck, comparerWithNameCheck);
+                if (desiredIndex.HasValue)
+                {
+                    return desiredIndex.Value;
+                }
 
-                    if (after != null)
+                if (after != null)
+                {
+                    var member = after(declarationList);
+                    if (member != null)
                     {
-                        var member = after(declarationList);
-                        if (member != null)
+                        var index = declarationList.IndexOf(member);
+                        if (index >= 0)
                         {
-                            var index = declarationList.IndexOf(member);
-                            if (index >= 0)
+                            index = GetPreferredIndex(index + 1, availableIndices, forward: true);
+                            if (index != -1)
                             {
-                                index = GetPreferredIndex(index + 1, availableIndices, forward: true);
-                                if (index != -1)
-                                {
-                                    return index;
-                                }
+                                return index;
                             }
                         }
                     }
+                }
 
-                    if (before != null)
+                if (before != null)
+                {
+                    var member = before(declarationList);
+                    if (member != null)
                     {
-                        var member = before(declarationList);
-                        if (member != null)
-                        {
-                            var index = declarationList.IndexOf(member);
+                        var index = declarationList.IndexOf(member);
 
-                            if (index >= 0)
+                        if (index >= 0)
+                        {
+                            index = GetPreferredIndex(index, availableIndices, forward: false);
+                            if (index != -1)
                             {
-                                index = GetPreferredIndex(index, availableIndices, forward: false);
-                                if (index != -1)
-                                {
-                                    return index;
-                                }
+                                return index;
                             }
                         }
                     }
diff --git a/src/Workspaces/Core/Portable/CodeGeneration/CodeGenerationOptions.cs b/src/Workspaces/Core/Portable/CodeGeneration/CodeGenerationOptions.cs
index cb62a720c740c..88f494bfe63ac 100644
--- a/src/Workspaces/Core/Portable/CodeGeneration/CodeGenerationOptions.cs
+++ b/src/Workspaces/Core/Portable/CodeGeneration/CodeGenerationOptions.cs
@@ -4,238 +4,37 @@
 
 using System;
 using System.Collections.Generic;
-using Microsoft.CodeAnalysis.Options;
+using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Simplification;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CodeGeneration
 {
     /// <summary>
-    /// Options for controlling the code produced by the <see cref="CodeGenerator"/>.
+    /// Context and preferences.
     /// </summary>
-    internal class CodeGenerationOptions
+    internal abstract class CodeGenerationOptions
     {
-        public static readonly CodeGenerationOptions Default = new();
+        public readonly CodeGenerationContext Context;
 
-        /// <summary>
-        /// A location used to determine the best place to generate a member.  This is only used for
-        /// determining which part of a partial type to generate in.  If a type only has one part, or
-        /// an API is used that specifies the type, then this is not used.  A part is preferred if
-        /// it surrounds this context location. If no part surrounds this location then a part is
-        /// preferred if it comes from the same SyntaxTree as this location.  If there is no
-        /// such part, then any part may be used for generation.
-        /// 
-        /// This option is not necessary if <see cref="AfterThisLocation"/> or <see cref="BeforeThisLocation"/> are
-        /// provided.
-        /// </summary>
-        public Location? ContextLocation { get; }
-
-        /// <summary>
-        /// A hint to the code generation service to specify where the generated code should be
-        /// placed.  Code will be generated after this location if the location is valid in the type
-        /// or symbol being generated into, and it is possible to generate the code after it.
-        /// 
-        /// If this option is provided, neither <see cref="ContextLocation"/> nor <see cref="BeforeThisLocation"/> are
-        /// needed.
-        /// </summary>
-        public Location? AfterThisLocation { get; }
-
-        /// <summary>
-        /// A hint to the code generation service to specify where the generated code should be
-        /// placed.  Code will be generated before this location if the location is valid in the type
-        /// or symbol being generated into, and it is possible to generate the code after it. 
-        /// 
-        /// If this option is provided, neither <see cref="ContextLocation"/> nor <see cref="AfterThisLocation"/> are
-        /// needed.
-        /// </summary>
-        public Location? BeforeThisLocation { get; }
-
-        /// <summary>
-        /// True if the code generation service should add <see cref="Simplifier.AddImportsAnnotation"/>,
-        /// and when not generating directly into a declaration, should try to automatically add imports to the file
-        /// for any generated code.
-        /// Defaults to true.
-        /// </summary>
-        public bool AddImports { get; }
-
-        /// <summary>
-        /// Contains additional imports to be automatically added.  This is useful for adding
-        /// imports that are part of a list of statements.
-        /// </summary>
-        public IEnumerable<INamespaceSymbol> AdditionalImports { get; }
-
-        /// <summary>
-        /// True if members of a symbol should also be generated along with the declaration.  If
-        /// false, only the symbol's declaration will be generated.
-        /// </summary>
-        public bool GenerateMembers { get; }
-
-        /// <summary>
-        /// True if the code generator should merge namespaces which only contain other namespaces
-        /// into a single declaration with a dotted name.  False if the nesting should be preserved
-        /// and each namespace declaration should be nested and should only have a single non-dotted
-        /// name.
-        /// 
-        /// Merging can only occur if the namespace only contains a single member that is also a
-        /// namespace.
-        /// </summary>
-        public bool MergeNestedNamespaces { get; }
-
-        /// <summary>
-        /// True if the code generation should put multiple attributes in a single attribute
-        /// declaration, or if should have a separate attribute declaration for each attribute.  For
-        /// example, in C# setting this to True this would produce "[Goo, Bar]" while setting it to
-        /// False would produce "[Goo][Bar]"
-        /// </summary>
-        public bool MergeAttributes { get; }
-
-        /// <summary>
-        /// True if the code generator should always generate accessibility modifiers, even if they
-        /// are the same as the defaults for that symbol.  For example, a private field in C# does
-        /// not need its accessibility specified as it will be private by default.  However, if this
-        /// option is set to true 'private' will still be generated.
-        /// </summary>
-        public bool GenerateDefaultAccessibility { get; }
-
-        /// <summary>
-        /// True if the code generator should generate empty bodies for methods along with the
-        /// method declaration.  If false, only method declarations will be generated.
-        /// </summary>
-        public bool GenerateMethodBodies { get; }
-
-        /// <summary>
-        /// True if the code generator should generate documentation comments where available
-        /// </summary>
-        public bool GenerateDocumentationComments { get; }
-
-        /// <summary>
-        /// True if the code generator should automatically attempt to choose the appropriate location
-        /// to insert members.  If false and a generation location is not specified by AfterThisLocation,
-        /// or BeforeThisLocation, members will be inserted at the end of the destination definition.
-        /// </summary>
-        public bool AutoInsertionLocation { get; }
-
-        /// <summary>
-        /// If <see cref="AutoInsertionLocation"/> is <see langword="false"/>, determines if members will be
-        /// sorted before being added to the end of the list of members.
-        /// </summary>
-        public bool SortMembers { get; }
-
-        /// <summary>
-        /// True if the code generator should attempt to reuse the syntax of the constituent entities, such as members, access modifier tokens, etc. while attempting to generate code.
-        /// If any of the member symbols have zero declaring syntax references (non-source symbols) OR two or more declaring syntax references (partial definitions), then syntax is not reused.
-        /// If false, then the code generator will always synthesize a new syntax node and ignore the declaring syntax references.
-        /// </summary>
-        public bool ReuseSyntax { get; }
-
-        public OptionSet? Options { get; }
-
-        public ParseOptions? ParseOptions { get; }
-
-        public CodeGenerationOptions(
-            Location? contextLocation = null,
-            Location? afterThisLocation = null,
-            Location? beforeThisLocation = null,
-            bool addImports = true,
-            IEnumerable<INamespaceSymbol>? additionalImports = null,
-            bool generateMembers = true,
-            bool mergeNestedNamespaces = true,
-            bool mergeAttributes = true,
-            bool generateDefaultAccessibility = true,
-            bool generateMethodBodies = true,
-            bool generateDocumentationComments = false,
-            bool autoInsertionLocation = true,
-            bool sortMembers = true,
-            bool reuseSyntax = false,
-            OptionSet? options = null,
-            ParseOptions? parseOptions = null)
+        protected CodeGenerationOptions(CodeGenerationContext context)
         {
-            CheckLocation(contextLocation, nameof(contextLocation));
-            CheckLocation(afterThisLocation, nameof(afterThisLocation));
-            CheckLocation(beforeThisLocation, nameof(beforeThisLocation));
-
-            this.ContextLocation = contextLocation;
-            this.AfterThisLocation = afterThisLocation;
-            this.BeforeThisLocation = beforeThisLocation;
-            this.AddImports = addImports;
-            this.AdditionalImports = additionalImports ?? SpecializedCollections.EmptyEnumerable<INamespaceSymbol>();
-            this.GenerateMembers = generateMembers;
-            this.MergeNestedNamespaces = mergeNestedNamespaces;
-            this.MergeAttributes = mergeAttributes;
-            this.GenerateDefaultAccessibility = generateDefaultAccessibility;
-            this.GenerateMethodBodies = generateMethodBodies;
-            this.GenerateDocumentationComments = generateDocumentationComments;
-            this.AutoInsertionLocation = autoInsertionLocation;
-            this.SortMembers = sortMembers;
-            this.ReuseSyntax = reuseSyntax;
-
-            this.Options = options;
-            this.ParseOptions = parseOptions ?? this.BestLocation?.SourceTree?.Options;
+            Context = context;
         }
 
-        private static void CheckLocation(Location? location, string name)
+        public static async ValueTask<CodeGenerationOptions> FromDocumentAsync(CodeGenerationContext context, Document document, CancellationToken cancellationToken)
         {
-            if (location != null && !location.IsInSource)
-            {
-                throw new ArgumentException(WorkspacesResources.Location_must_be_null_or_from_source, name);
-            }
+            var preferences = await CodeGenerationPreferences.FromDocumentAsync(document, cancellationToken).ConfigureAwait(false);
+            return preferences.GetOptions(context);
         }
 
-        internal Location? BestLocation
-            => this.AfterThisLocation ?? this.BeforeThisLocation ?? this.ContextLocation;
+        public CodeGenerationOptions WithContext(CodeGenerationContext value)
+            => WithContextImpl(value);
 
-        public CodeGenerationOptions With(
-            Optional<Location> contextLocation = default,
-            Optional<Location?> afterThisLocation = default,
-            Optional<Location?> beforeThisLocation = default,
-            Optional<bool> addImports = default,
-            Optional<IEnumerable<INamespaceSymbol>> additionalImports = default,
-            Optional<bool> generateMembers = default,
-            Optional<bool> mergeNestedNamespaces = default,
-            Optional<bool> mergeAttributes = default,
-            Optional<bool> generateDefaultAccessibility = default,
-            Optional<bool> generateMethodBodies = default,
-            Optional<bool> generateDocumentationComments = default,
-            Optional<bool> autoInsertionLocation = default,
-            Optional<bool> sortMembers = default,
-            Optional<bool> reuseSyntax = default,
-            Optional<OptionSet> options = default,
-            Optional<ParseOptions> parseOptions = default)
-        {
-            var newContextLocation = contextLocation.HasValue ? contextLocation.Value : this.ContextLocation;
-            var newAfterThisLocation = afterThisLocation.HasValue ? afterThisLocation.Value : this.AfterThisLocation;
-            var newBeforeThisLocation = beforeThisLocation.HasValue ? beforeThisLocation.Value : this.BeforeThisLocation;
-            var newAddImports = addImports.HasValue ? addImports.Value : this.AddImports;
-            var newAdditionalImports = additionalImports.HasValue ? additionalImports.Value : this.AdditionalImports;
-            var newGenerateMembers = generateMembers.HasValue ? generateMembers.Value : this.GenerateMembers;
-            var newMergeNestedNamespaces = mergeNestedNamespaces.HasValue ? mergeNestedNamespaces.Value : this.MergeNestedNamespaces;
-            var newMergeAttributes = mergeAttributes.HasValue ? mergeAttributes.Value : this.MergeAttributes;
-            var newGenerateDefaultAccessibility = generateDefaultAccessibility.HasValue ? generateDefaultAccessibility.Value : this.GenerateDefaultAccessibility;
-            var newGenerateMethodBodies = generateMethodBodies.HasValue ? generateMethodBodies.Value : this.GenerateMethodBodies;
-            var newGenerateDocumentationComments = generateDocumentationComments.HasValue ? generateDocumentationComments.Value : this.GenerateDocumentationComments;
-            var newAutoInsertionLocation = autoInsertionLocation.HasValue ? autoInsertionLocation.Value : this.AutoInsertionLocation;
-            var newSortMembers = sortMembers.HasValue ? sortMembers.Value : this.SortMembers;
-            var newReuseSyntax = reuseSyntax.HasValue ? reuseSyntax.Value : this.ReuseSyntax;
-            var newOptions = options.HasValue ? options.Value : this.Options;
-            var newParseOptions = parseOptions.HasValue ? parseOptions.Value : this.ParseOptions;
+        public CodeGenerationPreferences Preferences => PreferencesImpl;
 
-            return new CodeGenerationOptions(
-                newContextLocation,
-                newAfterThisLocation,
-                newBeforeThisLocation,
-                newAddImports,
-                newAdditionalImports,
-                newGenerateMembers,
-                newMergeNestedNamespaces,
-                newMergeAttributes,
-                newGenerateDefaultAccessibility,
-                newGenerateMethodBodies,
-                newGenerateDocumentationComments,
-                newAutoInsertionLocation,
-                newSortMembers,
-                newReuseSyntax,
-                newOptions,
-                newParseOptions);
-        }
+        protected abstract CodeGenerationPreferences PreferencesImpl { get; }
+        protected abstract CodeGenerationOptions WithContextImpl(CodeGenerationContext value);
     }
 }
diff --git a/src/Workspaces/Core/Portable/CodeGeneration/CodeGenerator.cs b/src/Workspaces/Core/Portable/CodeGeneration/CodeGenerator.cs
index 2c2f749ed72ba..0cc026f130959 100644
--- a/src/Workspaces/Core/Portable/CodeGeneration/CodeGenerator.cs
+++ b/src/Workspaces/Core/Portable/CodeGeneration/CodeGenerator.cs
@@ -1,10 +1,12 @@
 // 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 System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CodeGeneration
 {
@@ -18,190 +20,76 @@ internal static class CodeGenerator
         /// </summary>
         public static readonly SyntaxAnnotation Annotation = new(nameof(CodeGenerator));
 
-        private static ICodeGenerationService GetCodeGenerationService(Workspace workspace, string language)
-            => workspace.Services.GetLanguageServices(language).GetRequiredService<ICodeGenerationService>();
-
-        /// <summary>
-        /// Returns a newly created event declaration node from the provided event.
-        /// </summary>
-        public static SyntaxNode CreateEventDeclaration(IEventSymbol @event, Workspace workspace, CodeGenerationDestination destination = CodeGenerationDestination.Unspecified, CodeGenerationOptions? options = null)
-            => GetCodeGenerationService(workspace, @event.Language).CreateEventDeclaration(@event, destination, options);
-
-        /// <summary>
-        /// Returns a newly created field declaration node from the provided field.
-        /// </summary>
-        public static SyntaxNode CreateFieldDeclaration(IFieldSymbol field, Workspace workspace, CodeGenerationDestination destination = CodeGenerationDestination.Unspecified, CodeGenerationOptions? options = null)
-            => GetCodeGenerationService(workspace, field.Language).CreateFieldDeclaration(field, destination, options);
-
-        /// <summary>
-        /// Returns a newly created method declaration node from the provided method.
-        /// </summary>
-        public static SyntaxNode CreateMethodDeclaration(IMethodSymbol method, Workspace workspace, CodeGenerationDestination destination = CodeGenerationDestination.Unspecified, CodeGenerationOptions? options = null)
-            => GetCodeGenerationService(workspace, method.Language).CreateMethodDeclaration(method, destination, options);
-
-        /// <summary>
-        /// Returns a newly created property declaration node from the provided property.
-        /// </summary>
-        public static SyntaxNode CreatePropertyDeclaration(IPropertySymbol property, Workspace workspace, CodeGenerationDestination destination = CodeGenerationDestination.Unspecified, CodeGenerationOptions? options = null)
-            => GetCodeGenerationService(workspace, property.Language).CreatePropertyDeclaration(property, destination, options);
-
-        /// <summary>
-        /// Returns a newly created named type declaration node from the provided named type.
-        /// </summary>
-        public static SyntaxNode CreateNamedTypeDeclaration(INamedTypeSymbol namedType, Workspace workspace, CodeGenerationDestination destination = CodeGenerationDestination.Unspecified, CodeGenerationOptions? options = null)
-            => GetCodeGenerationService(workspace, namedType.Language).CreateNamedTypeDeclaration(namedType, destination, options);
-
-        /// <summary>
-        /// Returns a newly created namespace declaration node from the provided namespace.
-        /// </summary>
-        public static SyntaxNode CreateNamespaceDeclaration(INamespaceSymbol @namespace, Workspace workspace, CodeGenerationDestination destination = CodeGenerationDestination.Unspecified, CodeGenerationOptions? options = null)
-            => GetCodeGenerationService(workspace, @namespace.Language).CreateNamespaceDeclaration(@namespace, destination, options);
-
-        /// <summary>
-        /// Create a new declaration node with an event declaration of the same signature as the specified symbol added to it.
-        /// </summary>
-        public static TDeclarationNode AddEventDeclaration<TDeclarationNode>(TDeclarationNode destination, IEventSymbol @event, Workspace workspace, CodeGenerationOptions? options = null) where TDeclarationNode : SyntaxNode
-            => GetCodeGenerationService(workspace, destination.Language).AddEvent(destination, @event, options);
-
-        /// <summary>
-        /// Create a new declaration node with a field declaration of the same signature as the specified symbol added to it.
-        /// </summary>
-        public static TDeclarationNode AddFieldDeclaration<TDeclarationNode>(TDeclarationNode destination, IFieldSymbol field, Workspace workspace, CodeGenerationOptions? options = null) where TDeclarationNode : SyntaxNode
-            => GetCodeGenerationService(workspace, destination.Language).AddField(destination, field, options);
-
-        /// <summary>
-        /// Create a new declaration node with a method declaration of the same signature as the specified symbol added to it.
-        /// </summary>
-        public static TDeclarationNode AddMethodDeclaration<TDeclarationNode>(TDeclarationNode destination, IMethodSymbol method, Workspace workspace, CodeGenerationOptions? options = null) where TDeclarationNode : SyntaxNode
-            => GetCodeGenerationService(workspace, destination.Language).AddMethod(destination, method, options);
-
-        /// <summary>
-        /// Create a new declaration node with a property declaration of the same signature as the specified symbol added to it.
-        /// </summary>
-        public static TDeclarationNode AddPropertyDeclaration<TDeclarationNode>(TDeclarationNode destination, IPropertySymbol property, Workspace workspace, CodeGenerationOptions? options = null) where TDeclarationNode : SyntaxNode
-            => GetCodeGenerationService(workspace, destination.Language).AddProperty(destination, property, options);
-
-        /// <summary>
-        /// Create a new declaration node with a named type declaration of the same signature as the specified symbol added to it.
-        /// </summary>
-        public static TDeclarationNode AddNamedTypeDeclaration<TDeclarationNode>(TDeclarationNode destination, INamedTypeSymbol namedType, Workspace workspace, CodeGenerationOptions? options = null) where TDeclarationNode : SyntaxNode
-            => GetCodeGenerationService(workspace, destination.Language).AddNamedType(destination, namedType, options);
-
-        /// <summary>
-        /// Create a new declaration node with multiple member declarations of the same signatures as the specified symbols added to it.
-        /// </summary>
-        public static TDeclarationNode AddMemberDeclarations<TDeclarationNode>(TDeclarationNode destination, IEnumerable<ISymbol> members, Workspace workspace, CodeGenerationOptions? options = null) where TDeclarationNode : SyntaxNode
-            => GetCodeGenerationService(workspace, destination.Language).AddMembers(destination, members, options);
-
-        /// <summary>
-        /// Create a new declaration node with one or more parameter declarations of the same signature as the specified symbols added to it.
-        /// </summary>
-        public static TDeclarationNode AddParameterDeclarations<TDeclarationNode>(TDeclarationNode destinationMember, IEnumerable<IParameterSymbol> parameters, Workspace workspace, CodeGenerationOptions? options = null) where TDeclarationNode : SyntaxNode
-            => GetCodeGenerationService(workspace, destinationMember.Language).AddParameters(destinationMember, parameters, options);
-
-        /// <summary>
-        /// Create a new declaration node with the specified attributes added to it.
-        /// </summary>
-        public static TDeclarationNode AddAttributes<TDeclarationNode>(TDeclarationNode destination, Workspace workspace, IEnumerable<AttributeData> attributes, SyntaxToken? target = null, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode
-            => GetCodeGenerationService(workspace, destination.Language).AddAttributes(destination, attributes, target, options ?? CodeGenerationOptions.Default, cancellationToken);
-
-        /// <summary>
-        /// Removes the specified attribute node from the given declaration node.
-        /// </summary>
-        public static TDeclarationNode RemoveAttribute<TDeclarationNode>(TDeclarationNode destination, Workspace workspace, AttributeData attributeToRemove, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode
-            => GetCodeGenerationService(workspace, destination.Language).RemoveAttribute(destination, attributeToRemove, options ?? CodeGenerationOptions.Default, cancellationToken);
-
-        /// <summary>
-        /// Removes the specified attribute node from the given declaration node.
-        /// </summary>
-        public static TDeclarationNode RemoveAttribute<TDeclarationNode>(TDeclarationNode destination, Workspace workspace, SyntaxNode attributeToRemove, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode
-            => GetCodeGenerationService(workspace, destination.Language).RemoveAttribute(destination, attributeToRemove, options ?? CodeGenerationOptions.Default, cancellationToken);
-
-        public static TDeclarationNode UpdateDeclarationModifiers<TDeclarationNode>(TDeclarationNode destination, Workspace workspace, IEnumerable<SyntaxToken> newModifiers, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode
-            => GetCodeGenerationService(workspace, destination.Language).UpdateDeclarationModifiers(destination, newModifiers, options ?? new CodeGenerationOptions(reuseSyntax: true), cancellationToken);
-
-        public static TDeclarationNode UpdateDeclarationAccessibility<TDeclarationNode>(TDeclarationNode destination, Workspace workspace, Accessibility newAccessibility, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode
-            => GetCodeGenerationService(workspace, destination.Language).UpdateDeclarationAccessibility(destination, newAccessibility, options ?? new CodeGenerationOptions(reuseSyntax: true), cancellationToken);
-
-        public static TDeclarationNode UpdateDeclarationType<TDeclarationNode>(TDeclarationNode destination, Workspace workspace, ITypeSymbol newType, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode
-            => GetCodeGenerationService(workspace, destination.Language).UpdateDeclarationType(destination, newType, options ?? new CodeGenerationOptions(reuseSyntax: true), cancellationToken);
-
-        public static TDeclarationNode UpdateDeclarationMembers<TDeclarationNode>(TDeclarationNode destination, Workspace workspace, IList<ISymbol> newMembers, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode
-            => GetCodeGenerationService(workspace, destination.Language).UpdateDeclarationMembers(destination, newMembers, options ?? new CodeGenerationOptions(reuseSyntax: true), cancellationToken);
-
-        /// <summary>
-        /// Create a new declaration node with one or more statements added to its body.
-        /// </summary>
-        public static TDeclarationNode AddStatements<TDeclarationNode>(TDeclarationNode destinationMember, IEnumerable<SyntaxNode> statements, Workspace workspace, CodeGenerationOptions? options = null) where TDeclarationNode : SyntaxNode
-            => GetCodeGenerationService(workspace, destinationMember.Language).AddStatements(destinationMember, statements, options);
+        private static ICodeGenerationService GetCodeGenerationService(HostWorkspaceServices services, string language)
+            => services.GetLanguageServices(language).GetRequiredService<ICodeGenerationService>();
 
         /// <summary>
         /// Create a new solution where the declaration of the destination symbol has an additional event of the same signature as the specified event symbol.
         /// Returns the document in the new solution where the destination symbol is declared.
         /// </summary>
-        public static Task<Document> AddEventDeclarationAsync(Solution solution, INamedTypeSymbol destination, IEventSymbol @event, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default)
-            => GetCodeGenerationService(solution.Workspace, destination.Language).AddEventAsync(solution, destination, @event, options, cancellationToken);
+        public static Task<Document> AddEventDeclarationAsync(Solution solution, INamedTypeSymbol destination, IEventSymbol @event, CodeGenerationContext context, CancellationToken cancellationToken)
+            => GetCodeGenerationService(solution.Workspace.Services, destination.Language).AddEventAsync(solution, destination, @event, context, cancellationToken);
 
         /// <summary>
         /// Create a new solution where the declaration of the destination symbol has an additional field of the same signature as the specified field symbol.
         /// Returns the document in the new solution where the destination symbol is declared.
         /// </summary>
-        public static Task<Document> AddFieldDeclarationAsync(Solution solution, INamedTypeSymbol destination, IFieldSymbol field, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default)
-            => GetCodeGenerationService(solution.Workspace, destination.Language).AddFieldAsync(solution, destination, field, options, cancellationToken);
+        public static Task<Document> AddFieldDeclarationAsync(Solution solution, INamedTypeSymbol destination, IFieldSymbol field, CodeGenerationContext context, CancellationToken cancellationToken)
+            => GetCodeGenerationService(solution.Workspace.Services, destination.Language).AddFieldAsync(solution, destination, field, context, cancellationToken);
 
         /// <summary>
         /// Create a new solution where the declaration of the destination symbol has an additional method of the same signature as the specified method symbol.
         /// Returns the document in the new solution where the destination symbol is declared.
         /// </summary>
-        public static Task<Document> AddMethodDeclarationAsync(Solution solution, INamedTypeSymbol destination, IMethodSymbol method, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default)
-            => GetCodeGenerationService(solution.Workspace, destination.Language).AddMethodAsync(solution, destination, method, options, cancellationToken);
+        public static Task<Document> AddMethodDeclarationAsync(Solution solution, INamedTypeSymbol destination, IMethodSymbol method, CodeGenerationContext context, CancellationToken cancellationToken)
+            => GetCodeGenerationService(solution.Workspace.Services, destination.Language).AddMethodAsync(solution, destination, method, context, cancellationToken);
 
         /// <summary>
         /// Create a new solution where the declaration of the destination symbol has an additional property of the same signature as the specified property symbol.
         /// Returns the document in the new solution where the destination symbol is declared.
         /// </summary>
-        public static Task<Document> AddPropertyDeclarationAsync(Solution solution, INamedTypeSymbol destination, IPropertySymbol property, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default)
-            => GetCodeGenerationService(solution.Workspace, destination.Language).AddPropertyAsync(solution, destination, property, options, cancellationToken);
+        public static Task<Document> AddPropertyDeclarationAsync(Solution solution, INamedTypeSymbol destination, IPropertySymbol property, CodeGenerationContext context, CancellationToken cancellationToken)
+            => GetCodeGenerationService(solution.Workspace.Services, destination.Language).AddPropertyAsync(solution, destination, property, context, cancellationToken);
 
         /// <summary>
         /// Create a new solution where the declaration of the destination symbol has an additional named type of the same signature as the specified named type symbol.
         /// Returns the document in the new solution where the destination symbol is declared.
         /// </summary>
-        public static Task<Document> AddNamedTypeDeclarationAsync(Solution solution, INamedTypeSymbol destination, INamedTypeSymbol namedType, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default)
-            => GetCodeGenerationService(solution.Workspace, destination.Language).AddNamedTypeAsync(solution, destination, namedType, options, cancellationToken);
+        public static Task<Document> AddNamedTypeDeclarationAsync(Solution solution, INamedTypeSymbol destination, INamedTypeSymbol namedType, CodeGenerationContext context, CancellationToken cancellationToken)
+            => GetCodeGenerationService(solution.Workspace.Services, destination.Language).AddNamedTypeAsync(solution, destination, namedType, context, cancellationToken);
 
         /// <summary>
         /// Create a new solution where the declaration of the destination symbol has an additional named type of the same signature as the specified named type symbol.
         /// Returns the document in the new solution where the destination symbol is declared.
         /// </summary>
-        public static Task<Document> AddNamedTypeDeclarationAsync(Solution solution, INamespaceSymbol destination, INamedTypeSymbol namedType, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default)
-            => GetCodeGenerationService(solution.Workspace, destination.Language).AddNamedTypeAsync(solution, destination, namedType, options, cancellationToken);
+        public static Task<Document> AddNamedTypeDeclarationAsync(Solution solution, INamespaceSymbol destination, INamedTypeSymbol namedType, CodeGenerationContext context, CancellationToken cancellationToken)
+            => GetCodeGenerationService(solution.Workspace.Services, destination.Language).AddNamedTypeAsync(solution, destination, namedType, context, cancellationToken);
 
         /// <summary>
         /// Create a new solution where the declaration of the destination symbol has an additional namespace of the same signature as the specified namespace symbol.
         /// Returns the document in the new solution where the destination symbol is declared.
         /// </summary>
-        public static Task<Document> AddNamespaceDeclarationAsync(Solution solution, INamespaceSymbol destination, INamespaceSymbol @namespace, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default)
-            => GetCodeGenerationService(solution.Workspace, destination.Language).AddNamespaceAsync(solution, destination, @namespace, options, cancellationToken);
+        public static Task<Document> AddNamespaceDeclarationAsync(Solution solution, INamespaceSymbol destination, INamespaceSymbol @namespace, CodeGenerationContext context, CancellationToken cancellationToken)
+            => GetCodeGenerationService(solution.Workspace.Services, destination.Language).AddNamespaceAsync(solution, destination, @namespace, context, cancellationToken);
 
         /// <summary>
         /// Create a new solution where the declaration of the destination symbol has an additional namespace or type of the same signature as the specified namespace or type symbol.
         /// Returns the document in the new solution where the destination symbol is declared.
         /// </summary>
-        public static Task<Document> AddNamespaceOrTypeDeclarationAsync(Solution solution, INamespaceSymbol destination, INamespaceOrTypeSymbol namespaceOrType, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default)
-            => GetCodeGenerationService(solution.Workspace, destination.Language).AddNamespaceOrTypeAsync(solution, destination, namespaceOrType, options, cancellationToken);
+        public static Task<Document> AddNamespaceOrTypeDeclarationAsync(Solution solution, INamespaceSymbol destination, INamespaceOrTypeSymbol namespaceOrType, CodeGenerationContext context, CancellationToken cancellationToken)
+            => GetCodeGenerationService(solution.Workspace.Services, destination.Language).AddNamespaceOrTypeAsync(solution, destination, namespaceOrType, context, cancellationToken);
 
         /// <summary>
         /// Create a new solution where the declaration of the destination symbol has additional members of the same signature as the specified member symbols.
         /// Returns the document in the new solution where the destination symbol is declared.
         /// </summary>
-        public static Task<Document> AddMemberDeclarationsAsync(Solution solution, INamedTypeSymbol destination, IEnumerable<ISymbol> members, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default)
-            => GetCodeGenerationService(solution.Workspace, destination.Language).AddMembersAsync(solution, destination, members, options, cancellationToken);
+        public static Task<Document> AddMemberDeclarationsAsync(Solution solution, INamedTypeSymbol destination, IEnumerable<ISymbol> members, CodeGenerationContext context, CancellationToken cancellationToken)
+            => GetCodeGenerationService(solution.Workspace.Services, destination.Language).AddMembersAsync(solution, destination, members, context, cancellationToken);
 
         /// <summary>
         /// Returns <c>true</c> if additional declarations can be added to the destination symbol's declaration.
         /// </summary>
-        public static bool CanAdd(Solution solution, ISymbol destination, CancellationToken cancellationToken = default)
-            => GetCodeGenerationService(solution.Workspace, destination.Language).CanAddTo(destination, solution, cancellationToken);
+        public static bool CanAdd(Solution solution, ISymbol destination, CancellationToken cancellationToken)
+            => GetCodeGenerationService(solution.Workspace.Services, destination.Language).CanAddTo(destination, solution, cancellationToken);
     }
 }
diff --git a/src/Workspaces/Core/Portable/CodeGeneration/ICodeGenerationService.cs b/src/Workspaces/Core/Portable/CodeGeneration/ICodeGenerationService.cs
index 3eab235ee84e1..84b85e9e18d6d 100644
--- a/src/Workspaces/Core/Portable/CodeGeneration/ICodeGenerationService.cs
+++ b/src/Workspaces/Core/Portable/CodeGeneration/ICodeGenerationService.cs
@@ -6,175 +6,179 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Options;
 
 namespace Microsoft.CodeAnalysis.CodeGeneration
 {
     internal interface ICodeGenerationService : ILanguageService
     {
+        CodeGenerationPreferences GetPreferences(ParseOptions parseOptions, OptionSet documentOptions);
+
         /// <summary>
         /// Returns a newly created event declaration node from the provided event.
         /// </summary>
-        SyntaxNode CreateEventDeclaration(IEventSymbol @event, CodeGenerationDestination destination = CodeGenerationDestination.Unspecified, CodeGenerationOptions? options = null);
+        SyntaxNode CreateEventDeclaration(IEventSymbol @event, CodeGenerationDestination destination, CodeGenerationOptions options, CancellationToken cancellationToken);
 
         /// <summary>
         /// Returns a newly created field declaration node from the provided field.
         /// </summary>
-        SyntaxNode CreateFieldDeclaration(IFieldSymbol field, CodeGenerationDestination destination = CodeGenerationDestination.Unspecified, CodeGenerationOptions? options = null);
+        SyntaxNode CreateFieldDeclaration(IFieldSymbol field, CodeGenerationDestination destination, CodeGenerationOptions options, CancellationToken cancellationToken);
 
         /// <summary>
         /// Returns a newly created method declaration node from the provided method.
+        /// TODO: do not return null (https://github.com/dotnet/roslyn/issues/58243)
         /// </summary>
-        SyntaxNode CreateMethodDeclaration(IMethodSymbol method, CodeGenerationDestination destination = CodeGenerationDestination.Unspecified, CodeGenerationOptions? options = null);
+        SyntaxNode? CreateMethodDeclaration(IMethodSymbol method, CodeGenerationDestination destination, CodeGenerationOptions options, CancellationToken cancellationToken);
 
         /// <summary>
         /// Returns a newly created property declaration node from the provided property.
         /// </summary>
-        SyntaxNode CreatePropertyDeclaration(IPropertySymbol property, CodeGenerationDestination destination = CodeGenerationDestination.Unspecified, CodeGenerationOptions? options = null);
+        SyntaxNode CreatePropertyDeclaration(IPropertySymbol property, CodeGenerationDestination destination, CodeGenerationOptions options, CancellationToken cancellationToken);
 
         /// <summary>
         /// Returns a newly created named type declaration node from the provided named type.
         /// </summary>
-        SyntaxNode CreateNamedTypeDeclaration(INamedTypeSymbol namedType, CodeGenerationDestination destination = CodeGenerationDestination.Unspecified, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default);
+        SyntaxNode CreateNamedTypeDeclaration(INamedTypeSymbol namedType, CodeGenerationDestination destination, CodeGenerationOptions options, CancellationToken cancellationToken);
 
         /// <summary>
         /// Returns a newly created namespace declaration node from the provided namespace.
         /// </summary>
-        SyntaxNode CreateNamespaceDeclaration(INamespaceSymbol @namespace, CodeGenerationDestination destination = CodeGenerationDestination.Unspecified, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default);
+        SyntaxNode CreateNamespaceDeclaration(INamespaceSymbol @namespace, CodeGenerationDestination destination, CodeGenerationOptions options, CancellationToken cancellationToken);
 
         /// <summary>
         /// Adds an event into destination.
         /// </summary>
-        TDeclarationNode AddEvent<TDeclarationNode>(TDeclarationNode destination, IEventSymbol @event, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode;
+        TDeclarationNode AddEvent<TDeclarationNode>(TDeclarationNode destination, IEventSymbol @event, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
 
         /// <summary>
         /// Adds a field into destination.
         /// </summary>
-        TDeclarationNode AddField<TDeclarationNode>(TDeclarationNode destination, IFieldSymbol field, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode;
+        TDeclarationNode AddField<TDeclarationNode>(TDeclarationNode destination, IFieldSymbol field, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
 
         /// <summary>
         /// Adds a method into destination.
         /// </summary>
-        TDeclarationNode AddMethod<TDeclarationNode>(TDeclarationNode destination, IMethodSymbol method, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode;
+        TDeclarationNode AddMethod<TDeclarationNode>(TDeclarationNode destination, IMethodSymbol method, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
 
         /// <summary>
         /// Adds a property into destination. 
         /// </summary>
-        TDeclarationNode AddProperty<TDeclarationNode>(TDeclarationNode destination, IPropertySymbol property, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode;
+        TDeclarationNode AddProperty<TDeclarationNode>(TDeclarationNode destination, IPropertySymbol property, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
 
         /// <summary>
         /// Adds a named type into destination. 
         /// </summary>
-        TDeclarationNode AddNamedType<TDeclarationNode>(TDeclarationNode destination, INamedTypeSymbol namedType, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode;
+        TDeclarationNode AddNamedType<TDeclarationNode>(TDeclarationNode destination, INamedTypeSymbol namedType, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
 
         /// <summary>
         /// Adds a namespace into destination. 
         /// </summary>
-        TDeclarationNode AddNamespace<TDeclarationNode>(TDeclarationNode destination, INamespaceSymbol @namespace, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode;
+        TDeclarationNode AddNamespace<TDeclarationNode>(TDeclarationNode destination, INamespaceSymbol @namespace, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
 
         /// <summary>
         /// Adds members into destination.
         /// </summary>
-        TDeclarationNode AddMembers<TDeclarationNode>(TDeclarationNode destination, IEnumerable<ISymbol> members, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode;
+        TDeclarationNode AddMembers<TDeclarationNode>(TDeclarationNode destination, IEnumerable<ISymbol> members, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
 
         /// <summary>
         /// Adds the parameters to destination.
         /// </summary>
-        TDeclarationNode AddParameters<TDeclarationNode>(TDeclarationNode destination, IEnumerable<IParameterSymbol> parameters, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode;
+        TDeclarationNode AddParameters<TDeclarationNode>(TDeclarationNode destination, IEnumerable<IParameterSymbol> parameters, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
 
         /// <summary>
         /// Adds the attributes to destination.
         /// </summary>
-        TDeclarationNode AddAttributes<TDeclarationNode>(TDeclarationNode destination, IEnumerable<AttributeData> attributes, SyntaxToken? target = null, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode;
+        TDeclarationNode AddAttributes<TDeclarationNode>(TDeclarationNode destination, IEnumerable<AttributeData> attributes, SyntaxToken? target, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
 
         /// <summary>
         /// Remove the given attribute from destination.
         /// </summary>
-        TDeclarationNode RemoveAttribute<TDeclarationNode>(TDeclarationNode destination, SyntaxNode attributeToRemove, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode;
+        TDeclarationNode RemoveAttribute<TDeclarationNode>(TDeclarationNode destination, SyntaxNode attributeToRemove, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
 
         /// <summary>
         /// Remove the given attribute from destination.
         /// </summary>
-        TDeclarationNode RemoveAttribute<TDeclarationNode>(TDeclarationNode destination, AttributeData attributeToRemove, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode;
+        TDeclarationNode RemoveAttribute<TDeclarationNode>(TDeclarationNode destination, AttributeData attributeToRemove, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
 
         /// <summary>
         /// Update the modifiers list for the given declaration node.
         /// </summary>
-        TDeclarationNode UpdateDeclarationModifiers<TDeclarationNode>(TDeclarationNode declaration, IEnumerable<SyntaxToken> newModifiers, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode;
+        TDeclarationNode UpdateDeclarationModifiers<TDeclarationNode>(TDeclarationNode declaration, IEnumerable<SyntaxToken> newModifiers, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
 
         /// <summary>
         /// Update the accessibility modifiers for the given declaration node, retaining the trivia of the existing modifiers.
         /// </summary>
-        TDeclarationNode UpdateDeclarationAccessibility<TDeclarationNode>(TDeclarationNode declaration, Accessibility newAccessibility, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode;
+        TDeclarationNode UpdateDeclarationAccessibility<TDeclarationNode>(TDeclarationNode declaration, Accessibility newAccessibility, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
 
         /// <summary>
         /// Update the type for the given declaration node.
         /// </summary>
-        TDeclarationNode UpdateDeclarationType<TDeclarationNode>(TDeclarationNode declaration, ITypeSymbol newType, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode;
+        TDeclarationNode UpdateDeclarationType<TDeclarationNode>(TDeclarationNode declaration, ITypeSymbol newType, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
 
         /// <summary>
         /// Replace the existing members with the given newMembers for the given declaration node.
         /// </summary>
-        TDeclarationNode UpdateDeclarationMembers<TDeclarationNode>(TDeclarationNode declaration, IList<ISymbol> newMembers, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode;
+        TDeclarationNode UpdateDeclarationMembers<TDeclarationNode>(TDeclarationNode declaration, IList<ISymbol> newMembers, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
 
         /// <summary>
         /// Adds the statements to destination.
         /// </summary>
-        TDeclarationNode AddStatements<TDeclarationNode>(TDeclarationNode destination, IEnumerable<SyntaxNode> statements, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode;
+        TDeclarationNode AddStatements<TDeclarationNode>(TDeclarationNode destination, IEnumerable<SyntaxNode> statements, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode;
 
         /// <summary>
         /// Adds a field with the provided signature into destination.
         /// </summary>
-        Task<Document> AddEventAsync(Solution solution, INamedTypeSymbol destination, IEventSymbol @event, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default);
+        Task<Document> AddEventAsync(Solution solution, INamedTypeSymbol destination, IEventSymbol @event, CodeGenerationContext context, CancellationToken cancellationToken);
 
         /// <summary>
         /// Adds a field with the provided signature into destination.
         /// </summary>
-        Task<Document> AddFieldAsync(Solution solution, INamedTypeSymbol destination, IFieldSymbol field, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default);
+        Task<Document> AddFieldAsync(Solution solution, INamedTypeSymbol destination, IFieldSymbol field, CodeGenerationContext context, CancellationToken cancellationToken);
 
         /// <summary>
         /// Adds a method with the provided signature into destination.
         /// </summary>
-        Task<Document> AddMethodAsync(Solution solution, INamedTypeSymbol destination, IMethodSymbol method, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default);
+        Task<Document> AddMethodAsync(Solution solution, INamedTypeSymbol destination, IMethodSymbol method, CodeGenerationContext context, CancellationToken cancellationToken);
 
         /// <summary>
         /// Adds a property with the provided signature into destination.
         /// </summary>
-        Task<Document> AddPropertyAsync(Solution solution, INamedTypeSymbol destination, IPropertySymbol property, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default);
+        Task<Document> AddPropertyAsync(Solution solution, INamedTypeSymbol destination, IPropertySymbol property, CodeGenerationContext context, CancellationToken cancellationToken);
 
         /// <summary>
         /// Adds a named type into destination.
         /// </summary>
-        Task<Document> AddNamedTypeAsync(Solution solution, INamedTypeSymbol destination, INamedTypeSymbol namedType, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default);
+        Task<Document> AddNamedTypeAsync(Solution solution, INamedTypeSymbol destination, INamedTypeSymbol namedType, CodeGenerationContext context, CancellationToken cancellationToken);
 
         /// <summary>
         /// Adds a named type into destination.
         /// </summary>
-        Task<Document> AddNamedTypeAsync(Solution solution, INamespaceSymbol destination, INamedTypeSymbol namedType, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default);
+        Task<Document> AddNamedTypeAsync(Solution solution, INamespaceSymbol destination, INamedTypeSymbol namedType, CodeGenerationContext context, CancellationToken cancellationToken);
 
         /// <summary>
         /// Adds a namespace into destination.
         /// </summary>
-        Task<Document> AddNamespaceAsync(Solution solution, INamespaceSymbol destination, INamespaceSymbol @namespace, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default);
+        Task<Document> AddNamespaceAsync(Solution solution, INamespaceSymbol destination, INamespaceSymbol @namespace, CodeGenerationContext context, CancellationToken cancellationToken);
 
         /// <summary>
         /// Adds a namespace or type into destination.
         /// </summary>
-        Task<Document> AddNamespaceOrTypeAsync(Solution solution, INamespaceSymbol destination, INamespaceOrTypeSymbol namespaceOrType, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default);
+        Task<Document> AddNamespaceOrTypeAsync(Solution solution, INamespaceSymbol destination, INamespaceOrTypeSymbol namespaceOrType, CodeGenerationContext context, CancellationToken cancellationToken);
 
         /// <summary>
         /// Adds all the provided members into destination.
         /// </summary>
-        Task<Document> AddMembersAsync(Solution solution, INamedTypeSymbol destination, IEnumerable<ISymbol> members, CodeGenerationOptions? options = null, CancellationToken cancellationToken = default);
+        Task<Document> AddMembersAsync(Solution solution, INamedTypeSymbol destination, IEnumerable<ISymbol> members, CodeGenerationContext context, CancellationToken cancellationToken);
 
         /// <summary>
         /// <c>true</c> if destination is a location where other symbols can be added to.
         /// </summary>
-        bool CanAddTo(ISymbol destination, Solution solution, CancellationToken cancellationToken = default);
+        bool CanAddTo(ISymbol destination, Solution solution, CancellationToken cancellationToken);
 
         /// <summary>
         /// <c>true</c> if destination is a location where other symbols can be added to.
         /// </summary>
-        bool CanAddTo(SyntaxNode destination, Solution solution, CancellationToken cancellationToken = default);
+        bool CanAddTo(SyntaxNode destination, Solution solution, CancellationToken cancellationToken);
 
         /// <summary>
         /// Return the most relevant declaration to namespaceOrType,
@@ -182,6 +186,12 @@ internal interface ICodeGenerationService : ILanguageService
         /// then the declaration in the same file, then non auto-generated file,
         /// then all the potential location. Return null if no declaration.
         /// </summary>
-        Task<SyntaxNode?> FindMostRelevantNameSpaceOrTypeDeclarationAsync(Solution solution, INamespaceOrTypeSymbol namespaceOrType, CodeGenerationOptions options, CancellationToken cancellationToken);
+        Task<SyntaxNode?> FindMostRelevantNameSpaceOrTypeDeclarationAsync(Solution solution, INamespaceOrTypeSymbol namespaceOrType, CodeGenerationContext context, CancellationToken cancellationToken);
+    }
+
+    internal static class ICodeGenerationServiceExtensions
+    {
+        public static CodeGenerationOptions GetOptions(this ICodeGenerationService service, ParseOptions parseOptions, OptionSet documentOptions, CodeGenerationContext context)
+            => service.GetPreferences(parseOptions, documentOptions).GetOptions(context);
     }
 }
diff --git a/src/Workspaces/Core/Portable/Editing/DocumentEditor.cs b/src/Workspaces/Core/Portable/Editing/DocumentEditor.cs
index 0a32cfae46cd3..77a1e50bb222e 100644
--- a/src/Workspaces/Core/Portable/Editing/DocumentEditor.cs
+++ b/src/Workspaces/Core/Portable/Editing/DocumentEditor.cs
@@ -19,7 +19,7 @@ public class DocumentEditor : SyntaxEditor
         private readonly SemanticModel _model;
 
         private DocumentEditor(Document document, SemanticModel model, SyntaxNode root)
-            : base(root, document.Project.Solution.Workspace)
+            : base(root, document.Project.Solution.Workspace.Services)
         {
             _document = document;
             _model = model;
diff --git a/src/Workspaces/Core/Portable/Editing/ImportAdderService.cs b/src/Workspaces/Core/Portable/Editing/ImportAdderService.cs
index e61b54477eb74..aa0b14457c4b7 100644
--- a/src/Workspaces/Core/Portable/Editing/ImportAdderService.cs
+++ b/src/Workspaces/Core/Portable/Editing/ImportAdderService.cs
@@ -9,6 +9,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.AddImports;
+using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Options;
@@ -40,7 +41,9 @@ public async Task<Document> AddImportsAsync(
 
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             var addImportsService = document.GetRequiredLanguageService<IAddImportsService>();
+            var codeGenerator = document.GetRequiredLanguageService<ICodeGenerationService>();
             var generator = document.GetRequiredLanguageService<SyntaxGenerator>();
+            var preferences = codeGenerator.GetPreferences(root.SyntaxTree.Options, options);
 
             // Create a simple interval tree for simplification spans.
             var spansTree = new SimpleIntervalTree<TextSpan, TextSpanIntervalIntrospector>(new TextSpanIntervalIntrospector(), spans);
@@ -61,10 +64,10 @@ public async Task<Document> AddImportsAsync(
             var allowInHiddenRegions = document.CanAddImportsInHiddenRegions();
 
             if (strategy == Strategy.AddImportsFromSymbolAnnotations)
-                return await AddImportDirectivesFromSymbolAnnotationsAsync(document, options, nodes, addImportsService, generator, allowInHiddenRegions, cancellationToken).ConfigureAwait(false);
+                return await AddImportDirectivesFromSymbolAnnotationsAsync(document, preferences, nodes, addImportsService, generator, allowInHiddenRegions, cancellationToken).ConfigureAwait(false);
 
             if (strategy == Strategy.AddImportsFromSyntaxes)
-                return await AddImportDirectivesFromSyntaxesAsync(document, options, nodes, addImportsService, generator, allowInHiddenRegions, cancellationToken).ConfigureAwait(false);
+                return await AddImportDirectivesFromSyntaxesAsync(document, preferences, nodes, addImportsService, generator, allowInHiddenRegions, cancellationToken).ConfigureAwait(false);
 
             throw ExceptionUtilities.UnexpectedValue(strategy);
         }
@@ -107,7 +110,7 @@ private static SyntaxNode GenerateNamespaceImportDeclaration(INamespaceSymbol na
 
         private async Task<Document> AddImportDirectivesFromSyntaxesAsync(
             Document document,
-            OptionSet options,
+            CodeGenerationPreferences preferences,
             IEnumerable<SyntaxNode> syntaxNodes,
             IAddImportsService addImportsService,
             SyntaxGenerator generator,
@@ -160,7 +163,7 @@ private async Task<Document> AddImportDirectivesFromSyntaxesAsync(
             var context = first.GetCommonRoot(last);
 
             root = addImportsService.AddImports(
-                model.Compilation, root, context, importsToAdd, generator, options,
+                model.Compilation, root, context, importsToAdd, generator, preferences,
                 allowInHiddenRegions, cancellationToken);
 
             return document.WithSyntaxRoot(root);
@@ -168,7 +171,7 @@ private async Task<Document> AddImportDirectivesFromSyntaxesAsync(
 
         private async Task<Document> AddImportDirectivesFromSymbolAnnotationsAsync(
             Document document,
-            OptionSet options,
+            CodeGenerationPreferences preferences,
             IEnumerable<SyntaxNode> syntaxNodes,
             IAddImportsService addImportsService,
             SyntaxGenerator generator,
@@ -229,7 +232,7 @@ private async Task<Document> AddImportDirectivesFromSymbolAnnotationsAsync(
             var context = first.GetCommonRoot(last);
 
             // Find the namespace/compilation-unit we'll be adding all these imports to.
-            var importContainer = addImportsService.GetImportContainer(root, context, importToSyntax.First().Value, options);
+            var importContainer = addImportsService.GetImportContainer(root, context, importToSyntax.First().Value, preferences);
 
             // Now remove any imports we think can cause conflicts in that container.
             var safeImportsToAdd = GetSafeToAddImports(importToSyntax.Keys.ToImmutableArray(), importContainer, model, cancellationToken);
@@ -239,7 +242,7 @@ private async Task<Document> AddImportDirectivesFromSymbolAnnotationsAsync(
                 return document;
 
             root = addImportsService.AddImports(
-                model.Compilation, root, context, importsToAdd, generator, options,
+                model.Compilation, root, context, importsToAdd, generator, preferences,
                 allowInHiddenRegions, cancellationToken);
             return document.WithSyntaxRoot(root);
         }
diff --git a/src/Workspaces/Core/Portable/Editing/SyntaxEditor.cs b/src/Workspaces/Core/Portable/Editing/SyntaxEditor.cs
index daf8f4e07e9ae..0a90abac32167 100644
--- a/src/Workspaces/Core/Portable/Editing/SyntaxEditor.cs
+++ b/src/Workspaces/Core/Portable/Editing/SyntaxEditor.cs
@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using Microsoft.CodeAnalysis.Host;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Editing
@@ -23,21 +24,24 @@ public class SyntaxEditor
         /// <summary>
         /// Creates a new <see cref="SyntaxEditor"/> instance.
         /// </summary>
+        [Obsolete("Use SyntaxEditor(SyntaxNode, HostWorkspaceServices)")]
         public SyntaxEditor(SyntaxNode root, Workspace workspace)
+            : this(root, (workspace ?? throw new ArgumentNullException(nameof(workspace))).Services)
         {
-            if (workspace == null)
-            {
-                throw new ArgumentNullException(nameof(workspace));
-            }
+        }
 
-            OriginalRoot = root ?? throw new ArgumentNullException(nameof(root));
-            _generator = SyntaxGenerator.GetGenerator(workspace, root.Language);
-            _changes = new List<Change>();
+        /// <summary>
+        /// Creates a new <see cref="SyntaxEditor"/> instance.
+        /// </summary>
+        public SyntaxEditor(SyntaxNode root, HostWorkspaceServices services)
+            : this(root ?? throw new ArgumentNullException(nameof(root)),
+                   SyntaxGenerator.GetGenerator(services ?? throw new ArgumentNullException(nameof(services)), root.Language))
+        {
         }
 
         internal SyntaxEditor(SyntaxNode root, SyntaxGenerator generator)
         {
-            OriginalRoot = root ?? throw new ArgumentNullException(nameof(root));
+            OriginalRoot = root;
             _generator = generator;
             _changes = new List<Change>();
         }
@@ -83,8 +87,8 @@ private IEnumerable<SyntaxNode> ApplyTrackingToNewNodes(IEnumerable<SyntaxNode>
         /// </summary>
         public SyntaxNode GetChangedRoot()
         {
-            var nodes = Enumerable.Distinct(_changes.Where(c => OriginalRoot.Contains(c.Node))
-                                                    .Select(c => c.Node));
+            var nodes = Enumerable.Distinct(_changes.Where(c => OriginalRoot.Contains(c.OriginalNode))
+                                                    .Select(c => c.OriginalNode));
             var newRoot = OriginalRoot.TrackNodes(nodes);
 
             foreach (var change in _changes)
@@ -264,26 +268,40 @@ private void CheckNodeInOriginalTreeOrTracked(SyntaxNode node)
 
         private abstract class Change
         {
-            internal readonly SyntaxNode Node;
+            internal readonly SyntaxNode OriginalNode;
 
             public Change(SyntaxNode node)
-                => this.Node = node;
+                => OriginalNode = node;
+
+            public SyntaxNode Apply(SyntaxNode root, SyntaxGenerator generator)
+            {
+                var currentNode = root.GetCurrentNode(OriginalNode);
+                if (currentNode is null)
+                {
+                    Contract.Fail($"GetCurrentNode returned null with the following node: {OriginalNode}");
+                }
+
+                return Apply(root, currentNode, generator);
+            }
+
+            protected static SyntaxNode ValidateNewRoot(SyntaxNode? root)
+                => root ?? throw new InvalidOperationException("Tree root deleted");
 
-            public abstract SyntaxNode Apply(SyntaxNode root, SyntaxGenerator generator);
+            protected abstract SyntaxNode Apply(SyntaxNode root, SyntaxNode currentNode, SyntaxGenerator generator);
         }
 
-        private class NoChange : Change
+        private sealed class NoChange : Change
         {
             public NoChange(SyntaxNode node)
                 : base(node)
             {
             }
 
-            public override SyntaxNode Apply(SyntaxNode root, SyntaxGenerator generator)
+            protected override SyntaxNode Apply(SyntaxNode root, SyntaxNode currentNode, SyntaxGenerator generator)
                 => root;
         }
 
-        private class RemoveChange : Change
+        private sealed class RemoveChange : Change
         {
             private readonly SyntaxRemoveOptions _options;
 
@@ -293,11 +311,11 @@ public RemoveChange(SyntaxNode node, SyntaxRemoveOptions options)
                 _options = options;
             }
 
-            public override SyntaxNode Apply(SyntaxNode root, SyntaxGenerator generator)
-                => generator.RemoveNode(root, root.GetCurrentNode(this.Node), _options);
+            protected override SyntaxNode Apply(SyntaxNode root, SyntaxNode currentNode, SyntaxGenerator generator)
+                => ValidateNewRoot(generator.RemoveNode(root, currentNode, _options));
         }
 
-        private class ReplaceChange : Change
+        private sealed class ReplaceChange : Change
         {
             private readonly Func<SyntaxNode, SyntaxGenerator, SyntaxNode?> _modifier;
             private readonly SyntaxEditor _editor;
@@ -308,26 +326,20 @@ public ReplaceChange(
                 SyntaxEditor editor)
                 : base(node)
             {
-                Contract.ThrowIfNull(node, "Passed in node is null.");
+                Contract.ThrowIfNull(node);
                 _modifier = modifier;
                 _editor = editor;
             }
 
-            public override SyntaxNode Apply(SyntaxNode root, SyntaxGenerator generator)
+            protected override SyntaxNode Apply(SyntaxNode root, SyntaxNode currentNode, SyntaxGenerator generator)
             {
-                var current = root.GetCurrentNode(this.Node);
-                if (current is null)
-                {
-                    Contract.Fail($"GetCurrentNode returned null with the following node: {this.Node}");
-                }
-
-                var newNode = _modifier(current, generator);
+                var newNode = _modifier(currentNode, generator);
                 newNode = _editor.ApplyTrackingToNewNode(newNode);
-                return generator.ReplaceNode(root, current, newNode);
+                return ValidateNewRoot(generator.ReplaceNode(root, currentNode, newNode));
             }
         }
 
-        private class ReplaceWithCollectionChange : Change
+        private sealed class ReplaceWithCollectionChange : Change
         {
             private readonly Func<SyntaxNode, SyntaxGenerator, IEnumerable<SyntaxNode>> _modifier;
             private readonly SyntaxEditor _editor;
@@ -342,25 +354,19 @@ public ReplaceWithCollectionChange(
                 _editor = editor;
             }
 
-            public override SyntaxNode Apply(SyntaxNode root, SyntaxGenerator generator)
+            protected override SyntaxNode Apply(SyntaxNode root, SyntaxNode currentNode, SyntaxGenerator generator)
             {
-                var current = root.GetCurrentNode(this.Node);
-                if (current is null)
-                {
-                    Contract.Fail($"GetCurrentNode returned null with the following node: {this.Node}");
-                }
-
-                var newNodes = _modifier(current, generator).ToList();
+                var newNodes = _modifier(currentNode, generator).ToList();
                 for (var i = 0; i < newNodes.Count; i++)
                 {
                     newNodes[i] = _editor.ApplyTrackingToNewNode(newNodes[i]);
                 }
 
-                return SyntaxGenerator.ReplaceNode(root, current, newNodes);
+                return SyntaxGenerator.ReplaceNode(root, currentNode, newNodes);
             }
         }
 
-        private class ReplaceChange<TArgument> : Change
+        private sealed class ReplaceChange<TArgument> : Change
         {
             private readonly Func<SyntaxNode, SyntaxGenerator, TArgument, SyntaxNode> _modifier;
             private readonly TArgument _argument;
@@ -378,21 +384,15 @@ public ReplaceChange(
                 _editor = editor;
             }
 
-            public override SyntaxNode Apply(SyntaxNode root, SyntaxGenerator generator)
+            protected override SyntaxNode Apply(SyntaxNode root, SyntaxNode currentNode, SyntaxGenerator generator)
             {
-                var current = root.GetCurrentNode(this.Node);
-                if (current is null)
-                {
-                    Contract.Fail($"GetCurrentNode returned null with the following node: {this.Node}");
-                }
-
-                var newNode = _modifier(current, generator, _argument);
+                var newNode = _modifier(currentNode, generator, _argument);
                 newNode = _editor.ApplyTrackingToNewNode(newNode);
-                return generator.ReplaceNode(root, current, newNode);
+                return ValidateNewRoot(generator.ReplaceNode(root, currentNode, newNode));
             }
         }
 
-        private class InsertChange : Change
+        private sealed class InsertChange : Change
         {
             private readonly List<SyntaxNode> _newNodes;
             private readonly bool _isBefore;
@@ -404,17 +404,10 @@ public InsertChange(SyntaxNode node, IEnumerable<SyntaxNode> newNodes, bool isBe
                 _isBefore = isBefore;
             }
 
-            public override SyntaxNode Apply(SyntaxNode root, SyntaxGenerator generator)
-            {
-                if (_isBefore)
-                {
-                    return generator.InsertNodesBefore(root, root.GetCurrentNode(this.Node), _newNodes);
-                }
-                else
-                {
-                    return generator.InsertNodesAfter(root, root.GetCurrentNode(this.Node), _newNodes);
-                }
-            }
+            protected override SyntaxNode Apply(SyntaxNode root, SyntaxNode currentNode, SyntaxGenerator generator)
+                => _isBefore ?
+                    generator.InsertNodesBefore(root, currentNode, _newNodes) :
+                    generator.InsertNodesAfter(root, currentNode, _newNodes);
         }
     }
 }
diff --git a/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs b/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs
index a1f5de87e5a8b..f2ef1efb52eeb 100644
--- a/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs
+++ b/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs
@@ -2,11 +2,11 @@
 // 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.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis;
@@ -33,7 +33,7 @@ namespace Microsoft.CodeAnalysis.Editing
     /// </summary>
     public abstract class SyntaxGenerator : ILanguageService
     {
-        public static SyntaxRemoveOptions DefaultRemoveOptions = SyntaxRemoveOptions.KeepUnbalancedDirectives | SyntaxRemoveOptions.AddElasticMarker;
+        public static readonly SyntaxRemoveOptions DefaultRemoveOptions = SyntaxRemoveOptions.KeepUnbalancedDirectives | SyntaxRemoveOptions.AddElasticMarker;
 
         internal abstract SyntaxTrivia CarriageReturnLineFeed { get; }
         internal abstract SyntaxTrivia ElasticCarriageReturnLineFeed { get; }
@@ -51,7 +51,10 @@ public abstract class SyntaxGenerator : ILanguageService
         /// Gets the <see cref="SyntaxGenerator"/> for the specified language.
         /// </summary>
         public static SyntaxGenerator GetGenerator(Workspace workspace, string language)
-            => workspace.Services.GetLanguageServices(language).GetService<SyntaxGenerator>();
+            => GetGenerator(workspace.Services, language);
+
+        internal static SyntaxGenerator GetGenerator(HostWorkspaceServices services, string language)
+            => services.GetLanguageServices(language).GetRequiredService<SyntaxGenerator>();
 
         /// <summary>
         /// Gets the <see cref="SyntaxGenerator"/> for the language corresponding to the document.
@@ -63,14 +66,14 @@ public static SyntaxGenerator GetGenerator(Document document)
         /// Gets the <see cref="SyntaxGenerator"/> for the language corresponding to the project.
         /// </summary>
         public static SyntaxGenerator GetGenerator(Project project)
-            => project.LanguageServices.GetService<SyntaxGenerator>();
+            => project.LanguageServices.GetRequiredService<SyntaxGenerator>();
 
         #region Declarations
 
         /// <summary>
         /// Returns the node if it is a declaration, the immediate enclosing declaration if one exists, or null.
         /// </summary>
-        public SyntaxNode GetDeclaration(SyntaxNode node)
+        public SyntaxNode? GetDeclaration(SyntaxNode? node)
         {
             while (node != null)
             {
@@ -78,10 +81,8 @@ public SyntaxNode GetDeclaration(SyntaxNode node)
                 {
                     return node;
                 }
-                else
-                {
-                    node = node.Parent;
-                }
+
+                node = node.Parent;
             }
 
             return null;
@@ -90,7 +91,7 @@ public SyntaxNode GetDeclaration(SyntaxNode node)
         /// <summary>
         /// Returns the enclosing declaration of the specified kind or null.
         /// </summary>
-        public SyntaxNode GetDeclaration(SyntaxNode node, DeclarationKind kind)
+        public SyntaxNode? GetDeclaration(SyntaxNode? node, DeclarationKind kind)
         {
             while (node != null)
             {
@@ -98,10 +99,8 @@ public SyntaxNode GetDeclaration(SyntaxNode node, DeclarationKind kind)
                 {
                     return node;
                 }
-                else
-                {
-                    node = node.Parent;
-                }
+
+                node = node.Parent;
             }
 
             return null;
@@ -115,7 +114,7 @@ public abstract SyntaxNode FieldDeclaration(
             SyntaxNode type,
             Accessibility accessibility = Accessibility.NotApplicable,
             DeclarationModifiers modifiers = default,
-            SyntaxNode initializer = null);
+            SyntaxNode? initializer = null);
 
         /// <summary>
         /// Creates a field declaration matching an existing field symbol.
@@ -129,7 +128,7 @@ public SyntaxNode FieldDeclaration(IFieldSymbol field)
         /// <summary>
         /// Creates a field declaration matching an existing field symbol.
         /// </summary>
-        public SyntaxNode FieldDeclaration(IFieldSymbol field, SyntaxNode initializer)
+        public SyntaxNode FieldDeclaration(IFieldSymbol field, SyntaxNode? initializer)
         {
             return FieldDeclaration(
                 field.Name,
@@ -148,20 +147,20 @@ public SyntaxNode FieldDeclaration(IFieldSymbol field, SyntaxNode initializer)
         /// </summary>
         public abstract SyntaxNode MethodDeclaration(
             string name,
-            IEnumerable<SyntaxNode> parameters = null,
-            IEnumerable<string> typeParameters = null,
-            SyntaxNode returnType = null,
+            IEnumerable<SyntaxNode>? parameters = null,
+            IEnumerable<string>? typeParameters = null,
+            SyntaxNode? returnType = null,
             Accessibility accessibility = Accessibility.NotApplicable,
             DeclarationModifiers modifiers = default,
-            IEnumerable<SyntaxNode> statements = null);
+            IEnumerable<SyntaxNode>? statements = null);
 
         /// <summary>
         /// Creates a method declaration matching an existing method symbol.
         /// </summary>
-        public SyntaxNode MethodDeclaration(IMethodSymbol method, IEnumerable<SyntaxNode> statements = null)
+        public SyntaxNode MethodDeclaration(IMethodSymbol method, IEnumerable<SyntaxNode>? statements = null)
             => MethodDeclaration(method, method.Name, statements);
 
-        internal SyntaxNode MethodDeclaration(IMethodSymbol method, string name, IEnumerable<SyntaxNode> statements = null)
+        internal SyntaxNode MethodDeclaration(IMethodSymbol method, string name, IEnumerable<SyntaxNode>? statements = null)
         {
             var decl = MethodDeclaration(
                 name,
@@ -190,11 +189,11 @@ internal SyntaxNode MethodDeclaration(IMethodSymbol method, string name, IEnumer
         /// </summary>
         public virtual SyntaxNode OperatorDeclaration(
             OperatorKind kind,
-            IEnumerable<SyntaxNode> parameters = null,
-            SyntaxNode returnType = null,
+            IEnumerable<SyntaxNode>? parameters = null,
+            SyntaxNode? returnType = null,
             Accessibility accessibility = Accessibility.NotApplicable,
             DeclarationModifiers modifiers = default,
-            IEnumerable<SyntaxNode> statements = null)
+            IEnumerable<SyntaxNode>? statements = null)
         {
             throw new NotImplementedException();
         }
@@ -202,7 +201,7 @@ public virtual SyntaxNode OperatorDeclaration(
         /// <summary>
         /// Creates a method declaration matching an existing method symbol.
         /// </summary>
-        public SyntaxNode OperatorDeclaration(IMethodSymbol method, IEnumerable<SyntaxNode> statements = null)
+        public SyntaxNode OperatorDeclaration(IMethodSymbol method, IEnumerable<SyntaxNode>? statements = null)
         {
             if (method.MethodKind != MethodKind.UserDefinedOperator)
             {
@@ -257,14 +256,14 @@ private static OperatorKind GetOperatorKind(IMethodSymbol method)
         /// </summary>
         public abstract SyntaxNode ParameterDeclaration(
             string name,
-            SyntaxNode type = null,
-            SyntaxNode initializer = null,
+            SyntaxNode? type = null,
+            SyntaxNode? initializer = null,
             RefKind refKind = RefKind.None);
 
         /// <summary>
         /// Creates a parameter declaration matching an existing parameter symbol.
         /// </summary>
-        public SyntaxNode ParameterDeclaration(IParameterSymbol symbol, SyntaxNode initializer = null)
+        public SyntaxNode ParameterDeclaration(IParameterSymbol symbol, SyntaxNode? initializer = null)
         {
             return ParameterDeclaration(
                 symbol.Name,
@@ -291,16 +290,16 @@ public abstract SyntaxNode PropertyDeclaration(
             SyntaxNode type,
             Accessibility accessibility = Accessibility.NotApplicable,
             DeclarationModifiers modifiers = default,
-            IEnumerable<SyntaxNode> getAccessorStatements = null,
-            IEnumerable<SyntaxNode> setAccessorStatements = null);
+            IEnumerable<SyntaxNode>? getAccessorStatements = null,
+            IEnumerable<SyntaxNode>? setAccessorStatements = null);
 
         /// <summary>
         /// Creates a property declaration using an existing property symbol as a signature.
         /// </summary>
         public SyntaxNode PropertyDeclaration(
             IPropertySymbol property,
-            IEnumerable<SyntaxNode> getAccessorStatements = null,
-            IEnumerable<SyntaxNode> setAccessorStatements = null)
+            IEnumerable<SyntaxNode>? getAccessorStatements = null,
+            IEnumerable<SyntaxNode>? setAccessorStatements = null)
         {
             return PropertyDeclaration(
                     property.Name,
@@ -318,11 +317,11 @@ public SyntaxNode WithAccessorDeclarations(SyntaxNode declaration, params Syntax
 
         public abstract SyntaxNode GetAccessorDeclaration(
             Accessibility accessibility = Accessibility.NotApplicable,
-            IEnumerable<SyntaxNode> statements = null);
+            IEnumerable<SyntaxNode>? statements = null);
 
         public abstract SyntaxNode SetAccessorDeclaration(
             Accessibility accessibility = Accessibility.NotApplicable,
-            IEnumerable<SyntaxNode> statements = null);
+            IEnumerable<SyntaxNode>? statements = null);
 
         /// <summary>
         /// Creates an indexer declaration.
@@ -332,16 +331,16 @@ public abstract SyntaxNode IndexerDeclaration(
             SyntaxNode type,
             Accessibility accessibility = Accessibility.NotApplicable,
             DeclarationModifiers modifiers = default,
-            IEnumerable<SyntaxNode> getAccessorStatements = null,
-            IEnumerable<SyntaxNode> setAccessorStatements = null);
+            IEnumerable<SyntaxNode>? getAccessorStatements = null,
+            IEnumerable<SyntaxNode>? setAccessorStatements = null);
 
         /// <summary>
         /// Creates an indexer declaration matching an existing indexer symbol.
         /// </summary>
         public SyntaxNode IndexerDeclaration(
             IPropertySymbol indexer,
-            IEnumerable<SyntaxNode> getAccessorStatements = null,
-            IEnumerable<SyntaxNode> setAccessorStatements = null)
+            IEnumerable<SyntaxNode>? getAccessorStatements = null,
+            IEnumerable<SyntaxNode>? setAccessorStatements = null)
         {
             return IndexerDeclaration(
                 indexer.Parameters.Select(p => this.ParameterDeclaration(p)),
@@ -391,17 +390,17 @@ public abstract SyntaxNode CustomEventDeclaration(
             SyntaxNode type,
             Accessibility accessibility = Accessibility.NotApplicable,
             DeclarationModifiers modifiers = default,
-            IEnumerable<SyntaxNode> parameters = null,
-            IEnumerable<SyntaxNode> addAccessorStatements = null,
-            IEnumerable<SyntaxNode> removeAccessorStatements = null);
+            IEnumerable<SyntaxNode>? parameters = null,
+            IEnumerable<SyntaxNode>? addAccessorStatements = null,
+            IEnumerable<SyntaxNode>? removeAccessorStatements = null);
 
         /// <summary>
         /// Creates a custom event declaration from an existing event symbol.
         /// </summary>
         public SyntaxNode CustomEventDeclaration(
             IEventSymbol symbol,
-            IEnumerable<SyntaxNode> addAccessorStatements = null,
-            IEnumerable<SyntaxNode> removeAccessorStatements = null)
+            IEnumerable<SyntaxNode>? addAccessorStatements = null,
+            IEnumerable<SyntaxNode>? removeAccessorStatements = null)
         {
             var invoke = symbol.Type.GetMembers("Invoke").FirstOrDefault(m => m.Kind == SymbolKind.Method) as IMethodSymbol;
             var parameters = invoke?.Parameters.Select(p => this.ParameterDeclaration(p));
@@ -420,20 +419,20 @@ public SyntaxNode CustomEventDeclaration(
         /// Creates a constructor declaration.
         /// </summary>
         public abstract SyntaxNode ConstructorDeclaration(
-            string containingTypeName = null,
-            IEnumerable<SyntaxNode> parameters = null,
+            string? containingTypeName = null,
+            IEnumerable<SyntaxNode>? parameters = null,
             Accessibility accessibility = Accessibility.NotApplicable,
             DeclarationModifiers modifiers = default,
-            IEnumerable<SyntaxNode> baseConstructorArguments = null,
-            IEnumerable<SyntaxNode> statements = null);
+            IEnumerable<SyntaxNode>? baseConstructorArguments = null,
+            IEnumerable<SyntaxNode>? statements = null);
 
         /// <summary>
         /// Create a constructor declaration using 
         /// </summary>
         public SyntaxNode ConstructorDeclaration(
             IMethodSymbol constructorMethod,
-            IEnumerable<SyntaxNode> baseConstructorArguments = null,
-            IEnumerable<SyntaxNode> statements = null)
+            IEnumerable<SyntaxNode>? baseConstructorArguments = null,
+            IEnumerable<SyntaxNode>? statements = null)
         {
             return ConstructorDeclaration(
                 constructorMethod.ContainingType != null ? constructorMethod.ContainingType.Name : "New",
@@ -448,60 +447,60 @@ public SyntaxNode ConstructorDeclaration(
         /// Converts method, property and indexer declarations into public interface implementations.
         /// This is equivalent to an implicit C# interface implementation (you can access it via the interface or directly via the named member.)
         /// </summary>
-        public SyntaxNode AsPublicInterfaceImplementation(SyntaxNode declaration, SyntaxNode interfaceType)
-            => this.AsPublicInterfaceImplementation(declaration, interfaceType, null);
+        public SyntaxNode? AsPublicInterfaceImplementation(SyntaxNode declaration, SyntaxNode interfaceType)
+            => AsPublicInterfaceImplementation(declaration, interfaceType, interfaceMemberName: null);
 
         /// <summary>
         /// Converts method, property and indexer declarations into public interface implementations.
         /// This is equivalent to an implicit C# interface implementation (you can access it via the interface or directly via the named member.)
         /// </summary>
-        public abstract SyntaxNode AsPublicInterfaceImplementation(SyntaxNode declaration, SyntaxNode interfaceType, string interfaceMemberName);
+        public abstract SyntaxNode? AsPublicInterfaceImplementation(SyntaxNode declaration, SyntaxNode interfaceType, string? interfaceMemberName);
 
         /// <summary>
         /// Converts method, property and indexer declarations into private interface implementations.
         /// This is equivalent to a C# explicit interface implementation (you can declare it for access via the interface, but cannot call it directly).
         /// </summary>
-        public SyntaxNode AsPrivateInterfaceImplementation(SyntaxNode declaration, SyntaxNode interfaceType)
-            => this.AsPrivateInterfaceImplementation(declaration, interfaceType, null);
+        public SyntaxNode? AsPrivateInterfaceImplementation(SyntaxNode declaration, SyntaxNode interfaceType)
+            => AsPrivateInterfaceImplementation(declaration, interfaceType, interfaceMemberName: null);
 
         /// <summary>
         /// Converts method, property and indexer declarations into private interface implementations.
         /// This is equivalent to a C# explicit interface implementation (you can declare it for access via the interface, but cannot call it directly).
         /// </summary>
-        public abstract SyntaxNode AsPrivateInterfaceImplementation(SyntaxNode declaration, SyntaxNode interfaceType, string interfaceMemberName);
+        public abstract SyntaxNode? AsPrivateInterfaceImplementation(SyntaxNode declaration, SyntaxNode interfaceType, string? interfaceMemberName);
 
         /// <summary>
         /// Creates a class declaration.
         /// </summary>
         public abstract SyntaxNode ClassDeclaration(
             string name,
-            IEnumerable<string> typeParameters = null,
+            IEnumerable<string>? typeParameters = null,
             Accessibility accessibility = Accessibility.NotApplicable,
             DeclarationModifiers modifiers = default,
-            SyntaxNode baseType = null,
-            IEnumerable<SyntaxNode> interfaceTypes = null,
-            IEnumerable<SyntaxNode> members = null);
+            SyntaxNode? baseType = null,
+            IEnumerable<SyntaxNode>? interfaceTypes = null,
+            IEnumerable<SyntaxNode>? members = null);
 
         /// <summary>
         /// Creates a struct declaration.
         /// </summary>
         public abstract SyntaxNode StructDeclaration(
             string name,
-            IEnumerable<string> typeParameters = null,
+            IEnumerable<string>? typeParameters = null,
             Accessibility accessibility = Accessibility.NotApplicable,
             DeclarationModifiers modifiers = default,
-            IEnumerable<SyntaxNode> interfaceTypes = null,
-            IEnumerable<SyntaxNode> members = null);
+            IEnumerable<SyntaxNode>? interfaceTypes = null,
+            IEnumerable<SyntaxNode>? members = null);
 
         /// <summary>
         /// Creates a interface declaration.
         /// </summary>
         public abstract SyntaxNode InterfaceDeclaration(
             string name,
-            IEnumerable<string> typeParameters = null,
+            IEnumerable<string>? typeParameters = null,
             Accessibility accessibility = Accessibility.NotApplicable,
-            IEnumerable<SyntaxNode> interfaceTypes = null,
-            IEnumerable<SyntaxNode> members = null);
+            IEnumerable<SyntaxNode>? interfaceTypes = null,
+            IEnumerable<SyntaxNode>? members = null);
 
         /// <summary>
         /// Creates an enum declaration.
@@ -510,31 +509,31 @@ public abstract SyntaxNode EnumDeclaration(
             string name,
             Accessibility accessibility = Accessibility.NotApplicable,
             DeclarationModifiers modifiers = default,
-            IEnumerable<SyntaxNode> members = null);
+            IEnumerable<SyntaxNode>? members = null);
 
         /// <summary>
         /// Creates an enum declaration
         /// </summary>
         internal abstract SyntaxNode EnumDeclaration(
             string name,
-            SyntaxNode underlyingType,
+            SyntaxNode? underlyingType,
             Accessibility accessibility = Accessibility.NotApplicable,
             DeclarationModifiers modifiers = default,
-            IEnumerable<SyntaxNode> members = null);
+            IEnumerable<SyntaxNode>? members = null);
 
         /// <summary>
         /// Creates an enum member
         /// </summary>
-        public abstract SyntaxNode EnumMember(string name, SyntaxNode expression = null);
+        public abstract SyntaxNode EnumMember(string name, SyntaxNode? expression = null);
 
         /// <summary>
         /// Creates a delegate declaration.
         /// </summary>
         public abstract SyntaxNode DelegateDeclaration(
             string name,
-            IEnumerable<SyntaxNode> parameters = null,
-            IEnumerable<string> typeParameters = null,
-            SyntaxNode returnType = null,
+            IEnumerable<SyntaxNode>? parameters = null,
+            IEnumerable<string>? typeParameters = null,
+            SyntaxNode? returnType = null,
             Accessibility accessibility = Accessibility.NotApplicable,
             DeclarationModifiers modifiers = default);
 
@@ -585,7 +584,7 @@ public SyntaxNode Declaration(ISymbol symbol)
 
                 case SymbolKind.NamedType:
                     var type = (INamedTypeSymbol)symbol;
-                    SyntaxNode declaration = null;
+                    SyntaxNode? declaration = null;
 
                     switch (type.TypeKind)
                     {
@@ -594,7 +593,7 @@ public SyntaxNode Declaration(ISymbol symbol)
                                 type.Name,
                                 accessibility: type.DeclaredAccessibility,
                                 modifiers: DeclarationModifiers.From(type),
-                                baseType: TypeExpression(type.BaseType),
+                                baseType: (type.BaseType != null) ? TypeExpression(type.BaseType) : null,
                                 interfaceTypes: type.Interfaces.Select(i => TypeExpression(i)),
                                 members: type.GetMembers().Where(CanBeDeclared).Select(m => Declaration(m)));
                             break;
@@ -616,19 +615,22 @@ public SyntaxNode Declaration(ISymbol symbol)
                         case TypeKind.Enum:
                             declaration = EnumDeclaration(
                                 type.Name,
-                                type.EnumUnderlyingType?.SpecialType == SpecialType.System_Int32 ? null : TypeExpression(type.EnumUnderlyingType.SpecialType),
+                                underlyingType: (type.EnumUnderlyingType == null || type.EnumUnderlyingType.SpecialType == SpecialType.System_Int32) ? null : TypeExpression(type.EnumUnderlyingType.SpecialType),
                                 accessibility: type.DeclaredAccessibility,
                                 members: type.GetMembers().Where(s => s.Kind == SymbolKind.Field).Select(m => Declaration(m)));
                             break;
                         case TypeKind.Delegate:
                             var invoke = type.GetMembers("Invoke").First() as IMethodSymbol;
+                            if (invoke != null)
+                            {
+                                declaration = DelegateDeclaration(
+                                    type.Name,
+                                    parameters: invoke.Parameters.Select(p => ParameterDeclaration(p)),
+                                    returnType: TypeExpression(invoke.ReturnType),
+                                    accessibility: type.DeclaredAccessibility,
+                                    modifiers: DeclarationModifiers.From(type));
+                            }
 
-                            declaration = DelegateDeclaration(
-                                type.Name,
-                                parameters: invoke.Parameters.Select(p => ParameterDeclaration(p)),
-                                returnType: TypeExpression(invoke.ReturnType),
-                                accessibility: type.DeclaredAccessibility,
-                                modifiers: DeclarationModifiers.From(type));
                             break;
                     }
 
@@ -721,7 +723,7 @@ public SyntaxNode WithTypeParameters(SyntaxNode declaration, params string[] typ
         /// <summary>
         /// Adds a type constraint to a type parameter of a declaration.
         /// </summary>
-        public abstract SyntaxNode WithTypeConstraint(SyntaxNode declaration, string typeParameterName, SpecialTypeConstraintKind kinds, IEnumerable<SyntaxNode> types = null);
+        public abstract SyntaxNode WithTypeConstraint(SyntaxNode declaration, string typeParameterName, SpecialTypeConstraintKind kinds, IEnumerable<SyntaxNode>? types = null);
 
         /// <summary>
         /// Adds a type constraint to a type parameter of a declaration.
@@ -810,12 +812,12 @@ public SyntaxNode AliasImportDeclaration(string aliasIdentifierName, INamespaceO
         /// <summary>
         /// Creates an attribute.
         /// </summary>
-        public abstract SyntaxNode Attribute(SyntaxNode name, IEnumerable<SyntaxNode> attributeArguments = null);
+        public abstract SyntaxNode Attribute(SyntaxNode name, IEnumerable<SyntaxNode>? attributeArguments = null);
 
         /// <summary>
         /// Creates an attribute.
         /// </summary>
-        public SyntaxNode Attribute(string name, IEnumerable<SyntaxNode> attributeArguments = null)
+        public SyntaxNode Attribute(string name, IEnumerable<SyntaxNode>? attributeArguments = null)
             => Attribute(DottedName(name), attributeArguments);
 
         /// <summary>
@@ -829,6 +831,8 @@ public SyntaxNode Attribute(string name, params SyntaxNode[] attributeArguments)
         /// </summary>
         public SyntaxNode Attribute(AttributeData attribute)
         {
+            Contract.ThrowIfNull(attribute.AttributeClass);
+
             var args = attribute.ConstructorArguments.Select(a => this.AttributeArgument(this.TypedConstantExpression(a)))
                     .Concat(attribute.NamedArguments.Select(n => this.AttributeArgument(n.Key, this.TypedConstantExpression(n.Value))))
                     .ToBoxedImmutableArray();
@@ -841,19 +845,19 @@ public SyntaxNode Attribute(AttributeData attribute)
         /// <summary>
         /// Creates an attribute argument.
         /// </summary>
-        public abstract SyntaxNode AttributeArgument(string name, SyntaxNode expression);
+        public abstract SyntaxNode AttributeArgument(string? name, SyntaxNode expression);
 
         /// <summary>
         /// Creates an attribute argument.
         /// </summary>
         public SyntaxNode AttributeArgument(SyntaxNode expression)
-            => AttributeArgument(null, expression);
+            => AttributeArgument(name: null, expression);
 
         /// <summary>
         /// Removes all attributes from the declaration, including return attributes.
         /// </summary>
         public SyntaxNode RemoveAllAttributes(SyntaxNode declaration)
-            => this.RemoveNodes(declaration, this.GetAttributes(declaration).Concat(this.GetReturnAttributes(declaration)));
+            => RemoveNodes(declaration, GetAttributes(declaration).Concat(GetReturnAttributes(declaration)));
 
         /// <summary>
         /// Removes comments from leading and trailing trivia, as well
@@ -878,7 +882,7 @@ internal SyntaxToken RemoveLeadingAndTrailingComments(SyntaxToken token)
         internal abstract bool IsRegularOrDocComment(SyntaxTrivia trivia);
 
         internal SyntaxNode RemoveAllTypeInheritance(SyntaxNode declaration)
-            => this.RemoveNodes(declaration, this.GetTypeInheritance(declaration));
+            => RemoveNodes(declaration, GetTypeInheritance(declaration));
 
         internal abstract ImmutableArray<SyntaxNode> GetTypeInheritance(SyntaxNode declaration);
 
@@ -1048,7 +1052,7 @@ public SyntaxNode AddMembers(SyntaxNode declaration, params SyntaxNode[] members
         /// <summary>
         /// Gets the type of the declaration.
         /// </summary>
-        public abstract SyntaxNode GetType(SyntaxNode declaration);
+        public abstract SyntaxNode? GetType(SyntaxNode declaration);
 
         /// <summary>
         /// Changes the type of the declaration.
@@ -1060,7 +1064,7 @@ public SyntaxNode AddMembers(SyntaxNode declaration, params SyntaxNode[] members
         /// </summary>
         public abstract IReadOnlyList<SyntaxNode> GetParameters(SyntaxNode declaration);
 
-        internal abstract SyntaxNode GetParameterListNode(SyntaxNode declaration);
+        internal abstract SyntaxNode? GetParameterListNode(SyntaxNode declaration);
 
         /// <summary>
         /// Inserts the parameters at the specified index into the declaration.
@@ -1092,7 +1096,7 @@ public SyntaxNode AddSwitchSections(SyntaxNode switchStatement, IEnumerable<Synt
         /// <summary>
         /// Gets the expression associated with the declaration.
         /// </summary>
-        public abstract SyntaxNode GetExpression(SyntaxNode declaration);
+        public abstract SyntaxNode? GetExpression(SyntaxNode declaration);
 
         /// <summary>
         /// Changes the expression associated with the declaration.
@@ -1171,23 +1175,18 @@ public SyntaxNode AddAccessors(SyntaxNode declaration, IEnumerable<SyntaxNode> a
         #endregion
 
         #region Remove, Replace, Insert
+
         /// <summary>
         /// Replaces the node in the root's tree with the new node.
         /// </summary>
-        public virtual SyntaxNode ReplaceNode(SyntaxNode root, SyntaxNode node, SyntaxNode newDeclaration)
-        {
-            if (newDeclaration != null)
-            {
-                return root.ReplaceNode(node, newDeclaration);
-            }
-            else
-            {
-                return this.RemoveNode(root, node);
-            }
-        }
+        public virtual SyntaxNode ReplaceNode(SyntaxNode root, SyntaxNode node, SyntaxNode? newDeclaration)
+            => (newDeclaration != null) ? root.ReplaceNode(node, newDeclaration) : RemoveNode(root, node);
 
         internal static SyntaxNode ReplaceNode(SyntaxNode root, SyntaxNode node, IEnumerable<SyntaxNode> newDeclarations)
-            => root.ReplaceNode(node, newDeclarations);
+        {
+            Contract.ThrowIfTrue(ReferenceEquals(root, node));
+            return root.ReplaceNode(node, newDeclarations);
+        }
 
         /// <summary>
         /// Inserts the new node before the specified declaration.
@@ -1211,7 +1210,7 @@ public virtual SyntaxNode RemoveNode(SyntaxNode root, SyntaxNode node)
         /// Removes the node from the sub tree starting at the root.
         /// </summary>
         public virtual SyntaxNode RemoveNode(SyntaxNode root, SyntaxNode node, SyntaxRemoveOptions options)
-            => root.RemoveNode(node, options);
+            => root.RemoveNode(node, options) ?? throw new InvalidOperationException($"Can't remove root node.");
 
         /// <summary>
         /// Removes all the declarations from the sub tree starting at the root.
@@ -1220,13 +1219,20 @@ public SyntaxNode RemoveNodes(SyntaxNode root, IEnumerable<SyntaxNode> declarati
         {
             var newRoot = root.TrackNodes(declarations);
 
-            foreach (var decl in declarations)
+            foreach (var declaration in declarations)
             {
-                newRoot = this.RemoveNode(newRoot, newRoot.GetCurrentNode(decl));
+                var newDeclaration = newRoot.GetCurrentNode(declaration);
+                if (newDeclaration == null)
+                {
+                    continue;
+                }
+
+                newRoot = RemoveNode(newRoot, newDeclaration);
             }
 
             return newRoot;
         }
+
         #endregion
 
         #region Utility
@@ -1257,7 +1263,8 @@ private static bool Any(SyntaxTokenList original, int rawKind)
             return false;
         }
 
-        protected static SyntaxNode PreserveTrivia<TNode>(TNode node, Func<TNode, SyntaxNode> nodeChanger) where TNode : SyntaxNode
+        [return: NotNullIfNotNull("node")]
+        protected static SyntaxNode? PreserveTrivia<TNode>(TNode? node, Func<TNode, SyntaxNode> nodeChanger) where TNode : SyntaxNode
         {
             if (node == null)
             {
@@ -1267,17 +1274,14 @@ protected static SyntaxNode PreserveTrivia<TNode>(TNode node, Func<TNode, Syntax
             var nodeWithoutTrivia = node.WithoutLeadingTrivia().WithoutTrailingTrivia();
 
             var changedNode = nodeChanger(nodeWithoutTrivia);
-
             if (changedNode == nodeWithoutTrivia)
             {
                 return node;
             }
-            else
-            {
-                return changedNode
-                    .WithLeadingTrivia(node.GetLeadingTrivia().Concat(changedNode.GetLeadingTrivia()))
-                    .WithTrailingTrivia(changedNode.GetTrailingTrivia().Concat(node.GetTrailingTrivia()));
-            }
+
+            return changedNode
+                .WithLeadingTrivia(node.GetLeadingTrivia().Concat(changedNode.GetLeadingTrivia()))
+                .WithTrailingTrivia(changedNode.GetTrailingTrivia().Concat(node.GetTrailingTrivia()));
         }
 
         protected static SyntaxNode ReplaceWithTrivia(SyntaxNode root, SyntaxNode original, SyntaxNode replacement)
@@ -1307,7 +1311,8 @@ protected static SyntaxNode ReplaceWithTrivia(SyntaxNode root, SyntaxToken origi
         /// <summary>
         /// Creates a new instance of the node with the leading and trailing trivia removed and replaced with elastic markers.
         /// </summary>
-        public abstract TNode ClearTrivia<TNode>(TNode node) where TNode : SyntaxNode;
+        [return: MaybeNull, NotNullIfNotNull("node")]
+        public abstract TNode ClearTrivia<TNode>([MaybeNull] TNode node) where TNode : SyntaxNode;
 
 #pragma warning disable CA1822 // Mark members as static - shipped public API
         protected int IndexOf<T>(IReadOnlyList<T> list, T element)
@@ -1330,6 +1335,8 @@ protected static SyntaxNode ReplaceRange(SyntaxNode root, SyntaxNode node, IEnum
             var trackedFirst = first.TrackNodes(first);
             var newRoot = root.ReplaceNode(node, trackedFirst);
             var currentFirst = newRoot.GetCurrentNode(first);
+            Contract.ThrowIfNull(currentFirst);
+
             return newRoot.InsertNodesAfter(currentFirst, replacements.Skip(1));
         }
 
@@ -1369,7 +1376,7 @@ protected static SyntaxList<TNode> RemoveRange<TNode>(SyntaxList<TNode> list, in
         /// Creates a statement that can be used to return a value from a method body.
         /// </summary>
         /// <param name="expression">An optional expression that can be returned.</param>
-        public abstract SyntaxNode ReturnStatement(SyntaxNode expression = null);
+        public abstract SyntaxNode ReturnStatement(SyntaxNode? expression = null);
 
         /// <summary>
         /// Creates a statement that can be used to yield a value from an iterator method.
@@ -1382,7 +1389,7 @@ internal SyntaxNode YieldReturnStatement(SyntaxNode expression)
         /// Creates a statement that can be used to throw an exception.
         /// </summary>
         /// <param name="expression">An optional expression that can be thrown.</param>
-        public abstract SyntaxNode ThrowStatement(SyntaxNode expression = null);
+        public abstract SyntaxNode ThrowStatement(SyntaxNode? expression = null);
 
         /// <summary>
         /// Creates an expression that can be used to throw an exception.
@@ -1406,35 +1413,34 @@ internal SyntaxNode YieldReturnStatement(SyntaxNode expression)
         /// Creates a statement that declares a single local variable.
         /// </summary>
         public abstract SyntaxNode LocalDeclarationStatement(
-            SyntaxNode type, string identifier, SyntaxNode initializer = null, bool isConst = false);
+            SyntaxNode? type, string identifier, SyntaxNode? initializer = null, bool isConst = false);
 
-        internal SyntaxNode LocalDeclarationStatement(
-            SyntaxNode type, SyntaxToken identifier, SyntaxNode initializer = null, bool isConst = false)
+        internal SyntaxNode LocalDeclarationStatement(SyntaxNode? type, SyntaxToken identifier, SyntaxNode? initializer = null, bool isConst = false)
             => SyntaxGeneratorInternal.LocalDeclarationStatement(type, identifier, initializer, isConst);
 
         internal SyntaxNode WithInitializer(SyntaxNode variableDeclarator, SyntaxNode initializer)
             => SyntaxGeneratorInternal.WithInitializer(variableDeclarator, initializer);
+
         internal SyntaxNode EqualsValueClause(SyntaxToken operatorToken, SyntaxNode value)
             => SyntaxGeneratorInternal.EqualsValueClause(operatorToken, value);
 
         /// <summary>
         /// Creates a statement that declares a single local variable.
         /// </summary>
-        public SyntaxNode LocalDeclarationStatement(
-            ITypeSymbol type, string name, SyntaxNode initializer = null, bool isConst = false)
-                => LocalDeclarationStatement(TypeExpression(type), name, initializer, isConst);
+        public SyntaxNode LocalDeclarationStatement(ITypeSymbol type, string name, SyntaxNode? initializer = null, bool isConst = false)
+            => LocalDeclarationStatement(TypeExpression(type), name, initializer, isConst);
 
         /// <summary>
         /// Creates a statement that declares a single local variable.
         /// </summary>
         public SyntaxNode LocalDeclarationStatement(string name, SyntaxNode initializer)
-            => LocalDeclarationStatement((SyntaxNode)null, name, initializer);
+            => LocalDeclarationStatement(type: (SyntaxNode?)null, name, initializer);
 
         /// <summary>
         /// Creates a statement that declares a single local variable.
         /// </summary>
         internal SyntaxNode LocalDeclarationStatement(SyntaxToken name, SyntaxNode initializer)
-            => LocalDeclarationStatement(null, name, initializer);
+            => LocalDeclarationStatement(type: null, name, initializer);
 
         /// <summary>
         /// Creates an if-statement
@@ -1443,7 +1449,7 @@ internal SyntaxNode LocalDeclarationStatement(SyntaxToken name, SyntaxNode initi
         /// <param name="trueStatements">The statements that are executed if the condition is true.</param>
         /// <param name="falseStatements">The statements that are executed if the condition is false.</param>
         public abstract SyntaxNode IfStatement(
-            SyntaxNode condition, IEnumerable<SyntaxNode> trueStatements, IEnumerable<SyntaxNode> falseStatements = null);
+            SyntaxNode condition, IEnumerable<SyntaxNode> trueStatements, IEnumerable<SyntaxNode>? falseStatements = null);
 
         /// <summary>
         /// Creates an if statement
@@ -1491,13 +1497,13 @@ public SyntaxNode SwitchSection(SyntaxNode caseExpression, IEnumerable<SyntaxNod
         /// <summary>
         /// Creates a statement that represents a using-block pattern.
         /// </summary>
-        public abstract SyntaxNode UsingStatement(SyntaxNode type, string name, SyntaxNode expression, IEnumerable<SyntaxNode> statements);
+        public abstract SyntaxNode UsingStatement(SyntaxNode? type, string name, SyntaxNode expression, IEnumerable<SyntaxNode> statements);
 
         /// <summary>
         /// Creates a statement that represents a using-block pattern.
         /// </summary>
         public SyntaxNode UsingStatement(string name, SyntaxNode expression, IEnumerable<SyntaxNode> statements)
-            => UsingStatement(null, name, expression, statements);
+            => UsingStatement(type: null, name, expression, statements);
 
         /// <summary>
         /// Creates a statement that represents a using-block pattern.
@@ -1512,13 +1518,13 @@ public SyntaxNode UsingStatement(string name, SyntaxNode expression, IEnumerable
         /// <summary>
         /// Creates a try-catch or try-catch-finally statement.
         /// </summary>
-        public abstract SyntaxNode TryCatchStatement(IEnumerable<SyntaxNode> tryStatements, IEnumerable<SyntaxNode> catchClauses, IEnumerable<SyntaxNode> finallyStatements = null);
+        public abstract SyntaxNode TryCatchStatement(IEnumerable<SyntaxNode> tryStatements, IEnumerable<SyntaxNode>? catchClauses, IEnumerable<SyntaxNode>? finallyStatements = null);
 
         /// <summary>
         /// Creates a try-catch or try-catch-finally statement.
         /// </summary>
         public SyntaxNode TryCatchStatement(IEnumerable<SyntaxNode> tryStatements, params SyntaxNode[] catchClauses)
-            => TryCatchStatement(tryStatements, (IEnumerable<SyntaxNode>)catchClauses);
+            => TryCatchStatement(tryStatements, (IEnumerable<SyntaxNode>?)catchClauses);
 
         /// <summary>
         /// Creates a try-finally statement.
@@ -1586,7 +1592,7 @@ internal SyntaxNode InterpolationFormatClause(string format)
         /// <summary>
         /// Creates a literal expression. This is typically numeric primitives, strings or chars.
         /// </summary>
-        public abstract SyntaxNode LiteralExpression(object value);
+        public abstract SyntaxNode LiteralExpression(object? value);
 
         /// <summary>
         /// Creates an expression for a typed constant.
@@ -1609,7 +1615,7 @@ public SyntaxNode TrueLiteralExpression()
         /// Creates an expression that denotes the null literal.
         /// </summary>
         public SyntaxNode NullLiteralExpression()
-            => LiteralExpression(null);
+            => LiteralExpression(value: null);
 
         /// <summary>
         /// Creates an expression that denotes a simple identifier name.
@@ -1683,8 +1689,9 @@ public SyntaxNode DottedName(string dottedName)
             }
 
             var parts = dottedName.Split(s_dotSeparator);
+            Debug.Assert(!parts.IsEmpty());
 
-            SyntaxNode name = null;
+            SyntaxNode? name = null;
             foreach (var part in parts)
             {
                 if (name == null)
@@ -1693,10 +1700,11 @@ public SyntaxNode DottedName(string dottedName)
                 }
                 else
                 {
-                    name = QualifiedName(name, IdentifierName(part)).WithAdditionalAnnotations(Simplification.Simplifier.Annotation);
+                    name = QualifiedName(name, IdentifierName(part)).WithAdditionalAnnotations(Simplifier.Annotation);
                 }
             }
 
+            Contract.ThrowIfNull(name);
             return name;
         }
 
@@ -1771,7 +1779,7 @@ public SyntaxNode TupleTypeExpression(params SyntaxNode[] elements)
         /// <summary>
         /// Creates an expression that denotes a tuple type.
         /// </summary>
-        public SyntaxNode TupleTypeExpression(IEnumerable<ITypeSymbol> elementTypes, IEnumerable<string> elementNames = null)
+        public SyntaxNode TupleTypeExpression(IEnumerable<ITypeSymbol> elementTypes, IEnumerable<string>? elementNames = null)
         {
             if (elementTypes == null)
             {
@@ -1795,12 +1803,12 @@ public SyntaxNode TupleTypeExpression(IEnumerable<ITypeSymbol> elementTypes, IEn
         /// <summary>
         /// Creates an expression that denotes a tuple element.
         /// </summary>
-        public abstract SyntaxNode TupleElementExpression(SyntaxNode type, string name = null);
+        public abstract SyntaxNode TupleElementExpression(SyntaxNode type, string? name = null);
 
         /// <summary>
         /// Creates an expression that denotes a tuple element.
         /// </summary>
-        public SyntaxNode TupleElementExpression(ITypeSymbol type, string name = null)
+        public SyntaxNode TupleElementExpression(ITypeSymbol type, string? name = null)
             => TupleElementExpression(TypeExpression(type), name);
 #pragma warning restore RS0026 // Do not add multiple public overloads with optional parameters
 
@@ -1946,13 +1954,13 @@ public SyntaxNode ElementBindingExpression(params SyntaxNode[] arguments)
         /// <summary>
         /// Creates a member access expression.
         /// </summary>
-        public virtual SyntaxNode MemberAccessExpression(SyntaxNode expression, SyntaxNode memberName)
+        public virtual SyntaxNode MemberAccessExpression(SyntaxNode? expression, SyntaxNode memberName)
         {
             return MemberAccessExpressionWorker(expression, memberName)
-                .WithAdditionalAnnotations(Simplification.Simplifier.Annotation);
+                .WithAdditionalAnnotations(Simplifier.Annotation);
         }
 
-        internal abstract SyntaxNode MemberAccessExpressionWorker(SyntaxNode expression, SyntaxNode memberName);
+        internal abstract SyntaxNode MemberAccessExpressionWorker(SyntaxNode? expression, SyntaxNode memberName);
 
         internal SyntaxNode RefExpression(SyntaxNode expression)
             => SyntaxGeneratorInternal.RefExpression(expression);
@@ -1960,7 +1968,7 @@ internal SyntaxNode RefExpression(SyntaxNode expression)
         /// <summary>
         /// Creates a member access expression.
         /// </summary>
-        public SyntaxNode MemberAccessExpression(SyntaxNode expression, string memberName)
+        public SyntaxNode MemberAccessExpression(SyntaxNode? expression, string memberName)
             => MemberAccessExpression(expression, IdentifierName(memberName));
 
         /// <summary>
@@ -2013,19 +2021,19 @@ public SyntaxNode InvocationExpression(SyntaxNode expression, params SyntaxNode[
         /// <summary>
         /// Creates a node that is an argument to an invocation.
         /// </summary>
-        public abstract SyntaxNode Argument(string name, RefKind refKind, SyntaxNode expression);
+        public abstract SyntaxNode Argument(string? name, RefKind refKind, SyntaxNode expression);
 
         /// <summary>
         /// Creates a node that is an argument to an invocation.
         /// </summary>
         public SyntaxNode Argument(RefKind refKind, SyntaxNode expression)
-            => Argument(null, refKind, expression);
+            => Argument(name: null, refKind, expression);
 
         /// <summary>
         /// Creates a node that is an argument to an invocation.
         /// </summary>
         public SyntaxNode Argument(SyntaxNode expression)
-            => Argument(null, RefKind.None, expression);
+            => Argument(name: null, RefKind.None, expression);
 
         /// <summary>
         /// Creates an expression that access an element of an array or indexer.
@@ -2090,22 +2098,22 @@ public SyntaxNode ConvertExpression(ITypeSymbol type, SyntaxNode expression)
         /// <summary>
         /// Creates an expression that declares a value returning lambda expression.
         /// </summary>
-        public abstract SyntaxNode ValueReturningLambdaExpression(IEnumerable<SyntaxNode> lambdaParameters, SyntaxNode expression);
+        public abstract SyntaxNode ValueReturningLambdaExpression(IEnumerable<SyntaxNode>? lambdaParameters, SyntaxNode expression);
 
         /// <summary>
         /// Creates an expression that declares a void returning lambda expression
         /// </summary>
-        public abstract SyntaxNode VoidReturningLambdaExpression(IEnumerable<SyntaxNode> lambdaParameters, SyntaxNode expression);
+        public abstract SyntaxNode VoidReturningLambdaExpression(IEnumerable<SyntaxNode>? lambdaParameters, SyntaxNode expression);
 
         /// <summary>
         /// Creates an expression that declares a value returning lambda expression.
         /// </summary>
-        public abstract SyntaxNode ValueReturningLambdaExpression(IEnumerable<SyntaxNode> lambdaParameters, IEnumerable<SyntaxNode> statements);
+        public abstract SyntaxNode ValueReturningLambdaExpression(IEnumerable<SyntaxNode>? lambdaParameters, IEnumerable<SyntaxNode> statements);
 
         /// <summary>
         /// Creates an expression that declares a void returning lambda expression.
         /// </summary>
-        public abstract SyntaxNode VoidReturningLambdaExpression(IEnumerable<SyntaxNode> lambdaParameters, IEnumerable<SyntaxNode> statements);
+        public abstract SyntaxNode VoidReturningLambdaExpression(IEnumerable<SyntaxNode>? lambdaParameters, IEnumerable<SyntaxNode> statements);
 
         /// <summary>
         /// Creates an expression that declares a single parameter value returning lambda expression.
@@ -2135,30 +2143,30 @@ public SyntaxNode VoidReturningLambdaExpression(string parameterName, IEnumerabl
         /// Creates an expression that declares a zero parameter value returning lambda expression.
         /// </summary>
         public SyntaxNode ValueReturningLambdaExpression(SyntaxNode expression)
-            => ValueReturningLambdaExpression((IEnumerable<SyntaxNode>)null, expression);
+            => ValueReturningLambdaExpression((IEnumerable<SyntaxNode>?)null, expression);
 
         /// <summary>
         /// Creates an expression that declares a zero parameter void returning lambda expression.
         /// </summary>
         public SyntaxNode VoidReturningLambdaExpression(SyntaxNode expression)
-            => VoidReturningLambdaExpression((IEnumerable<SyntaxNode>)null, expression);
+            => VoidReturningLambdaExpression((IEnumerable<SyntaxNode>?)null, expression);
 
         /// <summary>
         /// Creates an expression that declares a zero parameter value returning lambda expression.
         /// </summary>
         public SyntaxNode ValueReturningLambdaExpression(IEnumerable<SyntaxNode> statements)
-            => ValueReturningLambdaExpression((IEnumerable<SyntaxNode>)null, statements);
+            => ValueReturningLambdaExpression((IEnumerable<SyntaxNode>?)null, statements);
 
         /// <summary>
         /// Creates an expression that declares a zero parameter void returning lambda expression.
         /// </summary>
         public SyntaxNode VoidReturningLambdaExpression(IEnumerable<SyntaxNode> statements)
-            => VoidReturningLambdaExpression((IEnumerable<SyntaxNode>)null, statements);
+            => VoidReturningLambdaExpression((IEnumerable<SyntaxNode>?)null, statements);
 
         /// <summary>
         /// Creates a lambda parameter.
         /// </summary>
-        public abstract SyntaxNode LambdaParameter(string identifier, SyntaxNode type = null);
+        public abstract SyntaxNode LambdaParameter(string identifier, SyntaxNode? type = null);
 
         /// <summary>
         /// Creates a lambda parameter.
@@ -2196,7 +2204,7 @@ internal SyntaxNode AddParentheses(SyntaxNode expression, bool includeElasticTri
 
         internal abstract SyntaxNode DocumentationCommentTrivia(IEnumerable<SyntaxNode> nodes, SyntaxTriviaList trailingTrivia, string endOfLineString);
 
-        internal abstract SyntaxNode DocumentationCommentTriviaWithUpdatedContent(SyntaxTrivia trivia, IEnumerable<SyntaxNode> content);
+        internal abstract SyntaxNode? DocumentationCommentTriviaWithUpdatedContent(SyntaxTrivia trivia, IEnumerable<SyntaxNode> content);
 
         #endregion
     }
diff --git a/src/Workspaces/Core/Portable/PublicAPI.Unshipped.txt b/src/Workspaces/Core/Portable/PublicAPI.Unshipped.txt
index 9bc1ad109c553..99a8a7edeabe6 100644
--- a/src/Workspaces/Core/Portable/PublicAPI.Unshipped.txt
+++ b/src/Workspaces/Core/Portable/PublicAPI.Unshipped.txt
@@ -4,6 +4,7 @@ const Microsoft.CodeAnalysis.Classification.ClassificationTypeNames.RecordStruct
 Microsoft.CodeAnalysis.CodeFixes.DocumentBasedFixAllProvider
 Microsoft.CodeAnalysis.CodeFixes.DocumentBasedFixAllProvider.DocumentBasedFixAllProvider() -> void
 Microsoft.CodeAnalysis.CommandLineProject
+Microsoft.CodeAnalysis.Editing.SyntaxEditor.SyntaxEditor(Microsoft.CodeAnalysis.SyntaxNode root, Microsoft.CodeAnalysis.Host.HostWorkspaceServices services) -> void
 Microsoft.CodeAnalysis.Project.GetSourceGeneratedDocumentAsync(Microsoft.CodeAnalysis.DocumentId documentId, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<Microsoft.CodeAnalysis.SourceGeneratedDocument>
 Microsoft.CodeAnalysis.Project.GetSourceGeneratedDocumentsAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask<System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SourceGeneratedDocument>>
 Microsoft.CodeAnalysis.Editing.DeclarationKind.RecordClass = 29 -> Microsoft.CodeAnalysis.Editing.DeclarationKind
@@ -14,5 +15,7 @@ override sealed Microsoft.CodeAnalysis.CodeFixes.DocumentBasedFixAllProvider.Get
 override sealed Microsoft.CodeAnalysis.CodeFixes.DocumentBasedFixAllProvider.GetSupportedFixAllScopes() -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.CodeFixes.FixAllScope>
 static Microsoft.CodeAnalysis.CommandLineProject.CreateProjectInfo(string projectName, string language, string commandLine, string baseDirectory, Microsoft.CodeAnalysis.Workspace workspace = null) -> Microsoft.CodeAnalysis.ProjectInfo
 static Microsoft.CodeAnalysis.CommandLineProject.CreateProjectInfo(string projectName, string language, System.Collections.Generic.IEnumerable<string> commandLineArgs, string projectDirectory, Microsoft.CodeAnalysis.Workspace workspace = null) -> Microsoft.CodeAnalysis.ProjectInfo
+*REMOVED*static Microsoft.CodeAnalysis.Editing.SyntaxGenerator.DefaultRemoveOptions -> Microsoft.CodeAnalysis.SyntaxRemoveOptions
+static readonly Microsoft.CodeAnalysis.Editing.SyntaxGenerator.DefaultRemoveOptions -> Microsoft.CodeAnalysis.SyntaxRemoveOptions
 virtual Microsoft.CodeAnalysis.CodeFixes.DocumentBasedFixAllProvider.GetFixAllTitle(Microsoft.CodeAnalysis.CodeFixes.FixAllContext fixAllContext) -> string
 static Microsoft.CodeAnalysis.CodeFixes.FixAllProvider.Create(System.Func<Microsoft.CodeAnalysis.CodeFixes.FixAllContext, Microsoft.CodeAnalysis.Document, System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Diagnostic>, System.Threading.Tasks.Task<Microsoft.CodeAnalysis.Document>> fixAllAsync) -> Microsoft.CodeAnalysis.CodeFixes.FixAllProvider
diff --git a/src/Workspaces/Core/Portable/Simplification/Simplifier.cs b/src/Workspaces/Core/Portable/Simplification/Simplifier.cs
index 29511cf30df63..e26c903fa565e 100644
--- a/src/Workspaces/Core/Portable/Simplification/Simplifier.cs
+++ b/src/Workspaces/Core/Portable/Simplification/Simplifier.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
@@ -11,6 +9,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
@@ -60,7 +59,7 @@ public static partial class Simplifier
         /// <summary>
         /// Expand qualifying parts of the specified subtree, annotating the parts using the <see cref="Annotation" /> annotation.
         /// </summary>
-        public static async Task<TNode> ExpandAsync<TNode>(TNode node, Document document, Func<SyntaxNode, bool> expandInsideNode = null, bool expandParameter = false, CancellationToken cancellationToken = default) where TNode : SyntaxNode
+        public static async Task<TNode> ExpandAsync<TNode>(TNode node, Document document, Func<SyntaxNode, bool>? expandInsideNode = null, bool expandParameter = false, CancellationToken cancellationToken = default) where TNode : SyntaxNode
         {
             if (node == null)
             {
@@ -72,14 +71,14 @@ public static async Task<TNode> ExpandAsync<TNode>(TNode node, Document document
                 throw new ArgumentNullException(nameof(document));
             }
 
-            var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
             return Expand(node, semanticModel, document.Project.Solution.Workspace, expandInsideNode, expandParameter, cancellationToken);
         }
 
         /// <summary>
         /// Expand qualifying parts of the specified subtree, annotating the parts using the <see cref="Annotation" /> annotation.
         /// </summary>
-        public static TNode Expand<TNode>(TNode node, SemanticModel semanticModel, Workspace workspace, Func<SyntaxNode, bool> expandInsideNode = null, bool expandParameter = false, CancellationToken cancellationToken = default) where TNode : SyntaxNode
+        public static TNode Expand<TNode>(TNode node, SemanticModel semanticModel, Workspace workspace, Func<SyntaxNode, bool>? expandInsideNode = null, bool expandParameter = false, CancellationToken cancellationToken = default) where TNode : SyntaxNode
         {
             if (node == null)
             {
@@ -96,7 +95,7 @@ public static TNode Expand<TNode>(TNode node, SemanticModel semanticModel, Works
                 throw new ArgumentNullException(nameof(workspace));
             }
 
-            var result = workspace.Services.GetLanguageServices(node.Language).GetService<ISimplificationService>()
+            var result = workspace.Services.GetLanguageServices(node.Language).GetRequiredService<ISimplificationService>()
                 .Expand(node, semanticModel, annotationForReplacedAliasIdentifier: null, expandInsideNode: expandInsideNode, expandParameter: expandParameter, cancellationToken: cancellationToken);
 
             return (TNode)result;
@@ -105,21 +104,21 @@ public static TNode Expand<TNode>(TNode node, SemanticModel semanticModel, Works
         /// <summary>
         /// Expand qualifying parts of the specified subtree, annotating the parts using the <see cref="Annotation" /> annotation.
         /// </summary>
-        public static async Task<SyntaxToken> ExpandAsync(SyntaxToken token, Document document, Func<SyntaxNode, bool> expandInsideNode = null, CancellationToken cancellationToken = default)
+        public static async Task<SyntaxToken> ExpandAsync(SyntaxToken token, Document document, Func<SyntaxNode, bool>? expandInsideNode = null, CancellationToken cancellationToken = default)
         {
             if (document == null)
             {
                 throw new ArgumentNullException(nameof(document));
             }
 
-            var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
             return Expand(token, semanticModel, document.Project.Solution.Workspace, expandInsideNode, cancellationToken);
         }
 
         /// <summary>
         /// Expand qualifying parts of the specified subtree, annotating the parts using the <see cref="Annotation" /> annotation.
         /// </summary>
-        public static SyntaxToken Expand(SyntaxToken token, SemanticModel semanticModel, Workspace workspace, Func<SyntaxNode, bool> expandInsideNode = null, CancellationToken cancellationToken = default)
+        public static SyntaxToken Expand(SyntaxToken token, SemanticModel semanticModel, Workspace workspace, Func<SyntaxNode, bool>? expandInsideNode = null, CancellationToken cancellationToken = default)
         {
             if (semanticModel == null)
             {
@@ -131,21 +130,21 @@ public static SyntaxToken Expand(SyntaxToken token, SemanticModel semanticModel,
                 throw new ArgumentNullException(nameof(workspace));
             }
 
-            return workspace.Services.GetLanguageServices(token.Language).GetService<ISimplificationService>()
+            return workspace.Services.GetLanguageServices(token.Language).GetRequiredService<ISimplificationService>()
                 .Expand(token, semanticModel, expandInsideNode, cancellationToken);
         }
 
         /// <summary>
         /// Reduce all sub-trees annotated with <see cref="Annotation" /> found within the document. The annotated node and all child nodes will be reduced.
         /// </summary>
-        public static async Task<Document> ReduceAsync(Document document, OptionSet optionSet = null, CancellationToken cancellationToken = default)
+        public static async Task<Document> ReduceAsync(Document document, OptionSet? optionSet = null, CancellationToken cancellationToken = default)
         {
             if (document == null)
             {
                 throw new ArgumentNullException(nameof(document));
             }
 
-            var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             return await ReduceAsync(document, root.FullSpan, optionSet, cancellationToken).ConfigureAwait(false);
         }
 
@@ -153,7 +152,7 @@ public static async Task<Document> ReduceAsync(Document document, OptionSet opti
         /// Reduce the sub-trees annotated with <see cref="Annotation" /> found within the subtrees identified with the specified <paramref name="annotation"/>.
         /// The annotated node and all child nodes will be reduced.
         /// </summary>
-        public static async Task<Document> ReduceAsync(Document document, SyntaxAnnotation annotation, OptionSet optionSet = null, CancellationToken cancellationToken = default)
+        public static async Task<Document> ReduceAsync(Document document, SyntaxAnnotation annotation, OptionSet? optionSet = null, CancellationToken cancellationToken = default)
         {
             if (document == null)
             {
@@ -165,7 +164,7 @@ public static async Task<Document> ReduceAsync(Document document, SyntaxAnnotati
                 throw new ArgumentNullException(nameof(annotation));
             }
 
-            var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             return await ReduceAsync(document, root.GetAnnotatedNodesAndTokens(annotation).Select(t => t.FullSpan), optionSet, cancellationToken).ConfigureAwait(false);
         }
 
@@ -173,7 +172,7 @@ public static async Task<Document> ReduceAsync(Document document, SyntaxAnnotati
         /// Reduce the sub-trees annotated with <see cref="Annotation" /> found within the specified span.
         /// The annotated node and all child nodes will be reduced.
         /// </summary>
-        public static Task<Document> ReduceAsync(Document document, TextSpan span, OptionSet optionSet = null, CancellationToken cancellationToken = default)
+        public static Task<Document> ReduceAsync(Document document, TextSpan span, OptionSet? optionSet = null, CancellationToken cancellationToken = default)
         {
             if (document == null)
             {
@@ -187,7 +186,7 @@ public static Task<Document> ReduceAsync(Document document, TextSpan span, Optio
         /// Reduce the sub-trees annotated with <see cref="Annotation" /> found within the specified spans.
         /// The annotated node and all child nodes will be reduced.
         /// </summary>
-        public static Task<Document> ReduceAsync(Document document, IEnumerable<TextSpan> spans, OptionSet optionSet = null, CancellationToken cancellationToken = default)
+        public static Task<Document> ReduceAsync(Document document, IEnumerable<TextSpan> spans, OptionSet? optionSet = null, CancellationToken cancellationToken = default)
         {
             if (document == null)
             {
@@ -199,15 +198,15 @@ public static Task<Document> ReduceAsync(Document document, IEnumerable<TextSpan
                 throw new ArgumentNullException(nameof(spans));
             }
 
-            return document.GetLanguageService<ISimplificationService>().ReduceAsync(
+            return document.GetRequiredLanguageService<ISimplificationService>().ReduceAsync(
                 document, spans.ToImmutableArrayOrEmpty(), optionSet, cancellationToken: cancellationToken);
         }
 
         internal static async Task<Document> ReduceAsync(
-            Document document, ImmutableArray<AbstractReducer> reducers, OptionSet optionSet = null, CancellationToken cancellationToken = default)
+            Document document, ImmutableArray<AbstractReducer> reducers, OptionSet? optionSet = null, CancellationToken cancellationToken = default)
         {
-            var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-            return await document.GetLanguageService<ISimplificationService>()
+            var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            return await document.GetRequiredLanguageService<ISimplificationService>()
                 .ReduceAsync(document, ImmutableArray.Create(root.FullSpan), optionSet,
                              reducers, cancellationToken).ConfigureAwait(false);
         }
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/DocumentState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/DocumentState.cs
index 5bdab8050746d..b0de6908c51d5 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/DocumentState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/DocumentState.cs
@@ -43,6 +43,8 @@ protected DocumentState(
             ValueSource<TreeAndVersion>? treeSource)
             : base(solutionServices, documentServiceProvider, attributes, sourceText, textSource)
         {
+            Contract.ThrowIfFalse(_options is null == _treeSource is null);
+
             _languageServices = languageServices;
             _options = options;
             _treeSource = treeSource;
diff --git a/src/Workspaces/CoreTest/Editing/SyntaxEditorTests.cs b/src/Workspaces/CoreTest/Editing/SyntaxEditorTests.cs
index 524eccbc376c6..0f5ff6ab4be6c 100644
--- a/src/Workspaces/CoreTest/Editing/SyntaxEditorTests.cs
+++ b/src/Workspaces/CoreTest/Editing/SyntaxEditorTests.cs
@@ -20,7 +20,7 @@ public class SyntaxEditorTests
         private Workspace _emptyWorkspace;
 
         private Workspace EmptyWorkspace
-            => _emptyWorkspace ?? (_emptyWorkspace = new AdhocWorkspace());
+            => _emptyWorkspace ??= new AdhocWorkspace();
 
         private void VerifySyntax<TSyntax>(SyntaxNode node, string expectedText) where TSyntax : SyntaxNode
         {
@@ -31,7 +31,7 @@ private void VerifySyntax<TSyntax>(SyntaxNode node, string expectedText) where T
         }
 
         private SyntaxEditor GetEditor(SyntaxNode root)
-            => new SyntaxEditor(root, EmptyWorkspace);
+            => new SyntaxEditor(root, EmptyWorkspace.Services);
 
         [Fact]
         public void TestReplaceNode()
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/BlockSyntaxExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/BlockSyntaxExtensions.cs
index f0ac28049f946..ccb7d925bfeee 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/BlockSyntaxExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/BlockSyntaxExtensions.cs
@@ -16,8 +16,9 @@ namespace Microsoft.CodeAnalysis.CSharp.Extensions
     internal static class BlockSyntaxExtensions
     {
         public static bool TryConvertToExpressionBody(
-            this BlockSyntax block,
-            ParseOptions options, ExpressionBodyPreference preference,
+            this BlockSyntax? block,
+            LanguageVersion languageVersion,
+            ExpressionBodyPreference preference,
             [NotNullWhen(true)] out ExpressionSyntax? expression,
             out SyntaxToken semicolonToken)
         {
@@ -26,8 +27,7 @@ public static bool TryConvertToExpressionBody(
             {
                 var firstStatement = block.Statements[0];
 
-                var version = ((CSharpParseOptions)options).LanguageVersion;
-                if (TryGetExpression(version, firstStatement, out expression, out semicolonToken) &&
+                if (TryGetExpression(firstStatement, languageVersion, out expression, out semicolonToken) &&
                     MatchesPreference(expression, preference))
                 {
                     // The close brace of the block may have important trivia on it (like 
@@ -45,31 +45,29 @@ public static bool TryConvertToExpressionBody(
         }
 
         public static bool TryConvertToArrowExpressionBody(
-            this BlockSyntax block, SyntaxKind declarationKind,
-            ParseOptions options, ExpressionBodyPreference preference,
+            this BlockSyntax block,
+            SyntaxKind declarationKind,
+            LanguageVersion languageVersion,
+            ExpressionBodyPreference preference,
             [NotNullWhen(true)] out ArrowExpressionClauseSyntax? arrowExpression,
             out SyntaxToken semicolonToken)
         {
-            var version = ((CSharpParseOptions)options).LanguageVersion;
-
             // We can always use arrow-expression bodies in C# 7 or above.
             // We can also use them in C# 6, but only a select set of member kinds.
             var acceptableVersion =
-                version >= LanguageVersion.CSharp7 ||
-                (version >= LanguageVersion.CSharp6 && IsSupportedInCSharp6(declarationKind));
+                languageVersion >= LanguageVersion.CSharp7 ||
+                (languageVersion >= LanguageVersion.CSharp6 && IsSupportedInCSharp6(declarationKind));
 
-            if (!acceptableVersion ||
-                !block.TryConvertToExpressionBody(
-                    options, preference,
-                    out var expression, out semicolonToken))
+            if (acceptableVersion &&
+                block.TryConvertToExpressionBody(languageVersion, preference, out var expression, out semicolonToken))
             {
-                arrowExpression = null;
-                semicolonToken = default;
-                return false;
+                arrowExpression = SyntaxFactory.ArrowExpressionClause(expression);
+                return true;
             }
 
-            arrowExpression = SyntaxFactory.ArrowExpressionClause(expression);
-            return true;
+            arrowExpression = null;
+            semicolonToken = default;
+            return false;
         }
 
         private static bool IsSupportedInCSharp6(SyntaxKind declarationKind)
@@ -100,9 +98,7 @@ public static bool MatchesPreference(
             return CSharpSyntaxFacts.Instance.IsOnSingleLine(expression, fullSpan: false);
         }
 
-        private static bool TryGetExpression(
-            LanguageVersion version, StatementSyntax firstStatement,
-            [NotNullWhen(true)] out ExpressionSyntax? expression, out SyntaxToken semicolonToken)
+        private static bool TryGetExpression(StatementSyntax firstStatement, LanguageVersion languageVersion, [NotNullWhen(true)] out ExpressionSyntax? expression, out SyntaxToken semicolonToken)
         {
             if (firstStatement is ExpressionStatementSyntax exprStatement)
             {
@@ -125,7 +121,7 @@ private static bool TryGetExpression(
             }
             else if (firstStatement is ThrowStatementSyntax throwStatement)
             {
-                if (version >= LanguageVersion.CSharp7 && throwStatement.Expression != null)
+                if (languageVersion >= LanguageVersion.CSharp7 && throwStatement.Expression != null)
                 {
                     expression = SyntaxFactory.ThrowExpression(throwStatement.ThrowKeyword, throwStatement.Expression);
                     semicolonToken = throwStatement.SemicolonToken;
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/SyntaxNodeExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/SyntaxNodeExtensions.cs
index 6d688478a8ae2..f107931667ad8 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/SyntaxNodeExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/SyntaxNodeExtensions.cs
@@ -21,6 +21,9 @@ namespace Microsoft.CodeAnalysis.CSharp.Extensions
 {
     internal static partial class SyntaxNodeExtensions
     {
+        public static LanguageVersion GetLanguageVersion(this SyntaxNode node)
+            => ((CSharpParseOptions)node.SyntaxTree.Options).LanguageVersion;
+
         public static void Deconstruct(this SyntaxNode node, out SyntaxKind kind)
         {
             kind = node.Kind();
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Utilities/SpeculationAnalyzer.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Utilities/SpeculationAnalyzer.cs
index 56570c3755675..d6a05777d3a1d 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Utilities/SpeculationAnalyzer.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Utilities/SpeculationAnalyzer.cs
@@ -757,7 +757,7 @@ protected override bool ConversionsAreCompatible(SemanticModel originalModel, Ex
         }
 
         private static bool ConditionalExpressionConversionsAreAllowed(ExpressionSyntax originalExpression)
-            => ((CSharpParseOptions)originalExpression.SyntaxTree.Options).LanguageVersion >= LanguageVersion.CSharp9;
+            => originalExpression.GetLanguageVersion() >= LanguageVersion.CSharp9;
 
         protected override bool ConversionsAreCompatible(ExpressionSyntax originalExpression, ITypeSymbol originalTargetType, ExpressionSyntax newExpression, ITypeSymbol newTargetType)
         {
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpAddImportsService.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpAddImportsService.cs
index c0d3399577183..71341eedb2f15 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpAddImportsService.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpAddImportsService.cs
@@ -8,6 +8,8 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 using Microsoft.CodeAnalysis.AddImports;
+using Microsoft.CodeAnalysis.CodeGeneration;
+using Microsoft.CodeAnalysis.CSharp.CodeGeneration;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -15,12 +17,6 @@
 using Microsoft.CodeAnalysis.Host.Mef;
 using Roslyn.Utilities;
 
-#if CODE_STYLE
-using OptionSet = Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions;
-#else
-using Microsoft.CodeAnalysis.Options;
-#endif
-
 namespace Microsoft.CodeAnalysis.CSharp.AddImports
 {
     [ExportLanguageService(typeof(IAddImportsService), LanguageNames.CSharp), Shared]
@@ -33,9 +29,9 @@ public CSharpAddImportsService()
         {
         }
 
-        protected override bool PlaceImportsInsideNamespaces(OptionSet options)
+        protected override bool PlaceImportsInsideNamespaces(CodeGenerationPreferences preferences)
         {
-            return options.GetOption(CSharpCodeStyleOptions.PreferredUsingDirectivePlacement).Value == AddImportPlacement.InsideNamespace;
+            return preferences.Options.GetOption(CSharpCodeStyleOptions.PreferredUsingDirectivePlacement).Value == AddImportPlacement.InsideNamespace;
         }
 
         // C# doesn't have global imports.
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpReplaceDiscardDeclarationsWithAssignmentsService.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpReplaceDiscardDeclarationsWithAssignmentsService.cs
index 7fb23bf1f325b..3748852a09932 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpReplaceDiscardDeclarationsWithAssignmentsService.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpReplaceDiscardDeclarationsWithAssignmentsService.cs
@@ -14,6 +14,7 @@
 using Microsoft.CodeAnalysis.CSharp.Utilities;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Formatting;
+using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.ReplaceDiscardDeclarationsWithAssignments;
@@ -32,9 +33,9 @@ public CSharpReplaceDiscardDeclarationsWithAssignmentsService()
         {
         }
 
-        public Task<SyntaxNode> ReplaceAsync(SyntaxNode memberDeclaration, SemanticModel semanticModel, Workspace workspace, CancellationToken cancellationToken)
+        public Task<SyntaxNode> ReplaceAsync(SyntaxNode memberDeclaration, SemanticModel semanticModel, HostWorkspaceServices services, CancellationToken cancellationToken)
         {
-            var editor = new SyntaxEditor(memberDeclaration, workspace);
+            var editor = new SyntaxEditor(memberDeclaration, services);
             foreach (var child in memberDeclaration.DescendantNodes())
             {
                 switch (child)
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSyntaxGeneratorInternal.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSyntaxGeneratorInternal.cs
index 2cdcdaabd5915..4c30d511f692a 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSyntaxGeneratorInternal.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSyntaxGeneratorInternal.cs
@@ -33,7 +33,7 @@ public CSharpSyntaxGeneratorInternal()
         internal override SyntaxTrivia EndOfLine(string text)
             => SyntaxFactory.EndOfLine(text);
 
-        internal override SyntaxNode LocalDeclarationStatement(SyntaxNode type, SyntaxToken name, SyntaxNode initializer, bool isConst)
+        internal override SyntaxNode LocalDeclarationStatement(SyntaxNode? type, SyntaxToken name, SyntaxNode? initializer, bool isConst)
         {
             return SyntaxFactory.LocalDeclarationStatement(
                 isConst ? SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ConstKeyword)) : default,
@@ -46,7 +46,7 @@ internal override SyntaxNode WithInitializer(SyntaxNode variableDeclarator, Synt
         internal override SyntaxNode EqualsValueClause(SyntaxToken operatorToken, SyntaxNode value)
             => SyntaxFactory.EqualsValueClause(operatorToken, (ExpressionSyntax)value);
 
-        internal static VariableDeclarationSyntax VariableDeclaration(SyntaxNode type, SyntaxToken name, SyntaxNode expression)
+        internal static VariableDeclarationSyntax VariableDeclaration(SyntaxNode? type, SyntaxToken name, SyntaxNode? expression)
         {
             return SyntaxFactory.VariableDeclaration(
                 type == null ? SyntaxFactory.IdentifierName("var") : (TypeSyntax)type,
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/CodeFixes/SyntaxEditorBasedCodeFixProvider.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/CodeFixes/SyntaxEditorBasedCodeFixProvider.cs
index 669b318a51005..e8871f733f605 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/CodeFixes/SyntaxEditorBasedCodeFixProvider.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/CodeFixes/SyntaxEditorBasedCodeFixProvider.cs
@@ -64,7 +64,7 @@ internal static async Task<Document> FixAllWithEditorAsync(
             CancellationToken cancellationToken)
         {
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-            var editor = new SyntaxEditor(root, document.Project.Solution.Workspace);
+            var editor = new SyntaxEditor(root, document.Project.Solution.Workspace.Services);
 
             await editAsync(editor).ConfigureAwait(false);
 
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/CodeGeneration/CodeGenerationPreferences.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/CodeGeneration/CodeGenerationPreferences.cs
new file mode 100644
index 0000000000000..a93703662b9ba
--- /dev/null
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/CodeGeneration/CodeGenerationPreferences.cs
@@ -0,0 +1,44 @@
+// 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.Threading;
+using System.Threading.Tasks;
+using Roslyn.Utilities;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+
+#if CODE_STYLE
+using OptionSet = Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions;
+#else
+using Microsoft.CodeAnalysis.Options;
+#endif
+
+namespace Microsoft.CodeAnalysis.CodeGeneration
+{
+    /// <summary>
+    /// Document-specific options for controlling the code produced by code generation.
+    /// </summary>
+    internal abstract class CodeGenerationPreferences
+    {
+        public readonly OptionSet Options;
+
+        public CodeGenerationPreferences(OptionSet options)
+        {
+            Options = options;
+        }
+
+#if !CODE_STYLE
+        public abstract CodeGenerationOptions GetOptions(CodeGenerationContext context);
+
+        public static async Task<CodeGenerationPreferences> FromDocumentAsync(Document document, CancellationToken cancellationToken)
+        {
+            var parseOptions = document.Project.ParseOptions;
+            Contract.ThrowIfNull(parseOptions);
+
+            var documentOptions = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
+            var codeGenerationService = document.GetRequiredLanguageService<ICodeGenerationService>();
+            return codeGenerationService.GetPreferences(parseOptions, documentOptions);
+        }
+#endif
+    }
+}
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/AddImports/AbstractAddImportsService.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/AddImports/AbstractAddImportsService.cs
index 1b1d0d1edd568..2ad56a36195d5 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/AddImports/AbstractAddImportsService.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/AddImports/AbstractAddImportsService.cs
@@ -10,12 +10,7 @@
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.CodeStyle;
-
-#if CODE_STYLE
-using OptionSet = Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions;
-#else
-using Microsoft.CodeAnalysis.Options;
-#endif
+using Microsoft.CodeAnalysis.CodeGeneration;
 
 namespace Microsoft.CodeAnalysis.AddImports
 {
@@ -35,7 +30,7 @@ protected AbstractAddImportsService()
         protected abstract SyntaxList<TUsingOrAliasSyntax> GetUsingsAndAliases(SyntaxNode node);
         protected abstract SyntaxList<TExternSyntax> GetExterns(SyntaxNode node);
         protected abstract bool IsStaticUsing(TUsingOrAliasSyntax usingOrAlias);
-        protected abstract bool PlaceImportsInsideNamespaces(OptionSet options);
+        protected abstract bool PlaceImportsInsideNamespaces(CodeGenerationPreferences preferences);
 
         private bool IsSimpleUsing(TUsingOrAliasSyntax usingOrAlias) => !IsAlias(usingOrAlias) && !IsStaticUsing(usingOrAlias);
         private bool IsAlias(TUsingOrAliasSyntax usingOrAlias) => GetAlias(usingOrAlias) != null;
@@ -94,10 +89,10 @@ private bool HasExistingImport(
 
         protected abstract bool IsEquivalentImport(SyntaxNode a, SyntaxNode b);
 
-        public SyntaxNode GetImportContainer(SyntaxNode root, SyntaxNode? contextLocation, SyntaxNode import, OptionSet options)
+        public SyntaxNode GetImportContainer(SyntaxNode root, SyntaxNode? contextLocation, SyntaxNode import, CodeGenerationPreferences preferences)
         {
             contextLocation ??= root;
-            GetContainers(root, contextLocation, options,
+            GetContainers(root, contextLocation, preferences,
                 out var externContainer, out var usingContainer, out var staticUsingContainer, out var aliasContainer);
 
             switch (import)
@@ -127,13 +122,13 @@ public SyntaxNode AddImports(
             SyntaxNode? contextLocation,
             IEnumerable<SyntaxNode> newImports,
             SyntaxGenerator generator,
-            OptionSet options,
+            CodeGenerationPreferences preferences,
             bool allowInHiddenRegions,
             CancellationToken cancellationToken)
         {
             contextLocation ??= root;
 
-            var placeSystemNamespaceFirst = options.GetOption(GenerationOptions.PlaceSystemNamespaceFirst, compilation.Language);
+            var placeSystemNamespaceFirst = preferences.Options.GetOption(GenerationOptions.PlaceSystemNamespaceFirst, compilation.Language);
 
             var globalImports = GetGlobalImports(compilation, generator);
             var containers = GetAllContainers(root, contextLocation);
@@ -144,7 +139,7 @@ public SyntaxNode AddImports(
             var staticUsingDirectives = filteredImports.OfType<TUsingOrAliasSyntax>().Where(IsStaticUsing).ToArray();
             var aliasDirectives = filteredImports.OfType<TUsingOrAliasSyntax>().Where(IsAlias).ToArray();
 
-            GetContainers(root, contextLocation, options,
+            GetContainers(root, contextLocation, preferences,
                 out var externContainer, out var usingContainer, out var aliasContainer, out var staticUsingContainer);
 
             var newRoot = Rewrite(
@@ -160,7 +155,7 @@ protected abstract SyntaxNode Rewrite(
             SyntaxNode externContainer, SyntaxNode usingContainer, SyntaxNode staticUsingContainer, SyntaxNode aliasContainer,
             bool placeSystemNamespaceFirst, bool allowInHiddenRegions, SyntaxNode root, CancellationToken cancellationToken);
 
-        private void GetContainers(SyntaxNode root, SyntaxNode contextLocation, OptionSet options, out SyntaxNode externContainer, out SyntaxNode usingContainer, out SyntaxNode staticUsingContainer, out SyntaxNode aliasContainer)
+        private void GetContainers(SyntaxNode root, SyntaxNode contextLocation, CodeGenerationPreferences preferences, out SyntaxNode externContainer, out SyntaxNode usingContainer, out SyntaxNode staticUsingContainer, out SyntaxNode aliasContainer)
         {
             var applicableContainer = GetFirstApplicableContainer(contextLocation);
             var contextSpine = applicableContainer.GetAncestorsOrThis<SyntaxNode>().ToImmutableArray();
@@ -172,7 +167,7 @@ private void GetContainers(SyntaxNode root, SyntaxNode contextLocation, OptionSe
 
             // If there aren't any existing imports then make sure we honour the inside namespace preference
             // for using directings if it's set
-            if (fallbackNode is null && PlaceImportsInsideNamespaces(options))
+            if (fallbackNode is null && PlaceImportsInsideNamespaces(preferences))
                 fallbackNode = contextSpine.OfType<TNamespaceDeclarationSyntax>().FirstOrDefault();
 
             // If all else fails use the root
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/AddImports/IAddImportsService.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/AddImports/IAddImportsService.cs
index 3a6b74155b9e3..89050fbb30047 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/AddImports/IAddImportsService.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/AddImports/IAddImportsService.cs
@@ -6,14 +6,9 @@
 using System.Threading;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.CodeGeneration;
 using Roslyn.Utilities;
 
-#if CODE_STYLE
-using OptionSet = Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions;
-#else
-using Microsoft.CodeAnalysis.Options;
-#endif
-
 namespace Microsoft.CodeAnalysis.AddImports
 {
     internal interface IAddImportsService : ILanguageService
@@ -29,11 +24,11 @@ internal interface IAddImportsService : ILanguageService
         /// Given a context location in a provided syntax tree, returns the appropriate container
         /// that <paramref name="import"/> should be added to.
         /// </summary>
-        SyntaxNode GetImportContainer(SyntaxNode root, SyntaxNode? contextLocation, SyntaxNode import, OptionSet options);
+        SyntaxNode GetImportContainer(SyntaxNode root, SyntaxNode? contextLocation, SyntaxNode import, CodeGenerationPreferences preferences);
 
         SyntaxNode AddImports(
             Compilation compilation, SyntaxNode root, SyntaxNode? contextLocation,
-            IEnumerable<SyntaxNode> newImports, SyntaxGenerator generator, OptionSet options,
+            IEnumerable<SyntaxNode> newImports, SyntaxGenerator generator, CodeGenerationPreferences preferences,
             bool allowInHiddenRegions, CancellationToken cancellationToken);
     }
 
@@ -41,11 +36,11 @@ internal static class IAddImportServiceExtensions
     {
         public static SyntaxNode AddImport(
             this IAddImportsService service, Compilation compilation, SyntaxNode root,
-            SyntaxNode contextLocation, SyntaxNode newImport, SyntaxGenerator generator, OptionSet options,
+            SyntaxNode contextLocation, SyntaxNode newImport, SyntaxGenerator generator, CodeGenerationPreferences preferences,
             bool allowInHiddenRegions, CancellationToken cancellationToken)
         {
             return service.AddImports(compilation, root, contextLocation,
-                SpecializedCollections.SingletonEnumerable(newImport), generator, options,
+                SpecializedCollections.SingletonEnumerable(newImport), generator, preferences,
                 allowInHiddenRegions, cancellationToken);
         }
     }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/MoveDeclarationNearReference/AbstractMoveDeclarationNearReferenceService.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/MoveDeclarationNearReference/AbstractMoveDeclarationNearReferenceService.cs
index 655c138f1d692..972164fbb53bd 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/MoveDeclarationNearReference/AbstractMoveDeclarationNearReferenceService.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/MoveDeclarationNearReference/AbstractMoveDeclarationNearReferenceService.cs
@@ -80,7 +80,7 @@ public async Task<Document> MoveDeclarationNearReferenceAsync(
             }
 
             var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-            var editor = new SyntaxEditor(root, document.Project.Solution.Workspace);
+            var editor = new SyntaxEditor(root, document.Project.Solution.Workspace.Services);
 
             var crossesMeaningfulBlock = CrossesMeaningfulBlock(state);
             var warningAnnotation = crossesMeaningfulBlock
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/ReplaceDiscardDeclarationsWithAssignments/IReplaceDiscardDeclarationsWithAssignmentsService.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/ReplaceDiscardDeclarationsWithAssignments/IReplaceDiscardDeclarationsWithAssignmentsService.cs
index 05036862393ad..ef4f5d30345c0 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/ReplaceDiscardDeclarationsWithAssignments/IReplaceDiscardDeclarationsWithAssignmentsService.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/ReplaceDiscardDeclarationsWithAssignments/IReplaceDiscardDeclarationsWithAssignmentsService.cs
@@ -29,6 +29,6 @@ internal interface IReplaceDiscardDeclarationsWithAssignmentsService : ILanguage
         /// where the code transformation wants to generate new discard assignment(s), which would be a compiler error.
         /// This method replaces such discard variable declarations with discard assignments.
         /// </summary>
-        Task<SyntaxNode> ReplaceAsync(SyntaxNode memberDeclaration, SemanticModel semanticModel, Workspace workspace, CancellationToken cancellationToken);
+        Task<SyntaxNode> ReplaceAsync(SyntaxNode memberDeclaration, SemanticModel semanticModel, HostWorkspaceServices services, CancellationToken cancellationToken);
     }
 }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SyntaxGeneratorInternalExtensions/SyntaxGeneratorInternal.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SyntaxGeneratorInternalExtensions/SyntaxGeneratorInternal.cs
index 4787ee302c0e5..e3ed12fa681aa 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SyntaxGeneratorInternalExtensions/SyntaxGeneratorInternal.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SyntaxGeneratorInternalExtensions/SyntaxGeneratorInternal.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System.Collections.Generic;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.LanguageServices;
@@ -28,7 +26,7 @@ internal abstract class SyntaxGeneratorInternal : ILanguageService
         /// Creates a statement that declares a single local variable with an optional initializer.
         /// </summary>
         internal abstract SyntaxNode LocalDeclarationStatement(
-            SyntaxNode type, SyntaxToken identifier, SyntaxNode initializer = null, bool isConst = false);
+            SyntaxNode? type, SyntaxToken identifier, SyntaxNode? initializer = null, bool isConst = false);
 
         /// <summary>
         /// Creates a statement that declares a single local variable.
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/WorkspaceExtensions.projitems b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/WorkspaceExtensions.projitems
index de688f639878c..6d8cdafcaffd1 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/WorkspaceExtensions.projitems
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/WorkspaceExtensions.projitems
@@ -9,6 +9,7 @@
     <Import_RootNamespace>Microsoft.CodeAnalysis.Shared</Import_RootNamespace>
   </PropertyGroup>
   <ItemGroup>
+    <Compile Include="$(MSBuildThisFileDirectory)CodeGeneration\CodeGenerationPreferences.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)EmbeddedLanguages\VirtualChars\IVirtualCharLanguageService.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\ContextQuery\ISyntaxContextService.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\ContextQuery\SyntaxContext.cs" />
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/LanguageServices/VisualBasicAddImportsService.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/LanguageServices/VisualBasicAddImportsService.vb
index f8abed2b5e8bc..a21ada97ee977 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/LanguageServices/VisualBasicAddImportsService.vb
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/LanguageServices/VisualBasicAddImportsService.vb
@@ -6,18 +6,13 @@ Imports System.Collections.Immutable
 Imports System.Composition
 Imports System.Threading
 Imports Microsoft.CodeAnalysis.AddImports
+Imports Microsoft.CodeAnalysis.CodeGeneration
 Imports Microsoft.CodeAnalysis.Editing
 Imports Microsoft.CodeAnalysis.Host.Mef
 Imports Microsoft.CodeAnalysis.PooledObjects
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 Imports Microsoft.CodeAnalysis.VisualBasic.Utilities
 
-#If CODE_STYLE Then
-Imports OptionSet = Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions
-#Else
-Imports Microsoft.CodeAnalysis.Options
-#End If
-
 Namespace Microsoft.CodeAnalysis.VisualBasic.AddImports
     <ExportLanguageService(GetType(IAddImportsService), LanguageNames.VisualBasic), [Shared]>
     Friend Class VisualBasicAddImportsService
@@ -63,7 +58,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.AddImports
                                                FirstOrDefault()?.Alias
         End Function
 
-        Protected Overrides Function PlaceImportsInsideNamespaces(options As OptionSet) As Boolean
+        Protected Overrides Function PlaceImportsInsideNamespaces(preferences As CodeGenerationPreferences) As Boolean
             ' Visual Basic doesn't support imports inside namespaces
             Return False
         End Function
diff --git a/src/Workspaces/VisualBasic/Portable/CodeGeneration/ConstructorGenerator.vb b/src/Workspaces/VisualBasic/Portable/CodeGeneration/ConstructorGenerator.vb
index 3522fd5118431..96822bf9d4297 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeGeneration/ConstructorGenerator.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeGeneration/ConstructorGenerator.vb
@@ -41,7 +41,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                 .WithModifiers(GenerateModifiers(constructor, destination, options)) _
                 .WithParameterList(ParameterGenerator.GenerateParameterList(constructor.Parameters, options))
 
-            Dim hasNoBody = Not options.GenerateMethodBodies
+            Dim hasNoBody = Not options.Context.GenerateMethodBodies
 
             Dim declaration =
                 If(hasNoBody,
diff --git a/src/Workspaces/VisualBasic/Portable/CodeGeneration/ConversionGenerator.vb b/src/Workspaces/VisualBasic/Portable/CodeGeneration/ConversionGenerator.vb
index 0236320082af4..29f0aa41b8fcb 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeGeneration/ConversionGenerator.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeGeneration/ConversionGenerator.vb
@@ -54,7 +54,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                 ParameterGenerator.GenerateParameterList(method.Parameters, options),
                 SyntaxFactory.SimpleAsClause(method.ReturnType.GenerateTypeSyntax()))
 
-            Dim hasNoBody = Not options.GenerateMethodBodies OrElse
+            Dim hasNoBody = Not options.Context.GenerateMethodBodies OrElse
                             method.IsExtern
 
             If hasNoBody Then
diff --git a/src/Workspaces/VisualBasic/Portable/CodeGeneration/EventGenerator.vb b/src/Workspaces/VisualBasic/Portable/CodeGeneration/EventGenerator.vb
index 585f7a84dc30c..9b42a51af0d59 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeGeneration/EventGenerator.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeGeneration/EventGenerator.vb
@@ -76,7 +76,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                                                         destination As CodeGenerationDestination,
                                                         options As CodeGenerationOptions) As DeclarationStatementSyntax
 
-            If options.GenerateMethodBodies AndAlso
+            If options.Context.GenerateMethodBodies AndAlso
                 ([event].AddMethod IsNot Nothing OrElse [event].RemoveMethod IsNot Nothing OrElse [event].RaiseMethod IsNot Nothing) Then
                 Return GenerateCustomEventDeclarationWorker([event], destination, options)
             Else
diff --git a/src/Workspaces/VisualBasic/Portable/CodeGeneration/ExpressionGenerator.vb b/src/Workspaces/VisualBasic/Portable/CodeGeneration/ExpressionGenerator.vb
index 6d4c57ca5177e..78674ef57f0a4 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeGeneration/ExpressionGenerator.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeGeneration/ExpressionGenerator.vb
@@ -48,7 +48,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             End If
 
             If type.TypeKind = TypeKind.Enum AndAlso value IsNot Nothing Then
-                Return DirectCast(VisualBasicFlagsEnumGenerator.Instance.TryCreateEnumConstantValue(DirectCast(type, INamedTypeSymbol), value), ExpressionSyntax)
+                Return DirectCast(VisualBasicFlagsEnumGenerator.Instance.CreateEnumConstantValue(DirectCast(type, INamedTypeSymbol), value), ExpressionSyntax)
             End If
 
             Return GenerateNonEnumValueExpression(type, value, canUseFieldReference)
diff --git a/src/Workspaces/VisualBasic/Portable/CodeGeneration/MethodGenerator.vb b/src/Workspaces/VisualBasic/Portable/CodeGeneration/MethodGenerator.vb
index 1815111410205..ba83a3ffbde7b 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeGeneration/MethodGenerator.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeGeneration/MethodGenerator.vb
@@ -84,7 +84,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                     WithImplementsClause(implementsClauseOpt).
                     WithHandlesClause(handlesClauseOpt)
 
-            Dim hasNoBody = Not options.GenerateMethodBodies OrElse
+            Dim hasNoBody = Not options.Context.GenerateMethodBodies OrElse
                             method.IsAbstract OrElse
                             destination = CodeGenerationDestination.InterfaceType
 
diff --git a/src/Workspaces/VisualBasic/Portable/CodeGeneration/NamedTypeGenerator.vb b/src/Workspaces/VisualBasic/Portable/CodeGeneration/NamedTypeGenerator.vb
index 1a6aa8db3f493..154bcf42f27e7 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeGeneration/NamedTypeGenerator.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeGeneration/NamedTypeGenerator.vb
@@ -48,11 +48,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                                     namedType As INamedTypeSymbol,
                                     options As CodeGenerationOptions,
                                     cancellationToken As CancellationToken) As StatementSyntax
-            options = If(options, CodeGenerationOptions.Default)
-
             Dim declaration = GetDeclarationSyntaxWithoutMembers(namedType, options)
 
-            declaration = If(options.GenerateMembers AndAlso namedType.TypeKind <> TypeKind.Delegate,
+            declaration = If(options.Context.GenerateMembers AndAlso namedType.TypeKind <> TypeKind.Delegate,
                 service.AddMembers(declaration, GetMembers(namedType), options, cancellationToken),
                 declaration)
 
diff --git a/src/Workspaces/VisualBasic/Portable/CodeGeneration/NamespaceGenerator.vb b/src/Workspaces/VisualBasic/Portable/CodeGeneration/NamespaceGenerator.vb
index aeef49fbba8b0..04c2d745b53f5 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeGeneration/NamespaceGenerator.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeGeneration/NamespaceGenerator.vb
@@ -44,12 +44,11 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
         Public Function GenerateNamespaceDeclaration(service As ICodeGenerationService, [namespace] As INamespaceSymbol, options As CodeGenerationOptions, cancellationToken As CancellationToken) As SyntaxNode
             Dim name As String = Nothing
             Dim innermostNamespace As INamespaceSymbol = Nothing
-            options = If(options, CodeGenerationOptions.Default)
             GetNameAndInnermostNamespace([namespace], options, name, innermostNamespace)
 
             Dim declaration = GetDeclarationSyntaxWithoutMembers([namespace], innermostNamespace, name, options)
 
-            declaration = If(options.GenerateMembers,
+            declaration = If(options.Context.GenerateMembers,
                 service.AddMembers(declaration, innermostNamespace.GetMembers().AsEnumerable(), options, cancellationToken),
                 declaration)
 
diff --git a/src/Workspaces/VisualBasic/Portable/CodeGeneration/OperatorGenerator.vb b/src/Workspaces/VisualBasic/Portable/CodeGeneration/OperatorGenerator.vb
index 6f09cb73b163c..5f23b1afa41f3 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeGeneration/OperatorGenerator.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeGeneration/OperatorGenerator.vb
@@ -49,7 +49,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                 ParameterGenerator.GenerateParameterList(method.Parameters, options),
                 SyntaxFactory.SimpleAsClause(method.ReturnType.GenerateTypeSyntax()))
 
-            Dim hasNoBody = Not options.GenerateMethodBodies OrElse
+            Dim hasNoBody = Not options.Context.GenerateMethodBodies OrElse
                             method.IsExtern
 
             If hasNoBody Then
diff --git a/src/Workspaces/VisualBasic/Portable/CodeGeneration/PropertyGenerator.vb b/src/Workspaces/VisualBasic/Portable/CodeGeneration/PropertyGenerator.vb
index 21b2ba17ab733..8572f0284aacc 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeGeneration/PropertyGenerator.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeGeneration/PropertyGenerator.vb
@@ -82,7 +82,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                 (setMethod IsNot Nothing AndAlso Not setMethod.IsAbstract)
 
             Dim hasNoBody =
-                Not options.GenerateMethodBodies OrElse
+                Not options.Context.GenerateMethodBodies OrElse
                 destination = CodeGenerationDestination.InterfaceType OrElse
                 [property].IsAbstract OrElse
                 Not hasStatements
diff --git a/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicCodeGenerationHelpers.vb b/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicCodeGenerationHelpers.vb
index 2d25baf5f39a2..fb83c7461856c 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicCodeGenerationHelpers.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicCodeGenerationHelpers.vb
@@ -18,8 +18,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                 destination As CodeGenerationDestination,
                 options As CodeGenerationOptions,
                 nonStructureAccessibility As Accessibility)
-            options = If(options, CodeGenerationOptions.Default)
-            If Not options.GenerateDefaultAccessibility Then
+            If Not options.Context.GenerateDefaultAccessibility Then
                 If destination = CodeGenerationDestination.StructType AndAlso accessibility = Accessibility.Public Then
                     Return
                 End If
@@ -114,20 +113,14 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
         End Function
 
         Private Function AfterDeclaration(Of TDeclaration As SyntaxNode)(
-            options As CodeGenerationOptions,
             [next] As Func(Of SyntaxList(Of TDeclaration), TDeclaration)) As Func(Of SyntaxList(Of TDeclaration), TDeclaration)
 
-            options = If(options, CodeGenerationOptions.Default)
-
             Return Function(list) [next]?(list)
         End Function
 
         Private Function BeforeDeclaration(Of TDeclaration As SyntaxNode)(
-            options As CodeGenerationOptions,
             [next] As Func(Of SyntaxList(Of TDeclaration), TDeclaration)) As Func(Of SyntaxList(Of TDeclaration), TDeclaration)
 
-            options = If(options, CodeGenerationOptions.Default)
-
             Return Function(list) [next]?(list)
         End Function
 
@@ -139,8 +132,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Optional after As Func(Of SyntaxList(Of TDeclaration), TDeclaration) = Nothing,
             Optional before As Func(Of SyntaxList(Of TDeclaration), TDeclaration) = Nothing) As SyntaxList(Of TDeclaration)
 
-            after = AfterDeclaration(options, after)
-            before = BeforeDeclaration(options, before)
+            after = AfterDeclaration(after)
+            before = BeforeDeclaration(before)
 
             Dim index = GetInsertionIndex(
                 declarationList, declaration, options, availableIndices,
@@ -186,7 +179,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             options As CodeGenerationOptions,
             Optional cancellationToken As CancellationToken = Nothing) As TSyntaxNode
 
-            If Not options.GenerateDocumentationComments OrElse node.GetLeadingTrivia().Any(Function(t) t.IsKind(SyntaxKind.DocumentationCommentTrivia)) Then
+            If Not options.Context.GenerateDocumentationComments OrElse node.GetLeadingTrivia().Any(Function(t) t.IsKind(SyntaxKind.DocumentationCommentTrivia)) Then
                 Return node
             End If
 
@@ -205,14 +198,14 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
         Public Function GetReuseableSyntaxNodeForSymbol(Of T As SyntaxNode)(symbol As ISymbol, options As CodeGenerationOptions) As T
             ThrowIfNull(symbol)
 
-            If options IsNot Nothing AndAlso options.ReuseSyntax AndAlso symbol.DeclaringSyntaxReferences.Length = 1
+            If options.Context.ReuseSyntax AndAlso symbol.DeclaringSyntaxReferences.Length = 1 Then
                 Dim reusableNode = symbol.DeclaringSyntaxReferences(0).GetSyntax()
 
                 ' For VB method like symbol (Function, Sub, Property & Event), DeclaringSyntaxReferences will fetch
                 ' the first line of the member's block. But what we want to reuse is the whole member's block
-                If symbol.IsKind(SymbolKind.Method) OrElse symbol.IsKind(SymbolKind.Property) OrElse symbol.IsKind(SymbolKind.Event)
+                If symbol.IsKind(SymbolKind.Method) OrElse symbol.IsKind(SymbolKind.Property) OrElse symbol.IsKind(SymbolKind.Event) Then
                     Dim declarationStatementNode = TryCast(reusableNode, DeclarationStatementSyntax)
-                    If declarationStatementNode IsNot Nothing
+                    If declarationStatementNode IsNot Nothing Then
                         Dim declarationBlockFromBegin = declarationStatementNode.GetDeclarationBlockFromBegin()
                         Return TryCast(RemoveLeadingDirectiveTrivia(declarationBlockFromBegin), T)
                     End If
diff --git a/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicCodeGenerationOptions.vb b/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicCodeGenerationOptions.vb
new file mode 100644
index 0000000000000..33eac7e5e8226
--- /dev/null
+++ b/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicCodeGenerationOptions.vb
@@ -0,0 +1,34 @@
+' 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.
+
+Imports Microsoft.CodeAnalysis.CodeGeneration
+
+Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
+    Friend NotInheritable Class VisualBasicCodeGenerationOptions
+        Inherits CodeGenerationOptions
+
+        Private ReadOnly _preferences As VisualBasicCodeGenerationPreferences
+
+        Public Sub New(context As CodeGenerationContext, preferences As VisualBasicCodeGenerationPreferences)
+            MyBase.New(context)
+            _preferences = preferences
+        End Sub
+
+        Public Shadows ReadOnly Property Preferences As VisualBasicCodeGenerationPreferences
+            Get
+                Return _preferences
+            End Get
+        End Property
+
+        Protected Overrides ReadOnly Property PreferencesImpl As CodeGenerationPreferences
+            Get
+                Return _preferences
+            End Get
+        End Property
+
+        Protected Overrides Function WithContextImpl(value As CodeGenerationContext) As CodeGenerationOptions
+            Return New VisualBasicCodeGenerationOptions(value, Preferences)
+        End Function
+    End Class
+End Namespace
diff --git a/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicCodeGenerationPreferences.vb b/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicCodeGenerationPreferences.vb
new file mode 100644
index 0000000000000..50fbc5fe29c36
--- /dev/null
+++ b/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicCodeGenerationPreferences.vb
@@ -0,0 +1,26 @@
+' 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.
+
+Imports System.Threading
+Imports Microsoft.CodeAnalysis.CodeGeneration
+Imports Microsoft.CodeAnalysis.Options
+
+Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
+    Friend NotInheritable Class VisualBasicCodeGenerationPreferences
+        Inherits CodeGenerationPreferences
+
+        Public Sub New(options As OptionSet)
+            MyBase.New(options)
+        End Sub
+
+        Public Overrides Function GetOptions(context As CodeGenerationContext) As CodeGenerationOptions
+            Return New VisualBasicCodeGenerationOptions(context, Me)
+        End Function
+
+        Public Shared Shadows Async Function FromDocumentAsync(document As Document, cancellationToken As CancellationToken) As Task(Of VisualBasicCodeGenerationPreferences)
+            Dim documentOptions = Await document.GetOptionsAsync(cancellationToken).ConfigureAwait(False)
+            Return New VisualBasicCodeGenerationPreferences(documentOptions)
+        End Function
+    End Class
+End Namespace
diff --git a/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicCodeGenerationService.vb b/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicCodeGenerationService.vb
index 2bbc37d4eb715..df0508c6dcd38 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicCodeGenerationService.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicCodeGenerationService.vb
@@ -9,20 +9,25 @@ Imports Microsoft.CodeAnalysis
 Imports Microsoft.CodeAnalysis.CodeGeneration
 Imports Microsoft.CodeAnalysis.Host
 Imports Microsoft.CodeAnalysis.LanguageServices
+Imports Microsoft.CodeAnalysis.Options
 Imports Microsoft.CodeAnalysis.PooledObjects
 Imports Microsoft.CodeAnalysis.Text
 Imports Microsoft.CodeAnalysis.VisualBasic.LanguageServices
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
+
     Friend Class VisualBasicCodeGenerationService
-        Inherits AbstractCodeGenerationService
+        Inherits AbstractCodeGenerationService(Of VisualBasicCodeGenerationOptions)
 
         Public Sub New(provider As HostLanguageServices)
-            MyBase.New(provider.GetService(Of ISymbolDeclarationService)(),
-                       provider.WorkspaceServices.Workspace)
+            MyBase.New(provider.GetService(Of ISymbolDeclarationService)())
         End Sub
 
+        Public Overrides Function GetPreferences(parseOptions As ParseOptions, documentOptions As OptionSet) As CodeGenerationPreferences
+            Return New VisualBasicCodeGenerationPreferences(documentOptions)
+        End Function
+
         Public Overloads Overrides Function GetDestination(containerNode As SyntaxNode) As CodeGenerationDestination
             Return VisualBasicCodeGenerationHelpers.GetDestination(containerNode)
         End Function
@@ -77,8 +82,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
         Protected Overrides Function AddEvent(Of TDeclarationNode As SyntaxNode)(
                 destinationType As TDeclarationNode,
                 [event] As IEventSymbol,
-                options As CodeGenerationOptions,
-                availableIndices As IList(Of Boolean)) As TDeclarationNode
+                options As VisualBasicCodeGenerationOptions,
+                availableIndices As IList(Of Boolean),
+                cancellationToken As CancellationToken) As TDeclarationNode
             CheckDeclarationNode(Of TypeBlockSyntax)(destinationType)
             Return Cast(Of TDeclarationNode)(AddEventTo(Cast(Of TypeBlockSyntax)(destinationType), [event], options, availableIndices))
         End Function
@@ -86,8 +92,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
         Protected Overrides Function AddField(Of TDeclarationNode As SyntaxNode)(
                 destinationType As TDeclarationNode,
                 field As IFieldSymbol,
-                options As CodeGenerationOptions,
-                availableIndices As IList(Of Boolean)) As TDeclarationNode
+                options As VisualBasicCodeGenerationOptions,
+                availableIndices As IList(Of Boolean),
+                cancellationToken As CancellationToken) As TDeclarationNode
             CheckDeclarationNode(Of EnumBlockSyntax, TypeBlockSyntax, CompilationUnitSyntax)(destinationType)
             If TypeOf destinationType Is EnumBlockSyntax Then
                 Return Cast(Of TDeclarationNode)(EnumMemberGenerator.AddEnumMemberTo(Cast(Of EnumBlockSyntax)(destinationType), field, options))
@@ -101,8 +108,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
         Protected Overrides Function AddProperty(Of TDeclarationNode As SyntaxNode)(
                 destinationType As TDeclarationNode,
                 [property] As IPropertySymbol,
-                options As CodeGenerationOptions,
-                availableIndices As IList(Of Boolean)) As TDeclarationNode
+                options As VisualBasicCodeGenerationOptions,
+                availableIndices As IList(Of Boolean),
+                cancellationToken As CancellationToken) As TDeclarationNode
             CheckDeclarationNode(Of TypeBlockSyntax, CompilationUnitSyntax)(destinationType)
 
             If TypeOf destinationType Is TypeBlockSyntax Then
@@ -115,8 +123,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
         Protected Overrides Function AddMethod(Of TDeclarationNode As SyntaxNode)(
                 destination As TDeclarationNode,
                 method As IMethodSymbol,
-                options As CodeGenerationOptions,
-                availableIndices As IList(Of Boolean)) As TDeclarationNode
+                options As VisualBasicCodeGenerationOptions,
+                availableIndices As IList(Of Boolean),
+                cancellationToken As CancellationToken) As TDeclarationNode
             CheckDeclarationNode(Of TypeBlockSyntax, CompilationUnitSyntax, NamespaceBlockSyntax)(destination)
 
             ' Synthesized methods for properties/events are not things we actually generate 
@@ -158,11 +167,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
         Protected Overloads Overrides Function AddNamedType(Of TDeclarationNode As SyntaxNode)(
                 destination As TDeclarationNode,
                 namedType As INamedTypeSymbol,
-                options As CodeGenerationOptions,
+                options As VisualBasicCodeGenerationOptions,
                 availableIndices As IList(Of Boolean),
                 cancellationToken As CancellationToken) As TDeclarationNode
             CheckDeclarationNode(Of TypeBlockSyntax, NamespaceBlockSyntax, CompilationUnitSyntax)(destination)
-            options = If(options, CodeGenerationOptions.Default)
             If TypeOf destination Is TypeBlockSyntax Then
                 Return Cast(Of TDeclarationNode)(NamedTypeGenerator.AddNamedTypeTo(Me, Cast(Of TypeBlockSyntax)(destination), namedType, options, availableIndices, cancellationToken))
             ElseIf TypeOf destination Is NamespaceBlockSyntax Then
@@ -175,7 +183,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
         Protected Overrides Function AddNamespace(Of TDeclarationNode As SyntaxNode)(
                 destination As TDeclarationNode,
                 [namespace] As INamespaceSymbol,
-                options As CodeGenerationOptions,
+                options As VisualBasicCodeGenerationOptions,
                 availableIndices As IList(Of Boolean),
                 cancellationToken As CancellationToken) As TDeclarationNode
             CheckDeclarationNode(Of CompilationUnitSyntax, NamespaceBlockSyntax)(destination)
@@ -190,7 +198,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
         Public Overrides Function AddParameters(Of TDeclarationNode As SyntaxNode)(
                 destinationMember As TDeclarationNode,
                 parameters As IEnumerable(Of IParameterSymbol),
-                options As CodeGenerationOptions,
+                options As VisualBasicCodeGenerationOptions,
                 cancellationToken As CancellationToken) As TDeclarationNode
             Dim methodBlock = TryCast(destinationMember, MethodBlockBaseSyntax)
             Dim methodStatement = If(methodBlock IsNot Nothing,
@@ -231,7 +239,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
         Private Overloads Shared Function AddParametersToMethod(Of TDeclarationNode As SyntaxNode)(methodStatement As MethodBaseSyntax,
                                                                 methodBlock As MethodBlockBaseSyntax,
                                                                 parameters As IEnumerable(Of IParameterSymbol),
-                                                                options As CodeGenerationOptions) As TDeclarationNode
+                                                                options As VisualBasicCodeGenerationOptions) As TDeclarationNode
             Dim newParameterList = AddParameters(methodStatement.ParameterList, parameters, options)
             Dim finalStatement = methodStatement.WithParameterList(newParameterList)
 
@@ -266,7 +274,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
         Private Overloads Shared Function AddParametersToProperty(Of TDeclarationNode As SyntaxNode)(
                                                                 propertyBlock As PropertyBlockSyntax,
                                                                 parameters As IEnumerable(Of IParameterSymbol),
-                                                                options As CodeGenerationOptions) As TDeclarationNode
+                                                                options As VisualBasicCodeGenerationOptions) As TDeclarationNode
             Dim propertyStatement = propertyBlock.PropertyStatement
             Dim newParameterList = AddParameters(propertyStatement.ParameterList, parameters, options)
             Dim newPropertyStatement = propertyStatement.WithParameterList(newParameterList)
@@ -274,7 +282,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Return DirectCast(newPropertyBlock, TDeclarationNode)
         End Function
 
-        Private Overloads Shared Function AddParameters(parameterList As ParameterListSyntax, parameters As IEnumerable(Of IParameterSymbol), options As CodeGenerationOptions) As ParameterListSyntax
+        Private Overloads Shared Function AddParameters(parameterList As ParameterListSyntax, parameters As IEnumerable(Of IParameterSymbol), options As VisualBasicCodeGenerationOptions) As ParameterListSyntax
             Dim nodesAndTokens = If(parameterList IsNot Nothing,
                     New List(Of SyntaxNodeOrToken)(parameterList.Parameters.GetWithSeparators()),
                     New List(Of SyntaxNodeOrToken))
@@ -301,7 +309,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                     destination As TDeclarationNode,
                     attributes As IEnumerable(Of AttributeData),
                     target As SyntaxToken?,
-                    options As CodeGenerationOptions,
+                    options As VisualBasicCodeGenerationOptions,
                     cancellationToken As CancellationToken) As TDeclarationNode
 
             If target.HasValue AndAlso Not target.Value.IsValidAttributeTarget() Then
@@ -331,7 +339,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Return destination
         End Function
 
-        Public Overrides Function RemoveAttribute(Of TDeclarationNode As SyntaxNode)(destination As TDeclarationNode, attributeToRemove As AttributeData, options As CodeGenerationOptions, cancellationToken As CancellationToken) As TDeclarationNode
+        Public Overrides Function RemoveAttribute(Of TDeclarationNode As SyntaxNode)(destination As TDeclarationNode, attributeToRemove As AttributeData, options As VisualBasicCodeGenerationOptions, cancellationToken As CancellationToken) As TDeclarationNode
             If attributeToRemove.ApplicationSyntaxReference Is Nothing Then
                 Throw New ArgumentException(NameOf(attributeToRemove))
             End If
@@ -340,7 +348,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Return RemoveAttribute(destination, attributeSyntaxToRemove, options, cancellationToken)
         End Function
 
-        Public Overrides Function RemoveAttribute(Of TDeclarationNode As SyntaxNode)(destination As TDeclarationNode, attributeToRemove As SyntaxNode, options As CodeGenerationOptions, cancellationToken As CancellationToken) As TDeclarationNode
+        Public Overrides Function RemoveAttribute(Of TDeclarationNode As SyntaxNode)(destination As TDeclarationNode, attributeToRemove As SyntaxNode, options As VisualBasicCodeGenerationOptions, cancellationToken As CancellationToken) As TDeclarationNode
             If attributeToRemove Is Nothing Then
                 Throw New ArgumentException(NameOf(attributeToRemove))
             End If
@@ -434,7 +442,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
         Public Overrides Function AddStatements(Of TDeclarationNode As SyntaxNode)(
                 destinationMember As TDeclarationNode,
                 statements As IEnumerable(Of SyntaxNode),
-                options As CodeGenerationOptions,
+                options As VisualBasicCodeGenerationOptions,
                 cancellationToken As CancellationToken) As TDeclarationNode
 
             Dim methodBlock = TryCast(destinationMember, MethodBlockBaseSyntax)
@@ -467,9 +475,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
         Private Shared Function AddStatementsWorker(Of TDeclarationNode As SyntaxNode)(
                 destinationMember As TDeclarationNode,
                 statements As IEnumerable(Of SyntaxNode),
-                options As CodeGenerationOptions,
+                options As VisualBasicCodeGenerationOptions,
                 cancellationToken As CancellationToken) As TDeclarationNode
-            Dim location = options.BestLocation
+            Dim location = options.Context.BestLocation
             CheckLocation(destinationMember, location)
 
             Dim token = location.FindToken(cancellationToken)
@@ -482,7 +490,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
 
             Dim statementArray = statements.OfType(Of StatementSyntax).ToArray()
             Dim newBlock As SyntaxNode
-            If options.BeforeThisLocation IsNot Nothing Then
+            If options.Context.BeforeThisLocation IsNot Nothing Then
                 Dim strippedTrivia As ImmutableArray(Of SyntaxTrivia) = Nothing
                 Dim newStatement = VisualBasicFileBannerFacts.Instance.GetNodeWithoutLeadingBannerAndPreprocessorDirectives(
                     oldStatement, strippedTrivia)
@@ -498,9 +506,11 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Return destinationMember.ReplaceNode(oldBlock, newBlock)
         End Function
 
+        ' TODO Change to Not return null (https://github.com/dotnet/roslyn/issues/58243)
         Public Overrides Function CreateMethodDeclaration(method As IMethodSymbol,
                                                           destination As CodeGenerationDestination,
-                                                          options As CodeGenerationOptions) As SyntaxNode
+                                                          options As VisualBasicCodeGenerationOptions,
+                                                          cancellationToken As CancellationToken) As SyntaxNode
             ' Synthesized methods for properties/events are not things we actually generate 
             ' declarations for.
             If method.AssociatedSymbol IsNot Nothing Then
@@ -520,13 +530,15 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
 
         Public Overrides Function CreateEventDeclaration([event] As IEventSymbol,
                                                          destination As CodeGenerationDestination,
-                                                         options As CodeGenerationOptions) As SyntaxNode
+                                                         options As VisualBasicCodeGenerationOptions,
+                                                         cancellationToken As CancellationToken) As SyntaxNode
             Return EventGenerator.GenerateEventDeclaration([event], destination, options)
         End Function
 
         Public Overrides Function CreateFieldDeclaration(field As IFieldSymbol,
                                                          destination As CodeGenerationDestination,
-                                                         options As CodeGenerationOptions) As SyntaxNode
+                                                         options As VisualBasicCodeGenerationOptions,
+                                                         cancellationToken As CancellationToken) As SyntaxNode
             If destination = CodeGenerationDestination.EnumType Then
                 Return EnumMemberGenerator.GenerateEnumMemberDeclaration(field, Nothing, options)
             Else
@@ -536,20 +548,21 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
 
         Public Overrides Function CreatePropertyDeclaration([property] As IPropertySymbol,
                                                             destination As CodeGenerationDestination,
-                                                            options As CodeGenerationOptions) As SyntaxNode
+                                                            options As VisualBasicCodeGenerationOptions,
+                                                            cancellationToken As CancellationToken) As SyntaxNode
             Return PropertyGenerator.GeneratePropertyDeclaration([property], destination, options)
         End Function
 
         Public Overrides Function CreateNamedTypeDeclaration(namedType As INamedTypeSymbol,
                                                              destination As CodeGenerationDestination,
-                                                             options As CodeGenerationOptions,
+                                                             options As VisualBasicCodeGenerationOptions,
                                                              cancellationToken As CancellationToken) As SyntaxNode
             Return NamedTypeGenerator.GenerateNamedTypeDeclaration(Me, namedType, options, cancellationToken)
         End Function
 
         Public Overrides Function CreateNamespaceDeclaration([namespace] As INamespaceSymbol,
                                                              destination As CodeGenerationDestination,
-                                                             options As CodeGenerationOptions,
+                                                             options As VisualBasicCodeGenerationOptions,
                                                              cancellationToken As CancellationToken) As SyntaxNode
             Return NamespaceGenerator.GenerateNamespaceDeclaration(Me, [namespace], options, cancellationToken)
         End Function
@@ -600,7 +613,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Return declaration
         End Function
 
-        Public Overrides Function UpdateDeclarationModifiers(Of TDeclarationNode As SyntaxNode)(declaration As TDeclarationNode, newModifiers As IEnumerable(Of SyntaxToken), options As CodeGenerationOptions, cancellationToken As CancellationToken) As TDeclarationNode
+        Public Overrides Function UpdateDeclarationModifiers(Of TDeclarationNode As SyntaxNode)(declaration As TDeclarationNode, newModifiers As IEnumerable(Of SyntaxToken), options As VisualBasicCodeGenerationOptions, cancellationToken As CancellationToken) As TDeclarationNode
             Dim computeNewModifiersList As Func(Of SyntaxTokenList, SyntaxTokenList) = Function(modifiersList As SyntaxTokenList)
                                                                                            Return SyntaxFactory.TokenList(newModifiers)
                                                                                        End Function
@@ -608,7 +621,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Return UpdateDeclarationModifiers(declaration, computeNewModifiersList)
         End Function
 
-        Public Overrides Function UpdateDeclarationAccessibility(Of TDeclarationNode As SyntaxNode)(declaration As TDeclarationNode, newAccessibility As Accessibility, options As CodeGenerationOptions, cancellationToken As CancellationToken) As TDeclarationNode
+        Public Overrides Function UpdateDeclarationAccessibility(Of TDeclarationNode As SyntaxNode)(declaration As TDeclarationNode, newAccessibility As Accessibility, options As VisualBasicCodeGenerationOptions, cancellationToken As CancellationToken) As TDeclarationNode
             Dim computeNewModifiersList As Func(Of SyntaxTokenList, SyntaxTokenList) = Function(modifiersList As SyntaxTokenList)
                                                                                            Return UpdateDeclarationAccessibility(modifiersList, newAccessibility, options)
                                                                                        End Function
@@ -616,7 +629,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Return UpdateDeclarationModifiers(declaration, computeNewModifiersList)
         End Function
 
-        Private Overloads Shared Function UpdateDeclarationAccessibility(modifiersList As SyntaxTokenList, newAccessibility As Accessibility, options As CodeGenerationOptions) As SyntaxTokenList
+        Private Overloads Shared Function UpdateDeclarationAccessibility(modifiersList As SyntaxTokenList, newAccessibility As Accessibility, options As VisualBasicCodeGenerationOptions) As SyntaxTokenList
             Dim newModifierTokens As ArrayBuilder(Of SyntaxToken) = Nothing
             Using x = ArrayBuilder(Of SyntaxToken).GetInstance(newModifierTokens)
                 AddAccessibilityModifiers(newAccessibility, newModifierTokens, CodeGenerationDestination.Unspecified, options, Accessibility.NotApplicable)
@@ -663,7 +676,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             End Select
         End Function
 
-        Public Overrides Function UpdateDeclarationType(Of TDeclarationNode As SyntaxNode)(declaration As TDeclarationNode, newType As ITypeSymbol, options As CodeGenerationOptions, cancellationToken As CancellationToken) As TDeclarationNode
+        Public Overrides Function UpdateDeclarationType(Of TDeclarationNode As SyntaxNode)(declaration As TDeclarationNode, newType As ITypeSymbol, options As VisualBasicCodeGenerationOptions, cancellationToken As CancellationToken) As TDeclarationNode
             Dim syntaxNode = TryCast(declaration, VisualBasicSyntaxNode)
             If syntaxNode Is Nothing Then
                 Return declaration
@@ -725,7 +738,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             End Select
         End Function
 
-        Public Overrides Function UpdateDeclarationMembers(Of TDeclarationNode As SyntaxNode)(declaration As TDeclarationNode, newMembers As IList(Of ISymbol), Optional options As CodeGenerationOptions = Nothing, Optional cancellationToken As CancellationToken = Nothing) As TDeclarationNode
+        Public Overrides Function UpdateDeclarationMembers(Of TDeclarationNode As SyntaxNode)(declaration As TDeclarationNode, newMembers As IList(Of ISymbol), options As VisualBasicCodeGenerationOptions, cancellationToken As CancellationToken) As TDeclarationNode
             Dim syntaxNode = TryCast(declaration, VisualBasicSyntaxNode)
             If syntaxNode IsNot Nothing Then
                 Select Case syntaxNode.Kind
diff --git a/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb b/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb
index 27fc75c4dd436..a5704f56aa2bc 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb
@@ -1411,32 +1411,30 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
         End Function
 
         Friend Overrides Function AsInterfaceMember(node As SyntaxNode) As SyntaxNode
-            If node IsNot Nothing Then
-                Select Case node.Kind
-                    Case SyntaxKind.FunctionBlock,
-                     SyntaxKind.SubBlock
-                        Return AsInterfaceMember(DirectCast(node, MethodBlockSyntax).BlockStatement)
-                    Case SyntaxKind.FunctionStatement,
-                     SyntaxKind.SubStatement
-                        Return Isolate(node, Function(d) DirectCast(d, MethodStatementSyntax).WithModifiers(Nothing))
-                    Case SyntaxKind.PropertyBlock
-                        Return AsInterfaceMember(DirectCast(node, PropertyBlockSyntax).PropertyStatement)
-                    Case SyntaxKind.PropertyStatement
-                        Return Isolate(
-                            node,
-                            Function(d)
-                                Dim propertyStatement = DirectCast(d, PropertyStatementSyntax)
-                                Dim mods = SyntaxFactory.TokenList(propertyStatement.Modifiers.Where(Function(tk) tk.IsKind(SyntaxKind.ReadOnlyKeyword) Or tk.IsKind(SyntaxKind.DefaultKeyword)))
-                                Return propertyStatement.WithModifiers(mods)
-                            End Function)
-                    Case SyntaxKind.EventBlock
-                        Return AsInterfaceMember(DirectCast(node, EventBlockSyntax).EventStatement)
-                    Case SyntaxKind.EventStatement
-                        Return Isolate(node, Function(d) DirectCast(d, EventStatementSyntax).WithModifiers(Nothing).WithCustomKeyword(Nothing))
-                End Select
-            End If
-
-            Return Nothing
+            Select Case node.Kind
+                Case SyntaxKind.FunctionBlock,
+                 SyntaxKind.SubBlock
+                    Return AsInterfaceMember(DirectCast(node, MethodBlockSyntax).BlockStatement)
+                Case SyntaxKind.FunctionStatement,
+                 SyntaxKind.SubStatement
+                    Return Isolate(node, Function(d) DirectCast(d, MethodStatementSyntax).WithModifiers(Nothing))
+                Case SyntaxKind.PropertyBlock
+                    Return AsInterfaceMember(DirectCast(node, PropertyBlockSyntax).PropertyStatement)
+                Case SyntaxKind.PropertyStatement
+                    Return Isolate(
+                        node,
+                        Function(d)
+                            Dim propertyStatement = DirectCast(d, PropertyStatementSyntax)
+                            Dim mods = SyntaxFactory.TokenList(propertyStatement.Modifiers.Where(Function(tk) tk.IsKind(SyntaxKind.ReadOnlyKeyword) Or tk.IsKind(SyntaxKind.DefaultKeyword)))
+                            Return propertyStatement.WithModifiers(mods)
+                        End Function)
+                Case SyntaxKind.EventBlock
+                    Return AsInterfaceMember(DirectCast(node, EventBlockSyntax).EventStatement)
+                Case SyntaxKind.EventStatement
+                    Return Isolate(node, Function(d) DirectCast(d, EventStatementSyntax).WithModifiers(Nothing).WithCustomKeyword(Nothing))
+                Case Else
+                    Throw ExceptionUtilities.UnexpectedValue(node.Kind)
+            End Select
         End Function
 
         Public Overrides Function EnumDeclaration(

From f29f93714d222888c232f34fe05165eafafe8ff7 Mon Sep 17 00:00:00 2001
From: Newell Clark <newellofthefuture@gmail.com>
Date: Tue, 11 Jan 2022 17:08:53 -0500
Subject: [PATCH 310/444] Use ReadOnlySpan properties over array fields
 (#56845)

---
 .../CSharp/Portable/Parser/QuickScanner.cs    |   6 +-
 .../PEWriter/InstructionOperandTypes.cs       |   5 +-
 .../Core/Portable/Xml/XmlCharType.cs          |  22 ++--
 src/Compilers/Test/Core/Assert/AssertEx.cs    | 112 ++++++++++++++++++
 4 files changed, 129 insertions(+), 16 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Parser/QuickScanner.cs b/src/Compilers/CSharp/Portable/Parser/QuickScanner.cs
index 4acec774daedb..8c409c7588fa3 100644
--- a/src/Compilers/CSharp/Portable/Parser/QuickScanner.cs
+++ b/src/Compilers/CSharp/Portable/Parser/QuickScanner.cs
@@ -206,14 +206,14 @@ private SyntaxToken QuickScanSyntaxToken()
 
             //localize frequently accessed fields
             var charWindow = TextWindow.CharacterWindow;
-            var charPropLength = s_charProperties.Length;
+            var charPropLength = CharProperties.Length;
 
             for (; i < n; i++)
             {
                 char c = charWindow[i];
                 int uc = unchecked((int)c);
 
-                var flags = uc < charPropLength ? (CharFlags)s_charProperties[uc] : CharFlags.Complex;
+                var flags = uc < charPropLength ? (CharFlags)CharProperties[uc] : CharFlags.Complex;
 
                 state = (QuickScanState)s_stateTransitions[(int)state, (int)flags];
                 // NOTE: that Bad > Done and it is the only state like that
@@ -273,7 +273,7 @@ private SyntaxToken CreateQuickToken()
         // # is marked complex as it may start directives.
         // PERF: Use byte instead of CharFlags so the compiler can use array literal initialization.
         //       The most natural type choice, Enum arrays, are not blittable due to a CLR limitation.
-        private static readonly byte[] s_charProperties = new[]
+        private static ReadOnlySpan<byte> CharProperties => new[]
         {
             // 0 .. 31
             (byte)CharFlags.Complex, (byte)CharFlags.Complex, (byte)CharFlags.Complex, (byte)CharFlags.Complex, (byte)CharFlags.Complex, (byte)CharFlags.Complex, (byte)CharFlags.Complex, (byte)CharFlags.Complex,
diff --git a/src/Compilers/Core/Portable/PEWriter/InstructionOperandTypes.cs b/src/Compilers/Core/Portable/PEWriter/InstructionOperandTypes.cs
index 4b34937925f21..dee800b95225f 100644
--- a/src/Compilers/Core/Portable/PEWriter/InstructionOperandTypes.cs
+++ b/src/Compilers/Core/Portable/PEWriter/InstructionOperandTypes.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.Reflection.Emit;
 
@@ -23,7 +24,7 @@ internal static OperandType ReadOperandType(ImmutableArray<byte> il, ref int pos
         }
 
         // internal for testing
-        internal static readonly byte[] OneByte = new byte[]
+        internal static ReadOnlySpan<byte> OneByte => new byte[]
         {
             (byte)OperandType.InlineNone,           // nop
             (byte)OperandType.InlineNone,           // break
@@ -283,7 +284,7 @@ internal static OperandType ReadOperandType(ImmutableArray<byte> il, ref int pos
         };
 
         // internal for testing
-        internal static readonly byte[] TwoByte = new byte[]
+        internal static ReadOnlySpan<byte> TwoByte => new byte[]
         {
             (byte)OperandType.InlineNone,           // arglist           (0xfe 0x00)
             (byte)OperandType.InlineNone,           // ceq
diff --git a/src/Compilers/Core/Portable/Xml/XmlCharType.cs b/src/Compilers/Core/Portable/Xml/XmlCharType.cs
index 79d9ff8d02304..abd100cb5e31f 100644
--- a/src/Compilers/Core/Portable/Xml/XmlCharType.cs
+++ b/src/Compilers/Core/Portable/Xml/XmlCharType.cs
@@ -474,7 +474,7 @@ internal static class XmlCharType
              0xd0, 0xd0, 0xd0, 0xd0, 0xd0, 0xd0, 0x00, 0x00,
         };
 
-        private static byte charProperties(char i)
+        private static byte GetCharProperties(char i)
         {
             // The index entry, table, identifies the start of the appropriate 256-entry table within s_charProperties
             byte table = s_charPropertiesIndex[i >> innerSizeBits];
@@ -910,7 +910,7 @@ private static byte charProperties(char i)
 
         public static bool IsWhiteSpace(char ch)
         {
-            return (charProperties(ch) & fWhitespace) != 0;
+            return (GetCharProperties(ch) & fWhitespace) != 0;
         }
 
         public static bool IsExtender(char ch)
@@ -920,7 +920,7 @@ public static bool IsExtender(char ch)
 
         public static bool IsNCNameSingleChar(char ch)
         {
-            return (charProperties(ch) & fNCNameSC) != 0;
+            return (GetCharProperties(ch) & fNCNameSC) != 0;
         }
 
 #if XML10_FIFTH_EDITION
@@ -955,7 +955,7 @@ public static bool IsNCNameLowSurrogateChar(char lowChar)
 
         public static bool IsStartNCNameSingleChar(char ch)
         {
-            return (charProperties(ch) & fNCStartNameSC) != 0;
+            return (GetCharProperties(ch) & fNCStartNameSC) != 0;
         }
 
 #if XML10_FIFTH_EDITION
@@ -982,7 +982,7 @@ public static bool IsStartNameSingleChar(char ch)
 
         public static bool IsCharData(char ch)
         {
-            return (charProperties(ch) & fCharData) != 0;
+            return (GetCharProperties(ch) & fCharData) != 0;
         }
 
         // [13] PubidChar ::=  #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%] Section 2.3 of spec
@@ -998,26 +998,26 @@ public static bool IsPubidChar(char ch)
         // TextChar = CharData - { 0xA, 0xD, '<', '&', ']' }
         internal static bool IsTextChar(char ch)
         {
-            return (charProperties(ch) & fText) != 0;
+            return (GetCharProperties(ch) & fText) != 0;
         }
 
         // AttrValueChar = CharData - { 0xA, 0xD, 0x9, '<', '>', '&', '\'', '"' }
         internal static bool IsAttributeValueChar(char ch)
         {
-            return (charProperties(ch) & fAttrValue) != 0;
+            return (GetCharProperties(ch) & fAttrValue) != 0;
         }
 
         // XML 1.0 Fourth Edition definitions
         //
         public static bool IsLetter(char ch)
         {
-            return (charProperties(ch) & fLetter) != 0;
+            return (GetCharProperties(ch) & fLetter) != 0;
         }
 
         // This method uses the XML 4th edition name character ranges
         public static bool IsNCNameCharXml4e(char ch)
         {
-            return (charProperties(ch) & fNCNameXml4e) != 0;
+            return (GetCharProperties(ch) & fNCNameXml4e) != 0;
         }
 
         // This method uses the XML 4th edition name character ranges
@@ -1089,7 +1089,7 @@ internal static int IsOnlyWhitespaceWithPos(string str)
             {
                 for (int i = 0; i < str.Length; i++)
                 {
-                    if ((charProperties(str[i]) & fWhitespace) == 0)
+                    if ((GetCharProperties(str[i]) & fWhitespace) == 0)
                     {
                         return i;
                     }
@@ -1104,7 +1104,7 @@ internal static int IsOnlyCharData(string str)
             {
                 for (int i = 0; i < str.Length; i++)
                 {
-                    if ((charProperties(str[i]) & fCharData) == 0)
+                    if ((GetCharProperties(str[i]) & fCharData) == 0)
                     {
                         if (i + 1 >= str.Length || !(XmlCharType.IsHighSurrogate(str[i]) && XmlCharType.IsLowSurrogate(str[i + 1])))
                         {
diff --git a/src/Compilers/Test/Core/Assert/AssertEx.cs b/src/Compilers/Test/Core/Assert/AssertEx.cs
index 10d6b8dadda69..a9f22745e31da 100644
--- a/src/Compilers/Test/Core/Assert/AssertEx.cs
+++ b/src/Compilers/Test/Core/Assert/AssertEx.cs
@@ -234,6 +234,22 @@ public static void Equal<T>(
             Assert.True(false, GetAssertMessage(expected, actual, comparer, message, itemInspector, itemSeparator, expectedValueSourcePath, expectedValueSourceLine));
         }
 
+        public static void Equal<T>(
+            ReadOnlySpan<T> expected,
+            ReadOnlySpan<T> actual,
+            IEqualityComparer<T> comparer = null,
+            string message = null,
+            string itemSeparator = null,
+            Func<T, string> itemInspector = null,
+            string expectedValueSourcePath = null,
+            int expectedValueSourceLine = 0)
+        {
+            if (SequenceEqual(expected, actual, comparer))
+                return;
+
+            Assert.True(false, GetAssertMessage(expected, actual, comparer, message, itemInspector, itemSeparator, expectedValueSourcePath, expectedValueSourceLine));
+        }
+
         /// <summary>
         /// Asserts that two strings are equal, and prints a diff between the two if they are not.
         /// </summary>
@@ -336,6 +352,22 @@ private static bool SequenceEqual<T>(IEnumerable<T> expected, IEnumerable<T> act
             return true;
         }
 
+        private static bool SequenceEqual<T>(ReadOnlySpan<T> expected, ReadOnlySpan<T> actual, IEqualityComparer<T> comparer = null)
+        {
+            if (expected.Length != actual.Length)
+                return false;
+
+            for (int i = 0; i < expected.Length; i++)
+            {
+                if (!(comparer is not null ? comparer.Equals(expected[i], actual[i]) : AssertEqualityComparer<T>.Equals(expected[i], actual[i])))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
         public static void SetEqual(IEnumerable<string> expected, IEnumerable<string> actual, IEqualityComparer<string> comparer = null, string message = null, string itemSeparator = "\r\n", Func<string, string> itemInspector = null)
         {
             var indexes = new Dictionary<string, int>(comparer);
@@ -673,6 +705,86 @@ public static string GetAssertMessage<T>(
             return message.ToString();
         }
 
+        public static string GetAssertMessage<T>(
+            ReadOnlySpan<T> expected,
+            ReadOnlySpan<T> actual,
+            IEqualityComparer<T> comparer = null,
+            string prefix = null,
+            Func<T, string> itemInspector = null,
+            string itemSeparator = null,
+            string expectedValueSourcePath = null,
+            int expectedValueSourceLine = 0)
+        {
+            if (itemInspector == null)
+            {
+                if (typeof(T) == typeof(byte))
+                {
+                    itemInspector = b => $"0x{b:X2}";
+                }
+                else
+                {
+                    itemInspector = new Func<T, string>(obj => (obj != null) ? obj.ToString() : "<null>");
+                }
+            }
+
+            if (itemSeparator == null)
+            {
+                if (typeof(T) == typeof(byte))
+                {
+                    itemSeparator = ", ";
+                }
+                else
+                {
+                    itemSeparator = "," + Environment.NewLine;
+                }
+            }
+
+            const int maxDisplayedExpectedEntries = 10;
+            var expectedString = join(itemSeparator, expected[..Math.Min(expected.Length, maxDisplayedExpectedEntries)], itemInspector);
+            var actualString = join(itemSeparator, actual, itemInspector);
+
+            var message = new StringBuilder();
+
+            if (!string.IsNullOrEmpty(prefix))
+            {
+                message.AppendLine(prefix);
+                message.AppendLine();
+            }
+
+            message.AppendLine("Expected:");
+            message.AppendLine(expectedString);
+            if (expected.Length > maxDisplayedExpectedEntries)
+            {
+                message.AppendLine("... truncated ...");
+            }
+
+            message.AppendLine("Actual:");
+            message.AppendLine(actualString);
+            message.AppendLine("Differences:");
+            message.AppendLine(DiffUtil.DiffReport(expected.ToArray(), actual.ToArray(), itemSeparator, comparer, itemInspector));
+
+            if (TryGenerateExpectedSourceFileAndGetDiffLink(actualString, expected.Length, expectedValueSourcePath, expectedValueSourceLine, out var link))
+            {
+                message.AppendLine(link);
+            }
+
+            return message.ToString();
+
+            static string join(string itemSeparator, ReadOnlySpan<T> items, Func<T, string> itemInspector)
+            {
+                var result = new StringBuilder();
+                var iter = items.GetEnumerator();
+
+                if (iter.MoveNext())
+                    result.Append(itemInspector(iter.Current));
+
+                while (iter.MoveNext())
+                    result.Append($"{itemSeparator}{itemInspector(iter.Current)}");
+
+                return result.ToString();
+            }
+        }
+
         internal static bool TryGenerateExpectedSourceFileAndGetDiffLink(string actualString, int expectedLineCount, string expectedValueSourcePath, int expectedValueSourceLine, out string link)
         {
             // add a link to a .cmd file that opens a diff tool:

From 4c9591cdb17c6cce07040bcefd4ce8f294c50ce4 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Tue, 11 Jan 2022 15:45:15 -0800
Subject: [PATCH 311/444] Add test showing case no longer repros

---
 .../RemoveUnnecessaryCastTests.cs             | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/src/Analyzers/CSharp/Tests/RemoveUnnecessaryCast/RemoveUnnecessaryCastTests.cs b/src/Analyzers/CSharp/Tests/RemoveUnnecessaryCast/RemoveUnnecessaryCastTests.cs
index cc47e2148c401..baa5d6e253b4a 100644
--- a/src/Analyzers/CSharp/Tests/RemoveUnnecessaryCast/RemoveUnnecessaryCastTests.cs
+++ b/src/Analyzers/CSharp/Tests/RemoveUnnecessaryCast/RemoveUnnecessaryCastTests.cs
@@ -12396,5 +12396,52 @@ private C(ReadOnlyMemory<byte>? buffer = null)
                 LanguageVersion = LanguageVersion.CSharp10,
             }.RunAsync();
         }
+
+        [WorkItem(58718, "https://github.com/dotnet/roslyn/issues/58718")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryCast)]
+        public async Task FunctionPointerWithImplicitOperator()
+        {
+            var source = @"
+unsafe
+{
+    PointerDelegate<int, int> dp = (PointerDelegate<int, int>)(&Mtd);
+}
+
+static int Mtd(int arg) => arg;
+
+public readonly struct PointerDelegate<T, TResult>
+{
+    private unsafe readonly delegate*<T,TResult> _pointer;
+
+    public unsafe PointerDelegate(delegate*<T, TResult> pointer)
+    {
+        this._pointer = pointer;
+    }
+
+    public TResult Invoke(T param)
+    {
+        unsafe
+        {
+            return this._pointer(param);
+        }
+    }
+
+    public unsafe static implicit operator PointerDelegate<T, TResult>(delegate*<T, TResult> pointer)
+    {
+        return new(pointer);
+    }
+}
+";
+            await new VerifyCS.Test
+            {
+                TestState =
+                {
+                    OutputKind = OutputKind.ConsoleApplication,
+                },
+                TestCode = source,
+                FixedCode = source,
+                LanguageVersion = LanguageVersion.CSharp10,
+            }.RunAsync();
+        }
     }
 }

From 2eab8221159ca23d2e07df16bdcc1987c59ad20c Mon Sep 17 00:00:00 2001
From: Fred Silberberg <frsilb@microsoft.com>
Date: Tue, 11 Jan 2022 15:58:10 -0800
Subject: [PATCH 312/444] Revert "Implement GetTypesByMetadataName (#58366)"
 (#58784)

This reverts commit fcc0827728b4c39d22f08b725fe32c7188b31030.
---
 .../Symbol/Compilation/CompilationAPITests.cs | 277 ------------------
 .../Core/Portable/Compilation/Compilation.cs  | 105 +------
 .../Core/Portable/PublicAPI.Unshipped.txt     |   1 -
 .../Test/Symbol/CompilationAPITests.vb        | 226 --------------
 .../Core/Extensions/CompilationExtensions.cs  |  51 ++--
 5 files changed, 35 insertions(+), 625 deletions(-)
 delete mode 100644 src/Compilers/VisualBasic/Test/Symbol/CompilationAPITests.vb

diff --git a/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs b/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs
index 6e608104926e4..d1a03c60f4a71 100644
--- a/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs
@@ -3036,282 +3036,5 @@ void M1()
         }
 
         #endregion
-
-        #region GetTypesByMetadataName Tests
-
-        [Fact]
-        public void GetTypesByMetadataName_NotInSourceNotInReferences()
-        {
-            var comp = CreateCompilation("");
-            comp.VerifyDiagnostics();
-
-            var types = comp.GetTypesByMetadataName("N.C`1");
-            Assert.Empty(types);
-        }
-
-        [Theory]
-        [CombinatorialData]
-        public void GetTypesByMetadataName_SingleInSourceNotInReferences(
-            bool useMetadataReference,
-            [CombinatorialValues("public", "internal")] string accessibility)
-        {
-            var referenceComp = CreateCompilation("");
-
-            var comp = CreateCompilation(
-$@"namespace N;
-{accessibility} class C<T> {{}}", new[] { useMetadataReference ? referenceComp.ToMetadataReference() : referenceComp.EmitToImageReference() });
-
-            comp.VerifyDiagnostics();
-
-            var types = comp.GetTypesByMetadataName("N.C`1");
-
-            Assert.Single(types);
-            AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString());
-        }
-
-        [Theory]
-        [CombinatorialData]
-        public void GetTypesByMetadataName_MultipleInSourceNotInReferences(
-            bool useMetadataReference,
-            [CombinatorialValues("public", "internal")] string accessibility)
-        {
-            var referenceComp = CreateCompilation("");
-
-            var comp = CreateCompilation(
-$@"namespace N;
-{accessibility} class C<T> {{}}
-{accessibility} class C<T> {{}}", new[] { useMetadataReference ? referenceComp.ToMetadataReference() : referenceComp.EmitToImageReference() });
-
-            comp.VerifyDiagnostics(
-                // (3,16): error CS0101: The namespace 'N' already contains a definition for 'C'
-                // internal class C<T> {}
-                Diagnostic(ErrorCode.ERR_DuplicateNameInNS, "C").WithArguments("C", "N").WithLocation(3, 8 + accessibility.Length)
-            );
-
-            var types = comp.GetTypesByMetadataName("N.C`1");
-
-            Assert.Single(types);
-            AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString());
-            Assert.Equal(2, types[0].Locations.Length);
-        }
-
-        [Theory]
-        [CombinatorialData]
-        public void GetTypesByMetadataName_SingleInSourceSingleInReferences(
-            bool useMetadataReference,
-            [CombinatorialValues("public", "internal")] string accessibility)
-        {
-            string source = $@"namespace N;
-{accessibility} class C<T> {{}}";
-
-            var referenceComp = CreateCompilation(source);
-
-            referenceComp.VerifyDiagnostics();
-
-            MetadataReference reference = useMetadataReference ? referenceComp.ToMetadataReference() : referenceComp.EmitToImageReference();
-            var comp = CreateCompilation(source, new[] { reference });
-            comp.VerifyDiagnostics();
-
-            var types = comp.GetTypesByMetadataName("N.C`1");
-
-            Assert.Equal(2, types.Length);
-            AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString());
-            Assert.Same(comp.Assembly.GetPublicSymbol(), types[0].ContainingAssembly);
-            AssertEx.Equal("N.C<T>", types[1].ToTestDisplayString());
-
-            var assembly1 = comp.GetAssemblyOrModuleSymbol(reference).GetPublicSymbol();
-            Assert.Same(types[1].ContainingAssembly, assembly1);
-        }
-
-        [Theory]
-        [CombinatorialData]
-        public void GetTypesByMetadataName_NotInSourceSingleInReferences(
-            bool useMetadataReference,
-            [CombinatorialValues("public", "internal")] string accessibility)
-        {
-            string source = @$"namespace N;
-{accessibility} class C<T> {{}}";
-
-            var referenceComp = CreateCompilation(source);
-
-            referenceComp.VerifyDiagnostics();
-
-            MetadataReference reference = useMetadataReference ? referenceComp.ToMetadataReference() : referenceComp.EmitToImageReference();
-            var comp = CreateCompilation("", new[] { reference });
-            comp.VerifyDiagnostics();
-
-            var types = comp.GetTypesByMetadataName("N.C`1");
-
-
-            Assert.Single(types);
-            AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString());
-
-            var assembly1 = comp.GetAssemblyOrModuleSymbol(reference).GetPublicSymbol();
-            Assert.Same(types[0].ContainingAssembly, assembly1);
-        }
-
-        [Theory]
-        [CombinatorialData]
-        public void GetTypesByMetadataName_NotInSourceMultipleInReferences(
-            bool useMetadataReference,
-            [CombinatorialValues("public", "internal")] string accessibility)
-        {
-            string source = @$"namespace N;
-{accessibility} class C<T> {{}}";
-
-            var referenceComp1 = CreateCompilation(source);
-            referenceComp1.VerifyDiagnostics();
-
-            var referenceComp2 = CreateCompilation(source);
-            referenceComp2.VerifyDiagnostics();
-
-            MetadataReference reference1 = getReference(referenceComp1);
-            MetadataReference reference2 = getReference(referenceComp2);
-            var comp = CreateCompilation("", new[] { reference1, reference2 });
-            comp.VerifyDiagnostics();
-
-            var types = comp.GetTypesByMetadataName("N.C`1");
-
-            Assert.Equal(2, types.Length);
-            AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString());
-            AssertEx.Equal("N.C<T>", types[1].ToTestDisplayString());
-
-            var assembly1 = comp.GetAssemblyOrModuleSymbol(reference1).GetPublicSymbol();
-            Assert.Same(types[0].ContainingAssembly, assembly1);
-
-            var assembly2 = comp.GetAssemblyOrModuleSymbol(reference2).GetPublicSymbol();
-            Assert.Same(types[1].ContainingAssembly, assembly2);
-
-            MetadataReference getReference(CSharpCompilation referenceComp1)
-            {
-                return useMetadataReference ? referenceComp1.ToMetadataReference() : referenceComp1.EmitToImageReference();
-            }
-        }
-
-        [Theory]
-        [CombinatorialData]
-        public void GetTypesByMetadataName_SingleInSourceMultipleInReferences(
-            bool useMetadataReference,
-            [CombinatorialValues("public", "internal")] string accessibility)
-        {
-            string source = @$"namespace N;
-{accessibility} class C<T> {{}}";
-
-            var referenceComp1 = CreateCompilation(source);
-            referenceComp1.VerifyDiagnostics();
-
-            var referenceComp2 = CreateCompilation(source);
-            referenceComp2.VerifyDiagnostics();
-
-            MetadataReference reference1 = getReference(referenceComp1);
-            MetadataReference reference2 = getReference(referenceComp2);
-            var comp = CreateCompilation(source, new[] { reference1, reference2 });
-            comp.VerifyDiagnostics();
-
-            var types = comp.GetTypesByMetadataName("N.C`1");
-
-            Assert.Equal(3, types.Length);
-            AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString());
-            Assert.Same(comp.Assembly.GetPublicSymbol(), types[0].ContainingAssembly);
-            AssertEx.Equal("N.C<T>", types[1].ToTestDisplayString());
-            AssertEx.Equal("N.C<T>", types[2].ToTestDisplayString());
-
-            var assembly1 = comp.GetAssemblyOrModuleSymbol(reference1).GetPublicSymbol();
-            Assert.Same(types[1].ContainingAssembly, assembly1);
-
-            var assembly2 = comp.GetAssemblyOrModuleSymbol(reference2).GetPublicSymbol();
-            Assert.Same(types[2].ContainingAssembly, assembly2);
-
-            MetadataReference getReference(CSharpCompilation referenceComp1)
-            {
-                return useMetadataReference ? referenceComp1.ToMetadataReference() : referenceComp1.EmitToImageReference();
-            }
-        }
-
-        [Fact]
-        public void GetTypesByMetadataName_Ordering()
-        {
-            var corlibSource = @"
-namespace System
-{
-    public class Object {}
-    public class Void {}
-}
-
-public class C {}
-";
-
-            var corlib = CreateEmptyCompilation(corlibSource);
-            var corlibReference = corlib.EmitToImageReference();
-
-            var other = CreateEmptyCompilation(@"public class C {}", new[] { corlibReference });
-            var otherReference = other.EmitToImageReference();
-
-            var current = CreateEmptyCompilation(@"public class C {}", new[] { otherReference, corlibReference });
-            current.VerifyDiagnostics();
-
-            var types = current.GetTypesByMetadataName("C");
-
-            AssertEx.Equal(types.Select(t => t.ToTestDisplayString()), new[] { "C", "C", "C" });
-            Assert.Same(types[0].ContainingAssembly, current.Assembly.GetPublicSymbol());
-
-            var corlibAssembly = current.GetAssemblyOrModuleSymbol(corlibReference).GetPublicSymbol();
-            Assert.Same(types[1].ContainingAssembly, corlibAssembly);
-
-            var otherAssembly = current.GetAssemblyOrModuleSymbol(otherReference).GetPublicSymbol();
-            Assert.Same(types[2].ContainingAssembly, otherAssembly);
-        }
-
-        [Fact]
-        public void GetTypeByMetadataName_CorLibViaExtern()
-        {
-            var corlibSource = @"
-namespace System
-{
-    public class Object {}
-    public class Void {}
-}
-
-public class C {}
-";
-
-            var corlib = CreateEmptyCompilation(corlibSource);
-            var corlibReference = corlib.EmitToImageReference(aliases: ImmutableArray.Create("corlib"));
-
-            var current = CreateEmptyCompilation(@"", new[] { corlibReference });
-            current.VerifyDiagnostics();
-
-            var type = ((Compilation)current).GetTypeByMetadataName("C");
-            Assert.NotNull(type);
-
-            var corlibAssembly = current.GetAssemblyOrModuleSymbol(corlibReference).GetPublicSymbol();
-            Assert.Same(type.ContainingAssembly, corlibAssembly);
-        }
-
-        [Fact]
-        public void GetTypeByMetadataName_OtherViaExtern()
-        {
-            var corlibSource = @"
-namespace System
-{
-    public class Object {}
-    public class Void {}
-}
-";
-
-            var corlib = CreateEmptyCompilation(corlibSource);
-            var corlibReference = corlib.EmitToImageReference();
-
-            var other = CreateEmptyCompilation(@"public class C {}", new[] { corlibReference });
-            var otherReference = other.EmitToImageReference(aliases: ImmutableArray.Create("other"));
-
-            var current = CreateEmptyCompilation(@"", new[] { otherReference, corlibReference });
-            current.VerifyDiagnostics();
-
-            var type = ((Compilation)current).GetTypeByMetadataName("C");
-            Assert.Null(type);
-        }
-
-        #endregion
     }
 }
diff --git a/src/Compilers/Core/Portable/Compilation/Compilation.cs b/src/Compilers/Core/Portable/Compilation/Compilation.cs
index d48762238a837..037ea63240a7d 100644
--- a/src/Compilers/Core/Portable/Compilation/Compilation.cs
+++ b/src/Compilers/Core/Portable/Compilation/Compilation.cs
@@ -1025,122 +1025,28 @@ public INamedTypeSymbol CreateNativeIntegerTypeSymbol(bool signed)
         private readonly ConcurrentCache<string, INamedTypeSymbol?> _getTypeCache =
             new ConcurrentCache<string, INamedTypeSymbol?>(50, ReferenceEqualityComparer.Instance);
 
-        private readonly ConcurrentCache<string, ImmutableArray<INamedTypeSymbol>> _getTypesCache =
-            new ConcurrentCache<string, ImmutableArray<INamedTypeSymbol>>(50, ReferenceEqualityComparer.Instance);
-
         /// <summary>
         /// Gets the type within the compilation's assembly and all referenced assemblies (other than
         /// those that can only be referenced via an extern alias) using its canonical CLR metadata name.
-        /// This lookup follows the following order:
-        /// <list type="number">
-        /// <item><description>If the type is found in the compilation's assembly, that type is returned.</description></item>
-        /// <item><description>
-        /// Next, the core library (the library that defines <c>System.Object</c> and has no assembly references) is searched.
-        /// If the type is found there, that type is returned.
-        /// </description></item>
-        /// <item><description>
-        /// Finally, all remaining referenced non-extern assemblies are searched. If one and only one type matching the provided metadata name is found, that
-        /// single type is returned. Accessibility is ignored for this check.
-        /// </description></item>
-        /// </list>
-        /// </summary>
-        /// <returns>Null if the type can't be found or there was an ambiguity during lookup.</returns>
+        /// </summary>
+        /// <returns>Null if the type can't be found.</returns>
         /// <remarks>
-        /// <para>
         /// Since VB does not have the concept of extern aliases, it considers all referenced assemblies.
-        /// </para>
-        /// <para>
-        /// In C#, if the core library is referenced as an extern assembly, it will be searched. All other extern-aliased assemblies will not be searched.
-        /// </para>
-        /// <para>
-        /// Because accessibility to the current assembly is ignored when searching for types that match the provided metadata name, if multiple referenced
-        /// assemblies define the same type symbol (as often happens when users copy well-known types from the BCL or other sources) then this API will return null,
-        /// even if all but one of those symbols would be otherwise inaccessible to user-written code in the current assembly. For fine-grained control over ambiguity
-        /// resolution, consider using <see cref="GetTypesByMetadataName(string)" /> instead and filtering the results for the symbol required.
-        /// </para>
-        /// <para>
-        /// Assemblies can contain multiple modules. Within each assembly, the search is performed based on module's position in the module list of that assembly. When
-        /// a match is found in one module in an assembly, no further modules within that assembly are searched.
-        /// </para>
-        /// <para>Type forwarders are ignored, and not considered part of the assembly where the TypeForwardAttribute is written.</para>
         /// </remarks>
         public INamedTypeSymbol? GetTypeByMetadataName(string fullyQualifiedMetadataName)
         {
             if (!_getTypeCache.TryGetValue(fullyQualifiedMetadataName, out INamedTypeSymbol? val))
             {
                 val = CommonGetTypeByMetadataName(fullyQualifiedMetadataName);
-                var result = _getTypeCache.TryAdd(fullyQualifiedMetadataName, val);
-                Debug.Assert(result || (_getTypeCache.TryGetValue(fullyQualifiedMetadataName, out var addedType) && ReferenceEquals(addedType, val)));
+                // Ignore if someone added the same value before us
+                _ = _getTypeCache.TryAdd(fullyQualifiedMetadataName, val);
             }
             return val;
         }
 
         protected abstract INamedTypeSymbol? CommonGetTypeByMetadataName(string metadataName);
 
-        /// <summary>
-        /// Gets all types with the compilation's assembly and all referenced assemblies that have the
-        /// given canonical CLR metadata name. Accessibility to the current assembly is ignored when
-        /// searching for matching type names.
-        /// </summary>
-        /// <returns>Empty array if no types match. Otherwise, all types that match the name, current assembly first if present.</returns>
-        /// <remarks>
-        /// <para>
-        /// Assemblies can contain multiple modules. Within each assembly, the search is performed based on module's position in the module list of that assembly. When
-        /// a match is found in one module in an assembly, no further modules within that assembly are searched.
-        /// </para>
-        /// <para>Type forwarders are ignored, and not considered part of the assembly where the TypeForwardAttribute is written.</para>
-        /// </remarks>
-        public ImmutableArray<INamedTypeSymbol> GetTypesByMetadataName(string fullyQualifiedMetadataName)
-        {
-            if (!_getTypesCache.TryGetValue(fullyQualifiedMetadataName, out ImmutableArray<INamedTypeSymbol> val))
-            {
-                val = getTypesByMetadataNameImpl();
-                var result = _getTypesCache.TryAdd(fullyQualifiedMetadataName, val);
-                Debug.Assert(result
-                    || (_getTypesCache.TryGetValue(fullyQualifiedMetadataName, out var addedArray)
-                        && Enumerable.SequenceEqual(addedArray, val, ReferenceEqualityComparer.Instance)));
-            }
-
-            return val;
-
-            ImmutableArray<INamedTypeSymbol> getTypesByMetadataNameImpl()
-            {
-                ArrayBuilder<INamedTypeSymbol>? typesByMetadataName = null;
-
-                // Start with the current assembly, then corlib, then look through all references, to mimic GetTypeByMetadataName search order.
-
-                addIfNotNull(Assembly.GetTypeByMetadataName(fullyQualifiedMetadataName));
-
-                var corLib = ObjectType.ContainingAssembly;
-
-                if (!ReferenceEquals(corLib, Assembly))
-                {
-                    addIfNotNull(corLib.GetTypeByMetadataName(fullyQualifiedMetadataName));
-                }
-
-                foreach (var referencedAssembly in SourceModule.ReferencedAssemblySymbols)
-                {
-                    if (ReferenceEquals(referencedAssembly, corLib))
-                    {
-                        continue;
-                    }
-
-                    addIfNotNull(referencedAssembly.GetTypeByMetadataName(fullyQualifiedMetadataName));
-                }
-
-                return typesByMetadataName?.ToImmutableAndFree() ?? ImmutableArray<INamedTypeSymbol>.Empty;
-
-                void addIfNotNull(INamedTypeSymbol? toAdd)
-                {
-                    if (toAdd != null)
-                    {
-                        typesByMetadataName ??= ArrayBuilder<INamedTypeSymbol>.GetInstance();
-                        typesByMetadataName.Add(toAdd);
-                    }
-                }
-            }
-        }
-
+#pragma warning disable RS0026 // Do not add multiple public overloads with optional parameters
         /// <summary>
         /// Returns a new INamedTypeSymbol with the given element types and
         /// (optional) element names, locations, and nullable annotations.
@@ -1181,6 +1087,7 @@ public INamedTypeSymbol CreateTupleTypeSymbol(
 
             return CommonCreateTupleTypeSymbol(elementTypes, elementNames, elementLocations, elementNullableAnnotations);
         }
+#pragma warning restore RS0026 // Do not add multiple public overloads with optional parameters
 
         /// <summary>
         /// Returns a new INamedTypeSymbol with the given element types, names, and locations.
diff --git a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
index ad76fcb80cd4d..02161a15fe460 100644
--- a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
+++ b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
@@ -9,7 +9,6 @@ const Microsoft.CodeAnalysis.WellKnownGeneratorOutputs.ImplementationSourceOutpu
 const Microsoft.CodeAnalysis.WellKnownGeneratorOutputs.SourceOutput = "SourceOutput" -> string!
 const Microsoft.CodeAnalysis.WellKnownMemberNames.PrintMembersMethodName = "PrintMembers" -> string!
 Microsoft.CodeAnalysis.Compilation.EmitDifference(Microsoft.CodeAnalysis.Emit.EmitBaseline! baseline, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.Emit.SemanticEdit>! edits, System.Func<Microsoft.CodeAnalysis.ISymbol!, bool>! isAddedSymbol, System.IO.Stream! metadataStream, System.IO.Stream! ilStream, System.IO.Stream! pdbStream, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.Emit.EmitDifferenceResult!
-Microsoft.CodeAnalysis.Compilation.GetTypesByMetadataName(string! fullyQualifiedMetadataName) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.INamedTypeSymbol!>
 Microsoft.CodeAnalysis.Emit.EmitDifferenceResult.ChangedTypes.get -> System.Collections.Immutable.ImmutableArray<System.Reflection.Metadata.TypeDefinitionHandle>
 Microsoft.CodeAnalysis.Emit.EmitDifferenceResult.UpdatedMethods.get -> System.Collections.Immutable.ImmutableArray<System.Reflection.Metadata.MethodDefinitionHandle>
 Microsoft.CodeAnalysis.Emit.SemanticEditKind.Replace = 4 -> Microsoft.CodeAnalysis.Emit.SemanticEditKind
diff --git a/src/Compilers/VisualBasic/Test/Symbol/CompilationAPITests.vb b/src/Compilers/VisualBasic/Test/Symbol/CompilationAPITests.vb
deleted file mode 100644
index b0f3ed506cc9f..0000000000000
--- a/src/Compilers/VisualBasic/Test/Symbol/CompilationAPITests.vb
+++ /dev/null
@@ -1,226 +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.
-
-Imports Microsoft.CodeAnalysis.Test.Utilities
-Imports Roslyn.Test.Utilities
-
-Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests
-
-    Public Class CompilationAPITests
-        Inherits BasicTestBase
-
-        <Fact()>
-        Public Sub GetTypesByMetadataName_NotInSourceNotInReferences()
-            Dim comp = CreateCompilation("")
-            comp.AssertNoDiagnostics()
-
-            Dim types = comp.GetTypesByMetadataName("N.C`1")
-            Assert.Empty(types)
-        End Sub
-
-        <Theory, CombinatorialData>
-        Public Sub GetTypesByMetadataName_SingleInSourceNotInReferences(useMetadataReferences As Boolean, <CombinatorialValues("Public", "Friend")> accessibility As String)
-            Dim referenceComp = CreateCompilation("")
-
-            Dim source =
-$"Namespace N
-    {accessibility} Class C(Of T)
-    End Class
-End Namespace"
-
-            Dim comp = CreateCompilation(source, {If(useMetadataReferences, referenceComp.ToMetadataReference(), referenceComp.EmitToImageReference())})
-            comp.AssertNoDiagnostics()
-
-            Dim types = comp.GetTypesByMetadataName("N.C`1")
-
-            Assert.Single(types)
-            AssertEx.Equal("N.C(Of T)", types(0).ToTestDisplayString())
-        End Sub
-
-        <Theory, CombinatorialData>
-        Public Sub GetTypesByMetadataName_MultipleInSourceNotInReferences(useMetadataReferences As Boolean, <CombinatorialValues("Public", "Friend")> accessibility As String)
-            Dim referenceComp = CreateCompilation("")
-
-            Dim source =
-$"Namespace N
-    {accessibility} Class C(Of T)
-    End Class
-    {accessibility} Class C(Of T)
-    End Class
-End Namespace"
-
-            Dim comp = CreateCompilation(source, {If(useMetadataReferences, referenceComp.ToMetadataReference(), referenceComp.EmitToImageReference())})
-            comp.AssertTheseDiagnostics(
-<expected>
-BC30179: class 'C' and class 'C' conflict in namespace 'N'.
-    <%= accessibility %> Class C(Of T)
-                 ~
-</expected>)
-
-            Dim types = comp.GetTypesByMetadataName("N.C`1")
-
-            Assert.Single(types)
-            AssertEx.Equal("N.C(Of T)", types(0).ToTestDisplayString())
-            Assert.Equal(2, types(0).Locations.Length)
-        End Sub
-
-        <Theory, CombinatorialData>
-        Public Sub GetTypesByMetadataName_SingleInSourceSingleInReferences(useMetadataReference As Boolean, <CombinatorialValues("Public", "Friend")> accessibility As String)
-            Dim source =
-$"Namespace N
-    {accessibility} Class C(Of T)
-    End Class
-End Namespace"
-
-            Dim referenceComp = CreateCompilation(source)
-            Dim reference As MetadataReference = If(useMetadataReference, referenceComp.ToMetadataReference(), referenceComp.EmitToImageReference())
-            Dim comp = CreateCompilation(source, {reference})
-            comp.AssertNoDiagnostics()
-
-            Dim types = comp.GetTypesByMetadataName("N.C`1")
-
-            Assert.Equal(2, types.Length)
-            AssertEx.Equal("N.C(Of T)", types(0).ToTestDisplayString())
-            Assert.Same(comp.Assembly, types(0).ContainingAssembly)
-            AssertEx.Equal("N.C(Of T)", types(1).ToTestDisplayString())
-
-            Dim referenceAssembly = comp.GetAssemblyOrModuleSymbol(reference)
-            Assert.Same(types(1).ContainingAssembly, referenceAssembly)
-        End Sub
-
-        <Theory, CombinatorialData>
-        Public Sub GetTypesByMetadataName_NotInSourceSingleInReferences(useMetadataReference As Boolean, <CombinatorialValues("Public", "Friend")> accessibility As String)
-            Dim source =
-$"Namespace N
-    {accessibility} Class C(Of T)
-    End Class
-End Namespace"
-
-            Dim referenceComp = CreateCompilation(source)
-            Dim reference As MetadataReference = GetReference(useMetadataReference, referenceComp)
-            Dim comp = CreateCompilation("", {reference})
-            comp.AssertNoDiagnostics()
-
-            Dim types = comp.GetTypesByMetadataName("N.C`1")
-
-            Assert.Single(types)
-            AssertEx.Equal("N.C(Of T)", types(0).ToTestDisplayString())
-
-            Dim referenceAssembly = comp.GetAssemblyOrModuleSymbol(reference)
-            Assert.Same(types(0).ContainingAssembly, referenceAssembly)
-        End Sub
-
-        Private Shared Function GetReference(useMetadataReference As Boolean, referenceComp As VisualBasicCompilation) As MetadataReference
-            Return If(useMetadataReference, referenceComp.ToMetadataReference(), referenceComp.EmitToImageReference())
-        End Function
-
-        <Theory, CombinatorialData>
-        Public Sub GetTypesByMetadataName_NotInSourceMultipleInReferences(useMetadataReference As Boolean, <CombinatorialValues("Public", "Friend")> accessibility As String)
-            Dim source =
-$"Namespace N
-    {accessibility} Class C(Of T)
-    End Class
-End Namespace"
-
-            Dim referenceComp1 = CreateCompilation(source)
-            Dim referenceComp2 = CreateCompilation(source)
-            Dim reference1 As MetadataReference = GetReference(useMetadataReference, referenceComp1)
-            Dim reference2 As MetadataReference = GetReference(useMetadataReference, referenceComp2)
-            Dim comp = CreateCompilation("", {reference1, reference2})
-            comp.AssertNoDiagnostics()
-
-            Dim types = comp.GetTypesByMetadataName("N.C`1")
-
-            Assert.Equal(2, types.Length)
-            AssertEx.Equal("N.C(Of T)", types(0).ToTestDisplayString())
-            AssertEx.Equal("N.C(Of T)", types(1).ToTestDisplayString())
-
-            Dim referenceAssembly1 = comp.GetAssemblyOrModuleSymbol(reference1)
-            Assert.Same(types(0).ContainingAssembly, referenceAssembly1)
-
-            Dim referenceAssembly2 = comp.GetAssemblyOrModuleSymbol(reference2)
-            Assert.Same(types(1).ContainingAssembly, referenceAssembly2)
-
-            If (useMetadataReference) Then
-            Else
-                Assert.False(types(0).IsInSource())
-                Assert.False(types(1).IsInSource())
-            End If
-        End Sub
-
-        <Theory, CombinatorialData>
-        Public Sub GetTypesByMetadataName_SingleInSourceMultipleInReferences(useMetadataReference As Boolean, <CombinatorialValues("Public", "Friend")> accessibility As String)
-            Dim source =
-$"Namespace N
-    {accessibility} Class C(Of T)
-    End Class
-End Namespace"
-
-            Dim referenceComp1 = CreateCompilation(source)
-            Dim referenceComp2 = CreateCompilation(source)
-            Dim reference1 As MetadataReference = GetReference(useMetadataReference, referenceComp1)
-            Dim reference2 As MetadataReference = GetReference(useMetadataReference, referenceComp2)
-            Dim comp = CreateCompilation(source, {reference1, reference2})
-            comp.AssertNoDiagnostics()
-
-            Dim types = comp.GetTypesByMetadataName("N.C`1")
-
-            Assert.Equal(3, types.Length)
-            AssertEx.Equal("N.C(Of T)", types(0).ToTestDisplayString())
-            Assert.Same(comp.Assembly, types(0).ContainingAssembly)
-            AssertEx.Equal("N.C(Of T)", types(1).ToTestDisplayString())
-            AssertEx.Equal("N.C(Of T)", types(2).ToTestDisplayString())
-
-            Dim referenceAssembly1 = comp.GetAssemblyOrModuleSymbol(reference1)
-            Assert.Same(types(1).ContainingAssembly, referenceAssembly1)
-
-            Dim referenceAssembly2 = comp.GetAssemblyOrModuleSymbol(reference2)
-            Assert.Same(types(2).ContainingAssembly, referenceAssembly2)
-        End Sub
-
-        <Fact>
-        Public Sub GetTypesByMetadataName_Ordering()
-            Dim corlibSource = "
-Namespace System
-    Public Class [Object]
-    End Class
-    Public Class [Void]
-    End Class
-End Namespace
-Public Class C
-End Class
-"
-
-            Dim corlib = CreateEmptyCompilation(corlibSource)
-            Dim corlibReference = corlib.EmitToImageReference()
-
-            Dim otherSource = "
-Public Class C
-End Class
-"
-
-            Dim other = CreateEmptyCompilation(otherSource, {corlibReference})
-            Dim otherReference = other.EmitToImageReference()
-
-            Dim currentSource = "
-Public Class C
-End Class
-"
-            Dim current = CreateEmptyCompilation(currentSource, {otherReference, corlibReference})
-            current.AssertNoDiagnostics()
-
-            Dim types = current.GetTypesByMetadataName("C")
-
-            AssertEx.Equal(types.Select(Function(t) t.ToTestDisplayString()), {"C", "C", "C"})
-
-            Assert.Same(current.Assembly, types(0).ContainingAssembly)
-
-            Dim corlibAssembly = current.GetAssemblyOrModuleSymbol(corlibReference)
-            Assert.Same(types(1).ContainingAssembly, corlibAssembly)
-
-            Dim otherAssembly = current.GetAssemblyOrModuleSymbol(otherReference)
-            Assert.Same(types(2).ContainingAssembly, otherAssembly)
-        End Sub
-    End Class
-End Namespace
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/CompilationExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/CompilationExtensions.cs
index 0384afee7e1fc..649d9f7bfa377 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/CompilationExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/CompilationExtensions.cs
@@ -2,8 +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.Diagnostics;
-
 namespace Microsoft.CodeAnalysis.Shared.Extensions
 {
     internal static class CompilationExtensions
@@ -35,33 +33,42 @@ internal static class CompilationExtensions
         /// <returns>The symbol to use for code analysis; otherwise, <see langword="null"/>.</returns>
         public static INamedTypeSymbol? GetBestTypeByMetadataName(this Compilation compilation, string fullyQualifiedMetadataName)
         {
-            INamedTypeSymbol? type = null;
+            // Try to get the unique type with this name, ignoring accessibility
+            var type = compilation.GetTypeByMetadataName(fullyQualifiedMetadataName);
+
+            // Otherwise, try to get the unique type with this name originally defined in 'compilation'
+            type ??= compilation.Assembly.GetTypeByMetadataName(fullyQualifiedMetadataName);
 
-            foreach (var currentType in compilation.GetTypesByMetadataName(fullyQualifiedMetadataName))
+            // Otherwise, try to get the unique accessible type with this name from a reference
+            if (type is null)
             {
-                if (ReferenceEquals(currentType.ContainingAssembly, compilation.Assembly))
+                foreach (var module in compilation.Assembly.Modules)
                 {
-                    Debug.Assert(type is null);
-                    return currentType;
-                }
+                    foreach (var referencedAssembly in module.ReferencedAssemblySymbols)
+                    {
+                        var currentType = referencedAssembly.GetTypeByMetadataName(fullyQualifiedMetadataName);
+                        if (currentType is null)
+                            continue;
 
-                switch (currentType.GetResultantVisibility())
-                {
-                    case Utilities.SymbolVisibility.Public:
-                    case Utilities.SymbolVisibility.Internal when currentType.ContainingAssembly.GivesAccessTo(compilation.Assembly):
-                        break;
+                        switch (currentType.GetResultantVisibility())
+                        {
+                            case Utilities.SymbolVisibility.Public:
+                            case Utilities.SymbolVisibility.Internal when referencedAssembly.GivesAccessTo(compilation.Assembly):
+                                break;
 
-                    default:
-                        continue;
-                }
+                            default:
+                                continue;
+                        }
 
-                if (type is object)
-                {
-                    // Multiple visible types with the same metadata name are present
-                    return null;
-                }
+                        if (type is object)
+                        {
+                            // Multiple visible types with the same metadata name are present
+                            return null;
+                        }
 
-                type = currentType;
+                        type = currentType;
+                    }
+                }
             }
 
             return type;

From 7c60002b24f59f88b0dc2fdb350936733afd4ccf Mon Sep 17 00:00:00 2001
From: Rikki Gibson <rigibson@microsoft.com>
Date: Tue, 11 Jan 2022 16:58:04 -0800
Subject: [PATCH 313/444] Parameter null-checking analyzer and fixer (#58182)

---
 .../Analyzers/CSharpAnalyzers.projitems       |    1 +
 .../Analyzers/CSharpAnalyzersResources.resx   |    3 +
 ...ParameterNullCheckingDiagnosticAnalyzer.cs |  316 ++++
 .../xlf/CSharpAnalyzersResources.cs.xlf       |    5 +
 .../xlf/CSharpAnalyzersResources.de.xlf       |    5 +
 .../xlf/CSharpAnalyzersResources.es.xlf       |    5 +
 .../xlf/CSharpAnalyzersResources.fr.xlf       |    5 +
 .../xlf/CSharpAnalyzersResources.it.xlf       |    5 +
 .../xlf/CSharpAnalyzersResources.ja.xlf       |    5 +
 .../xlf/CSharpAnalyzersResources.ko.xlf       |    5 +
 .../xlf/CSharpAnalyzersResources.pl.xlf       |    5 +
 .../xlf/CSharpAnalyzersResources.pt-BR.xlf    |    5 +
 .../xlf/CSharpAnalyzersResources.ru.xlf       |    5 +
 .../xlf/CSharpAnalyzersResources.tr.xlf       |    5 +
 .../xlf/CSharpAnalyzersResources.zh-Hans.xlf  |    5 +
 .../xlf/CSharpAnalyzersResources.zh-Hant.xlf  |    5 +
 .../CodeFixes/CSharpCodeFixes.projitems       |    1 +
 ...UseParameterNullCheckingCodeFixProvider.cs |  102 ++
 .../Tests/CSharpAnalyzers.UnitTests.projitems |    1 +
 .../UseParameterNullCheckingTests.cs          | 1549 +++++++++++++++++
 .../Core/Analyzers/EnforceOnBuildValues.cs    |    1 +
 .../Core/Analyzers/IDEDiagnosticIds.cs        |    2 +
 .../PredefinedCodeFixProviderNames.cs         |    1 +
 src/Compilers/Test/Core/Traits/Traits.cs      |    1 +
 .../AddParameterCheckTests.cs                 |   23 +-
 .../IDEDiagnosticIDConfigurationTests.cs      |    6 +
 .../CSharp/Impl/CSharpVSResources.resx        |    3 +
 .../CSharpCodeStyleSettingsProvider.cs        |    4 +
 .../AutomationObject.Style.cs                 |    6 +
 .../Impl/Options/Formatting/StyleViewModel.cs |   23 +
 .../CSharp/Impl/xlf/CSharpVSResources.cs.xlf  |    5 +
 .../CSharp/Impl/xlf/CSharpVSResources.de.xlf  |    5 +
 .../CSharp/Impl/xlf/CSharpVSResources.es.xlf  |    5 +
 .../CSharp/Impl/xlf/CSharpVSResources.fr.xlf  |    5 +
 .../CSharp/Impl/xlf/CSharpVSResources.it.xlf  |    5 +
 .../CSharp/Impl/xlf/CSharpVSResources.ja.xlf  |    5 +
 .../CSharp/Impl/xlf/CSharpVSResources.ko.xlf  |    5 +
 .../CSharp/Impl/xlf/CSharpVSResources.pl.xlf  |    5 +
 .../Impl/xlf/CSharpVSResources.pt-BR.xlf      |    5 +
 .../CSharp/Impl/xlf/CSharpVSResources.ru.xlf  |    5 +
 .../CSharp/Impl/xlf/CSharpVSResources.tr.xlf  |    5 +
 .../Impl/xlf/CSharpVSResources.zh-Hans.xlf    |    5 +
 .../Impl/xlf/CSharpVSResources.zh-Hant.xlf    |    5 +
 .../CSharpEditorConfigGeneratorTests.vb       |    2 +
 .../CodeStyle/CSharpCodeStyleOptions.cs       |    6 +
 45 files changed, 2180 insertions(+), 1 deletion(-)
 create mode 100644 src/Analyzers/CSharp/Analyzers/UseParameterNullChecking/CSharpUseParameterNullCheckingDiagnosticAnalyzer.cs
 create mode 100644 src/Analyzers/CSharp/CodeFixes/UseParameterNullChecking/CSharpUseParameterNullCheckingCodeFixProvider.cs
 create mode 100644 src/Analyzers/CSharp/Tests/UseParameterNullChecking/UseParameterNullCheckingTests.cs

diff --git a/src/Analyzers/CSharp/Analyzers/CSharpAnalyzers.projitems b/src/Analyzers/CSharp/Analyzers/CSharpAnalyzers.projitems
index 77239030f8743..64c484b1d0853 100644
--- a/src/Analyzers/CSharp/Analyzers/CSharpAnalyzers.projitems
+++ b/src/Analyzers/CSharp/Analyzers/CSharpAnalyzers.projitems
@@ -103,6 +103,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)UseIsNullCheck\CSharpUseNullCheckOverTypeCheckDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseIsNullCheck\CSharpUseIsNullCheckForCastAndEqualityOperatorDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseIsNullCheck\CSharpUseIsNullCheckForReferenceEqualsDiagnosticAnalyzer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)UseParameterNullChecking\CSharpUseParameterNullCheckingDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseTupleSwap\CSharpUseTupleSwapDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseLocalFunction\CSharpUseLocalFunctionDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseNullPropagation\CSharpUseNullPropagationDiagnosticAnalyzer.cs" />
diff --git a/src/Analyzers/CSharp/Analyzers/CSharpAnalyzersResources.resx b/src/Analyzers/CSharp/Analyzers/CSharpAnalyzersResources.resx
index 2d3d526546b29..466c18e00e098 100644
--- a/src/Analyzers/CSharp/Analyzers/CSharpAnalyzersResources.resx
+++ b/src/Analyzers/CSharp/Analyzers/CSharpAnalyzersResources.resx
@@ -340,4 +340,7 @@
   <data name="Use_tuple_to_swap_values" xml:space="preserve">
     <value>Use tuple to swap values</value>
   </data>
+  <data name="Use_parameter_null_checking" xml:space="preserve">
+    <value>Use parameter null checking</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/Analyzers/CSharp/Analyzers/UseParameterNullChecking/CSharpUseParameterNullCheckingDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseParameterNullChecking/CSharpUseParameterNullCheckingDiagnosticAnalyzer.cs
new file mode 100644
index 0000000000000..db85ff5cdea6a
--- /dev/null
+++ b/src/Analyzers/CSharp/Analyzers/UseParameterNullChecking/CSharpUseParameterNullCheckingDiagnosticAnalyzer.cs
@@ -0,0 +1,316 @@
+// 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.Diagnostics.CodeAnalysis;
+using System.Linq;
+using Microsoft.CodeAnalysis.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.CSharp.UseParameterNullChecking
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    internal sealed class CSharpUseParameterNullCheckingDiagnosticAnalyzer
+        : AbstractBuiltInCodeStyleDiagnosticAnalyzer
+    {
+        private const string ArgumentNullExceptionName = $"{nameof(System)}.{nameof(ArgumentNullException)}";
+        private static readonly LocalizableResourceString s_resourceTitle = new(nameof(AnalyzersResources.Null_check_can_be_simplified), AnalyzersResources.ResourceManager, typeof(AnalyzersResources));
+
+        public CSharpUseParameterNullCheckingDiagnosticAnalyzer()
+            : base(IDEDiagnosticIds.UseParameterNullCheckingId,
+                   EnforceOnBuildValues.UseParameterNullChecking,
+                   CSharpCodeStyleOptions.PreferParameterNullChecking,
+                   LanguageNames.CSharp,
+                   s_resourceTitle,
+                   s_resourceTitle)
+        {
+        }
+
+        public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
+            => DiagnosticAnalyzerCategory.SemanticSpanAnalysis;
+
+        protected override void InitializeWorker(AnalysisContext context)
+            => context.RegisterCompilationStartAction(context =>
+            {
+                var compilation = (CSharpCompilation)context.Compilation;
+                if (compilation.LanguageVersion < LanguageVersionExtensions.CSharpNext)
+                {
+                    return;
+                }
+
+                var argumentNullException = compilation.GetBestTypeByMetadataName(ArgumentNullExceptionName);
+                if (argumentNullException is null)
+                {
+                    return;
+                }
+
+                IMethodSymbol? argumentNullExceptionConstructor = null;
+                IMethodSymbol? argumentNullExceptionStringConstructor = null;
+                foreach (var constructor in argumentNullException.InstanceConstructors)
+                {
+                    if (argumentNullExceptionConstructor is not null && argumentNullExceptionStringConstructor is not null)
+                    {
+                        break;
+                    }
+
+                    switch (constructor)
+                    {
+                        case { DeclaredAccessibility: Accessibility.Public, Parameters.Length: 0 }:
+                            argumentNullExceptionConstructor = constructor;
+                            break;
+                        case { DeclaredAccessibility: Accessibility.Public, Parameters.Length: 1 }
+                            when constructor.Parameters[0].Type.SpecialType == SpecialType.System_String:
+
+                            argumentNullExceptionStringConstructor = constructor;
+                            break;
+                    }
+                }
+
+                if (argumentNullExceptionConstructor is null || argumentNullExceptionStringConstructor is null)
+                {
+                    return;
+                }
+
+                var objectType = compilation.GetSpecialType(SpecialType.System_Object);
+                var referenceEqualsMethod = (IMethodSymbol?)objectType
+                    .GetMembers(nameof(ReferenceEquals))
+                    .FirstOrDefault(m => m is IMethodSymbol { DeclaredAccessibility: Accessibility.Public, Parameters.Length: 2 });
+
+                // We are potentially interested in any declaration that has parameters.
+                // However, we avoid indexers specifically because of the complexity of locating and deleting equivalent null checks across multiple accessors.
+                context.RegisterSyntaxNodeAction(
+                    context => AnalyzeSyntax(context, argumentNullExceptionConstructor, argumentNullExceptionStringConstructor, referenceEqualsMethod),
+                    SyntaxKind.ConstructorDeclaration,
+                    SyntaxKind.MethodDeclaration,
+                    SyntaxKind.LocalFunctionStatement,
+                    SyntaxKind.SimpleLambdaExpression,
+                    SyntaxKind.ParenthesizedLambdaExpression,
+                    SyntaxKind.AnonymousMethodExpression,
+                    SyntaxKind.OperatorDeclaration,
+                    SyntaxKind.ConversionOperatorDeclaration);
+            });
+
+        private void AnalyzeSyntax(
+            SyntaxNodeAnalysisContext context,
+            IMethodSymbol argumentNullExceptionConstructor,
+            IMethodSymbol argumentNullExceptionStringConstructor,
+            IMethodSymbol? referenceEqualsMethod)
+        {
+            var cancellationToken = context.CancellationToken;
+
+            var semanticModel = context.SemanticModel;
+            var syntaxTree = semanticModel.SyntaxTree;
+
+            var option = context.Options.GetOption(CSharpCodeStyleOptions.PreferParameterNullChecking, syntaxTree, cancellationToken);
+            if (!option.Value)
+            {
+                return;
+            }
+
+            var node = context.Node;
+            var block = node switch
+            {
+                MethodDeclarationSyntax methodDecl => methodDecl.Body,
+                ConstructorDeclarationSyntax constructorDecl => constructorDecl.Body,
+                LocalFunctionStatementSyntax localFunctionStatement => localFunctionStatement.Body,
+                AnonymousFunctionExpressionSyntax anonymousFunction => anonymousFunction.Block,
+                OperatorDeclarationSyntax operatorDecl => operatorDecl.Body,
+                ConversionOperatorDeclarationSyntax conversionDecl => conversionDecl.Body,
+                _ => throw ExceptionUtilities.UnexpectedValue(node)
+            };
+
+            // More scenarios should be supported eventually: https://github.com/dotnet/roslyn/issues/58699
+            if (block is null)
+            {
+                return;
+            }
+
+            var methodSymbol = node is AnonymousFunctionExpressionSyntax
+                ? (IMethodSymbol?)semanticModel.GetSymbolInfo(node, cancellationToken).Symbol
+                : (IMethodSymbol?)semanticModel.GetDeclaredSymbol(node, cancellationToken);
+            if (methodSymbol is null || methodSymbol.Parameters.IsEmpty)
+            {
+                return;
+            }
+
+            foreach (var statement in block.Statements)
+            {
+                var parameter = TryGetParameterNullCheckedByStatement(statement);
+                if (ParameterCanUseNullChecking(parameter)
+                    && parameter.DeclaringSyntaxReferences.FirstOrDefault() is SyntaxReference reference
+                    && reference.SyntaxTree.Equals(statement.SyntaxTree)
+                    && reference.GetSyntax() is ParameterSyntax parameterSyntax)
+                {
+                    context.ReportDiagnostic(DiagnosticHelper.Create(
+                        Descriptor,
+                        statement.GetLocation(),
+                        option.Notification.Severity,
+                        additionalLocations: new[] { parameterSyntax.GetLocation() },
+                        properties: null));
+                }
+            }
+
+            return;
+
+            bool ParameterCanUseNullChecking([NotNullWhen(true)] IParameterSymbol? parameter)
+            {
+                if (parameter is null)
+                    return false;
+
+                if (parameter.RefKind != RefKind.None)
+                    return false;
+
+                if (parameter.Type.IsValueType)
+                {
+                    return parameter.Type.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T
+                        || parameter.Type.TypeKind is TypeKind.Pointer or TypeKind.FunctionPointer;
+                }
+
+                return true;
+            }
+
+            IParameterSymbol? TryGetParameterNullCheckedByStatement(StatementSyntax statement)
+            {
+                switch (statement)
+                {
+                    // if (param == null) { throw new ArgumentNullException(nameof(param)); }
+                    // if (param is null) { throw new ArgumentNullException(nameof(param)); }
+                    // if (object.ReferenceEquals(param, null)) { throw new ArgumentNullException(nameof(param)); }
+                    case IfStatementSyntax ifStatement:
+                        ExpressionSyntax left, right;
+                        switch (ifStatement)
+                        {
+                            case { Condition: BinaryExpressionSyntax { OperatorToken.RawKind: (int)SyntaxKind.EqualsEqualsToken } binary }
+                                // Only suggest the fix on built-in `==` operators where we know we won't change behavior
+                                when semanticModel.GetSymbolInfo(binary).Symbol is IMethodSymbol { MethodKind: MethodKind.BuiltinOperator }:
+
+                                left = binary.Left;
+                                right = binary.Right;
+                                break;
+                            case { Condition: IsPatternExpressionSyntax { Expression: var patternInput, Pattern: ConstantPatternSyntax { Expression: var patternExpression } } }:
+                                left = patternInput;
+                                right = patternExpression;
+                                break;
+                            case { Condition: InvocationExpressionSyntax { Expression: var receiver, ArgumentList.Arguments: { Count: 2 } arguments } }
+                                when referenceEqualsMethod != null && referenceEqualsMethod.Equals(semanticModel.GetSymbolInfo(receiver, cancellationToken).Symbol):
+
+                                left = arguments[0].Expression;
+                                right = arguments[1].Expression;
+                                break;
+
+                            default:
+                                return null;
+                        }
+
+                        var parameterInBinary = left.IsKind(SyntaxKind.NullLiteralExpression) ? TryGetParameter(right)
+                            : right.IsKind(SyntaxKind.NullLiteralExpression) ? TryGetParameter(left)
+                            : null;
+                        if (parameterInBinary is null)
+                        {
+                            return null;
+                        }
+
+                        var throwStatement = ifStatement.Statement switch
+                        {
+                            ThrowStatementSyntax @throw => @throw,
+                            BlockSyntax { Statements: { Count: 1 } statements } => statements[0] as ThrowStatementSyntax,
+                            _ => null
+                        };
+
+                        if (throwStatement?.Expression is not ObjectCreationExpressionSyntax thrownInIf
+                            || !IsConstructorApplicable(thrownInIf, parameterInBinary))
+                        {
+                            return null;
+                        }
+
+                        return parameterInBinary;
+
+                    // this.field = param ?? throw new ArgumentNullException(nameof(param));
+                    case ExpressionStatementSyntax
+                    {
+                        Expression: AssignmentExpressionSyntax
+                        {
+                            Right: BinaryExpressionSyntax
+                            {
+                                OperatorToken.RawKind: (int)SyntaxKind.QuestionQuestionToken,
+                                Left: ExpressionSyntax maybeParameter,
+                                Right: ThrowExpressionSyntax { Expression: ObjectCreationExpressionSyntax thrownInNullCoalescing }
+                            }
+                        }
+                    }:
+                        var coalescedParameter = TryGetParameter(maybeParameter);
+                        if (coalescedParameter is null || !IsConstructorApplicable(thrownInNullCoalescing, coalescedParameter))
+                        {
+                            return null;
+                        }
+
+                        return coalescedParameter;
+
+                    default:
+                        return null;
+                }
+            }
+
+            IParameterSymbol? TryGetParameter(ExpressionSyntax maybeParameter)
+            {
+                // `(object)x == null` is often used to ensure reference equality is used.
+                // therefore, we specially unwrap casts when the cast is to `object`.
+                if (maybeParameter is CastExpressionSyntax { Type: var type, Expression: var operand })
+                {
+                    if (semanticModel.GetTypeInfo(type).Type?.SpecialType != SpecialType.System_Object)
+                    {
+                        return null;
+                    }
+
+                    maybeParameter = operand;
+                }
+
+                if (semanticModel.GetSymbolInfo(maybeParameter).Symbol is not IParameterSymbol { ContainingSymbol: { } containingSymbol } parameterSymbol || !containingSymbol.Equals(methodSymbol))
+                {
+                    return null;
+                }
+
+                return parameterSymbol;
+            }
+
+            bool IsConstructorApplicable(ObjectCreationExpressionSyntax exceptionCreation, IParameterSymbol parameterSymbol)
+            {
+                if (exceptionCreation.ArgumentList?.Arguments is not { } arguments)
+                {
+                    return false;
+                }
+
+                // 'new ArgumentNullException()'
+                if (argumentNullExceptionConstructor.Equals(semanticModel.GetSymbolInfo(exceptionCreation, cancellationToken).Symbol))
+                {
+                    return arguments.Count == 0;
+                }
+
+                // 'new ArgumentNullException(nameof(param))' (or equivalent)
+                if (!argumentNullExceptionStringConstructor.Equals(semanticModel.GetSymbolInfo(exceptionCreation, cancellationToken).Symbol))
+                {
+                    return false;
+                }
+
+                if (arguments.Count != 1)
+                {
+                    return false;
+                }
+
+                var constantValue = semanticModel.GetConstantValue(arguments[0].Expression, cancellationToken);
+                if (constantValue.Value is not string constantString || !string.Equals(constantString, parameterSymbol.Name, StringComparison.Ordinal))
+                {
+                    return false;
+                }
+
+                return true;
+            }
+        }
+    }
+}
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.cs.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.cs.xlf
index be38ae577fa07..d3bf326ebc1a3 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.cs.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.cs.xlf
@@ -262,6 +262,11 @@
         <target state="translated">Použít new(...)</target>
         <note>{Locked="new(...)"} This is a C# construct and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Use_parameter_null_checking">
+        <source>Use parameter null checking</source>
+        <target state="new">Use parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Use_pattern_matching">
         <source>Use pattern matching</source>
         <target state="translated">Použít porovnávání vzorů</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.de.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.de.xlf
index de593ee65610b..3e5a10a5c1b01 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.de.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.de.xlf
@@ -262,6 +262,11 @@
         <target state="translated">"new(...)" verwenden</target>
         <note>{Locked="new(...)"} This is a C# construct and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Use_parameter_null_checking">
+        <source>Use parameter null checking</source>
+        <target state="new">Use parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Use_pattern_matching">
         <source>Use pattern matching</source>
         <target state="translated">Musterabgleich verwenden</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.es.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.es.xlf
index ad0f16fb97f56..487cb6690ab0d 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.es.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.es.xlf
@@ -262,6 +262,11 @@
         <target state="translated">Usar "new(...)"</target>
         <note>{Locked="new(...)"} This is a C# construct and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Use_parameter_null_checking">
+        <source>Use parameter null checking</source>
+        <target state="new">Use parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Use_pattern_matching">
         <source>Use pattern matching</source>
         <target state="translated">Usar coincidencia de patrones</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.fr.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.fr.xlf
index f9cf8172a54d7..3ea7e6285c43f 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.fr.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.fr.xlf
@@ -262,6 +262,11 @@
         <target state="translated">Utiliser 'new(...)'</target>
         <note>{Locked="new(...)"} This is a C# construct and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Use_parameter_null_checking">
+        <source>Use parameter null checking</source>
+        <target state="new">Use parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Use_pattern_matching">
         <source>Use pattern matching</source>
         <target state="translated">Utiliser les critères spéciaux</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.it.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.it.xlf
index 2bced89905496..e5166f9b4e1c5 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.it.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.it.xlf
@@ -262,6 +262,11 @@
         <target state="translated">Usa 'new(...)'</target>
         <note>{Locked="new(...)"} This is a C# construct and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Use_parameter_null_checking">
+        <source>Use parameter null checking</source>
+        <target state="new">Use parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Use_pattern_matching">
         <source>Use pattern matching</source>
         <target state="translated">Usa i criteri di ricerca</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ja.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ja.xlf
index f36328909a864..06648a84234eb 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ja.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ja.xlf
@@ -262,6 +262,11 @@
         <target state="translated">'new(...)' を使用する</target>
         <note>{Locked="new(...)"} This is a C# construct and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Use_parameter_null_checking">
+        <source>Use parameter null checking</source>
+        <target state="new">Use parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Use_pattern_matching">
         <source>Use pattern matching</source>
         <target state="translated">パターン マッチングを使用します</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ko.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ko.xlf
index ce043a110e343..c48fe7cd0888d 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ko.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ko.xlf
@@ -262,6 +262,11 @@
         <target state="translated">'new(...)' 사용</target>
         <note>{Locked="new(...)"} This is a C# construct and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Use_parameter_null_checking">
+        <source>Use parameter null checking</source>
+        <target state="new">Use parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Use_pattern_matching">
         <source>Use pattern matching</source>
         <target state="translated">패턴 일치 사용</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pl.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pl.xlf
index af3991d281da5..92deaef069791 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pl.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pl.xlf
@@ -262,6 +262,11 @@
         <target state="translated">Użyj operatora „new(...)”</target>
         <note>{Locked="new(...)"} This is a C# construct and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Use_parameter_null_checking">
+        <source>Use parameter null checking</source>
+        <target state="new">Use parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Use_pattern_matching">
         <source>Use pattern matching</source>
         <target state="translated">Użyj dopasowywania wzorców</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pt-BR.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pt-BR.xlf
index 67408b2147adf..52318280707e5 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pt-BR.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pt-BR.xlf
@@ -262,6 +262,11 @@
         <target state="translated">Usar 'new(...)'</target>
         <note>{Locked="new(...)"} This is a C# construct and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Use_parameter_null_checking">
+        <source>Use parameter null checking</source>
+        <target state="new">Use parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Use_pattern_matching">
         <source>Use pattern matching</source>
         <target state="translated">Usar a correspondência de padrão</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ru.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ru.xlf
index 3e87bac5a4c3b..98bde1d848ccc 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ru.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ru.xlf
@@ -262,6 +262,11 @@
         <target state="translated">Используйте "new(...)".</target>
         <note>{Locked="new(...)"} This is a C# construct and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Use_parameter_null_checking">
+        <source>Use parameter null checking</source>
+        <target state="new">Use parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Use_pattern_matching">
         <source>Use pattern matching</source>
         <target state="translated">Используйте сопоставление шаблонов</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.tr.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.tr.xlf
index f3a2d5a24347d..6627d78551333 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.tr.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.tr.xlf
@@ -262,6 +262,11 @@
         <target state="translated">'new(...)' kullanın</target>
         <note>{Locked="new(...)"} This is a C# construct and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Use_parameter_null_checking">
+        <source>Use parameter null checking</source>
+        <target state="new">Use parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Use_pattern_matching">
         <source>Use pattern matching</source>
         <target state="translated">Desen eşleştirme kullan</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hans.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hans.xlf
index 7c6167a7e02dc..cf626f8bbc06d 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hans.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hans.xlf
@@ -262,6 +262,11 @@
         <target state="translated">使用 "new(...)"</target>
         <note>{Locked="new(...)"} This is a C# construct and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Use_parameter_null_checking">
+        <source>Use parameter null checking</source>
+        <target state="new">Use parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Use_pattern_matching">
         <source>Use pattern matching</source>
         <target state="translated">使用模式匹配</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hant.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hant.xlf
index 25266870695f0..c43a1e4f62e47 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hant.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hant.xlf
@@ -262,6 +262,11 @@
         <target state="translated">使用 'new(...)'</target>
         <note>{Locked="new(...)"} This is a C# construct and should not be localized.</note>
       </trans-unit>
+      <trans-unit id="Use_parameter_null_checking">
+        <source>Use parameter null checking</source>
+        <target state="new">Use parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Use_pattern_matching">
         <source>Use pattern matching</source>
         <target state="translated">使用模式比對</target>
diff --git a/src/Analyzers/CSharp/CodeFixes/CSharpCodeFixes.projitems b/src/Analyzers/CSharp/CodeFixes/CSharpCodeFixes.projitems
index c58db92c96184..d411389a4b28d 100644
--- a/src/Analyzers/CSharp/CodeFixes/CSharpCodeFixes.projitems
+++ b/src/Analyzers/CSharp/CodeFixes/CSharpCodeFixes.projitems
@@ -51,6 +51,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)UseConditionalExpression\CSharpUseConditionalExpressionHelpers.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseConditionalExpression\MultiLineConditionalExpressionFormattingRule.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseDeconstruction\CSharpUseDeconstructionCodeFixProvider.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)UseParameterNullChecking\CSharpUseParameterNullCheckingCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseTupleSwap\CSharpUseTupleSwapCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseDefaultLiteral\CSharpUseDefaultLiteralCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseExpressionBody\UseExpressionBodyCodeFixProvider.cs" />
diff --git a/src/Analyzers/CSharp/CodeFixes/UseParameterNullChecking/CSharpUseParameterNullCheckingCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/UseParameterNullChecking/CSharpUseParameterNullCheckingCodeFixProvider.cs
new file mode 100644
index 0000000000000..5bc8f3a915a18
--- /dev/null
+++ b/src/Analyzers/CSharp/CodeFixes/UseParameterNullChecking/CSharpUseParameterNullCheckingCodeFixProvider.cs
@@ -0,0 +1,102 @@
+// 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.Immutable;
+using System.Composition;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.CSharp.UseParameterNullChecking
+{
+    [ExportCodeFixProvider(LanguageNames.CSharp, Name = PredefinedCodeFixProviderNames.UseParameterNullChecking), Shared]
+    internal sealed class CSharpUseParameterNullCheckingCodeFixProvider : SyntaxEditorBasedCodeFixProvider
+    {
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public CSharpUseParameterNullCheckingCodeFixProvider()
+        {
+        }
+
+        public override ImmutableArray<string> FixableDiagnosticIds
+            => ImmutableArray.Create(IDEDiagnosticIds.UseParameterNullCheckingId);
+
+        internal sealed override CodeFixCategory CodeFixCategory => CodeFixCategory.CodeStyle;
+
+        public override Task RegisterCodeFixesAsync(CodeFixContext context)
+        {
+            var diagnostic = context.Diagnostics[0];
+            context.RegisterCodeFix(
+                new MyCodeAction(c => FixAsync(context.Document, diagnostic, c)),
+                context.Diagnostics);
+            return Task.CompletedTask;
+        }
+
+        protected override Task FixAllAsync(
+            Document document, ImmutableArray<Diagnostic> diagnostics,
+            SyntaxEditor editor, CancellationToken cancellationToken)
+        {
+            // Tracking parameters which have already been fixed by a fix-all operation.
+            // This avoids crashing the fixer when the same parameter is null-tested multiple times.
+            using var _ = PooledHashSet<Location>.GetInstance(out var fixedParameterLocations);
+            foreach (var diagnostic in diagnostics)
+            {
+                var node = diagnostic.Location.FindNode(getInnermostNodeForTie: true, cancellationToken: cancellationToken);
+                switch (node)
+                {
+                    case IfStatementSyntax ifStatement:
+                        editor.RemoveNode(ifStatement);
+                        break;
+                    case ExpressionStatementSyntax expressionStatement:
+                        // this.item = item ?? throw new ArgumentNullException(nameof(item));
+                        var assignment = (AssignmentExpressionSyntax)expressionStatement.Expression;
+                        var nullCoalescing = (BinaryExpressionSyntax)assignment.Right;
+                        var parameterReferenceSyntax = nullCoalescing.Left;
+                        editor.ReplaceNode(nullCoalescing, parameterReferenceSyntax.WithAppendedTrailingTrivia(SyntaxFactory.ElasticMarker));
+                        break;
+                    default:
+                        throw ExceptionUtilities.UnexpectedValue(node);
+                }
+
+                var parameterLocation = diagnostic.AdditionalLocations[0];
+                if (fixedParameterLocations.Add(parameterLocation))
+                {
+                    var parameterSyntax = (ParameterSyntax)parameterLocation.FindNode(cancellationToken);
+                    if (parameterSyntax.ExclamationExclamationToken.IsKind(SyntaxKind.None))
+                    {
+                        var identifier = parameterSyntax.Identifier;
+                        var newIdentifier = identifier.WithoutTrailingTrivia();
+                        var newExclamationExclamationToken = SyntaxFactory.Token(SyntaxTriviaList.Empty, SyntaxKind.ExclamationExclamationToken, identifier.TrailingTrivia);
+                        editor.ReplaceNode(parameterSyntax, parameterSyntax.Update(
+                            parameterSyntax.AttributeLists,
+                            parameterSyntax.Modifiers,
+                            parameterSyntax.Type,
+                            newIdentifier,
+                            newExclamationExclamationToken,
+                            parameterSyntax.Default));
+                    }
+                }
+            }
+
+            return Task.CompletedTask;
+        }
+
+        private class MyCodeAction : CustomCodeActions.DocumentChangeAction
+        {
+            public MyCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument)
+                : base(CSharpAnalyzersResources.Use_parameter_null_checking, createChangedDocument, nameof(CSharpUseParameterNullCheckingCodeFixProvider))
+            {
+            }
+        }
+    }
+}
diff --git a/src/Analyzers/CSharp/Tests/CSharpAnalyzers.UnitTests.projitems b/src/Analyzers/CSharp/Tests/CSharpAnalyzers.UnitTests.projitems
index f084e0292c272..2aa0e218be626 100644
--- a/src/Analyzers/CSharp/Tests/CSharpAnalyzers.UnitTests.projitems
+++ b/src/Analyzers/CSharp/Tests/CSharpAnalyzers.UnitTests.projitems
@@ -92,6 +92,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)UseIsNullCheck\UseNullCheckOverTypeCheckDiagnosticAnalyzerTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseExplicitTupleName\UseExplicitTupleNameTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseImplicitObjectCreation\CSharpUseImplicitObjectCreationTests.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)UseParameterNullChecking\UseParameterNullCheckingTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseTupleSwap\UseTupleSwapTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseLocalFunction\UseLocalFunctionTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseNullPropagation\UseNullPropagationTests.cs" />
diff --git a/src/Analyzers/CSharp/Tests/UseParameterNullChecking/UseParameterNullCheckingTests.cs b/src/Analyzers/CSharp/Tests/UseParameterNullChecking/UseParameterNullCheckingTests.cs
new file mode 100644
index 0000000000000..bc69220f51600
--- /dev/null
+++ b/src/Analyzers/CSharp/Tests/UseParameterNullChecking/UseParameterNullCheckingTests.cs
@@ -0,0 +1,1549 @@
+// 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.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
+using Microsoft.CodeAnalysis.CSharp.UseParameterNullChecking;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics;
+using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.UseParameterNullChecking
+{
+    using VerifyCS = CSharpCodeFixVerifier<CSharpUseParameterNullCheckingDiagnosticAnalyzer, CSharpUseParameterNullCheckingCodeFixProvider>;
+
+    public class UseParameterNullCheckingTests
+    {
+        [Theory]
+        [Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        [InlineData("==")]
+        [InlineData("is")]
+        public async Task TestNoBraces(string @operator)
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"
+using System;
+
+class C
+{
+    void M(string s)
+    {
+        [|if (s " + @operator + @" null)
+            throw new ArgumentNullException(nameof(s));|]
+    }
+}",
+                FixedCode = @"
+using System;
+
+class C
+{
+    void M(string s!!)
+    {
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Theory]
+        [Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        [InlineData("==")]
+        [InlineData("is")]
+        public async Task TestWithBraces(string @operator)
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"
+using System;
+
+class C
+{
+    void M(string s)
+    {
+        [|if (s " + @operator + @" null)
+        {
+            throw new ArgumentNullException(nameof(s));
+        }|]
+    }
+}",
+                FixedCode = @"
+using System;
+
+class C
+{
+    void M(string s!!)
+    {
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Theory]
+        [Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        [InlineData("==")]
+        [InlineData("is")]
+        public async Task TestLocalFunction(string @operator)
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"
+using System;
+
+class C
+{
+    void M()
+    {
+        local("""");
+        void local(string s)
+        {
+            [|if (s " + @operator + @" null)
+            {
+                throw new ArgumentNullException(nameof(s));
+            }|]
+        }
+    }
+}",
+                FixedCode = @"
+using System;
+
+class C
+{
+    void M()
+    {
+        local("""");
+        void local(string s!!)
+        {
+        }
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestEqualitySwapped()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"
+using System;
+
+class C
+{
+    void M(string s)
+    {
+        [|if (null == (object)s)
+            throw new ArgumentNullException(nameof(s));|]
+    }
+}",
+                FixedCode = @"
+using System;
+
+class C
+{
+    void M(string s!!)
+    {
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestNotEquality()
+        {
+            var testCode = @"
+using System;
+
+class C
+{
+    void M(string s)
+    {
+        if ((object)s != null)
+            throw new ArgumentNullException(nameof(s));
+    }
+}";
+            await new VerifyCS.Test()
+            {
+                TestCode = testCode,
+                FixedCode = testCode,
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestNullCoalescingThrow()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"
+using System;
+
+class C
+{
+    private readonly string s;
+    public C(string s)
+    {
+        [|this.s = s ?? throw new ArgumentNullException(nameof(s));|]
+    }
+}",
+                FixedCode = @"
+using System;
+
+class C
+{
+    private readonly string s;
+    public C(string s!!)
+    {
+        this.s = s;
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestOperator()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"
+using System;
+
+class C
+{
+    public static C operator +(C c, string s)
+    {
+        [|if (s is null)
+            throw new ArgumentNullException(nameof(s));|]
+
+        return new C();
+    }
+}",
+                FixedCode = @"
+using System;
+
+class C
+{
+    public static C operator +(C c, string s!!)
+    {
+        return new C();
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestConversionOperator()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"
+using System;
+
+class C
+{
+    public static implicit operator C(string s)
+    {
+        [|if (s is null)
+            throw new ArgumentNullException(nameof(s));|]
+
+        return new C();
+    }
+}",
+                FixedCode = @"
+using System;
+
+class C
+{
+    public static implicit operator C(string s!!)
+    {
+        return new C();
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestNullCoalescingThrowExpressionBody()
+        {
+            // We'd like to support this eventually. https://github.com/dotnet/roslyn/issues/58699
+            var testCode = @"
+using System;
+
+class C
+{
+    private readonly string s;
+    public C(string s)
+        => this.s = s ?? throw new ArgumentNullException(nameof(s));
+}";
+            await new VerifyCS.Test()
+            {
+                TestCode = testCode,
+                FixedCode = testCode,
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestNullCoalescingThrowBaseClause()
+        {
+            // We'd like to support this eventually. https://github.com/dotnet/roslyn/issues/58699
+            var testCode = @"
+using System;
+
+class Base { public Base(string s) { } }
+class C : Base
+{
+    public C(string s) : base(s ?? throw new ArgumentNullException(nameof(s))) { }
+}";
+            await new VerifyCS.Test()
+            {
+                TestCode = testCode,
+                FixedCode = testCode,
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestAlreadyNullChecked()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"using System;
+
+class C
+{
+    public C(string s!!)
+    {
+        [|if (s is null)
+            throw new ArgumentNullException(nameof(s));|]
+    }
+}",
+                FixedCode = @"using System;
+
+class C
+{
+    public C(string s!!)
+    {
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestSingleLineNoBraces()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"using System;
+
+class C
+{
+    public C(string s)
+    {
+        [|if (s is null) throw new ArgumentNullException(nameof(s));|]
+    }
+}",
+                FixedCode = @"using System;
+
+class C
+{
+    public C(string s!!)
+    {
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestSingleLineWithBraces()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"using System;
+
+class C
+{
+    public C(string s)
+    {
+        [|if (s is null) { throw new ArgumentNullException(nameof(s)); }|]
+    }
+}",
+                FixedCode = @"using System;
+
+class C
+{
+    public C(string s!!)
+    {
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestLeadingAndTrailingTrivia1()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"using System;
+
+class C
+{
+    public C(string s)
+    {
+        // comment1
+        [|if (s is null) { throw new ArgumentNullException(nameof(s)); }|] // comment2
+    }
+}",
+                FixedCode = @"using System;
+
+class C
+{
+    public C(string s!!)
+    {
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestLeadingAndTrailingTrivia2()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"using System;
+
+class C
+{
+    public C(
+          string x // comment
+        , string y // comment,
+        , string z // comment
+        )
+    {
+        [|if (x is null) throw new ArgumentNullException(nameof(x));|]
+        [|if (y is null) throw new ArgumentNullException(nameof(y));|]
+        [|if (z is null) throw new ArgumentNullException(nameof(z));|]
+    }
+}",
+                FixedCode = @"using System;
+
+class C
+{
+    public C(
+          string x!! // comment
+        , string y!! // comment,
+        , string z!! // comment
+        )
+    {
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestLeadingAndTrailingTrivia3()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"using System;
+
+class C
+{
+    public C(
+          string x /* comment */ !!
+        )
+    {
+        [|if (x is null) throw new ArgumentNullException(nameof(x));|]
+    }
+}",
+                FixedCode = @"using System;
+
+class C
+{
+    public C(
+          string x /* comment */ !!
+        )
+    {
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestAssignThenTest()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"using System;
+
+class C
+{
+    public C(string s)
+    {
+        s = ""a"";
+        [|if (s is null) { throw new ArgumentNullException(nameof(s)); }|]
+    }
+}",
+                FixedCode = @"using System;
+
+class C
+{
+    public C(string s!!)
+    {
+        s = ""a"";
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestRedundantNullChecks()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"
+using System;
+
+class C
+{
+    public C(string s)
+    {
+        [|if (s is null)
+            throw new ArgumentNullException(nameof(s));|]
+
+        [|if (s is null)
+            throw new ArgumentNullException(nameof(s));|]
+    }
+}",
+                FixedCode =
+@"
+using System;
+
+class C
+{
+    public C(string s!!)
+    {
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Theory, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        [InlineData("ref")]
+        [InlineData("in")]
+        [InlineData("out")]
+        public async Task TestRefParameter(string refKind)
+        {
+            // https://github.com/dotnet/roslyn/issues/58699
+            // When the implementation changes to permit ref/in parameters, we should also change the fixer.
+            var testCode = @"
+using System;
+
+class C
+{
+    public C(" + refKind + @" string s)
+    {
+        if (s is null)
+            throw new ArgumentNullException(nameof(s));
+    }
+}";
+            await new VerifyCS.Test()
+            {
+                TestCode = testCode,
+                FixedCode = testCode,
+                CompilerDiagnostics = Testing.CompilerDiagnostics.None,
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Theory, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        [InlineData("object")]
+        [InlineData("C")]
+        public async Task TestReferenceEqualsCheck(string className)
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"
+using System;
+
+class C
+{
+    private readonly string s;
+    void M1(string s)
+    {
+        [|if (" + className + @".ReferenceEquals(s, null))
+        {
+            throw new ArgumentNullException(nameof(s));
+        }|]
+    }
+
+    void M2(string s)
+    {
+        [|if (" + className + @".ReferenceEquals(null, s))
+        {
+            throw new ArgumentNullException(nameof(s));
+        }|]
+    }
+}",
+                FixedCode = @"
+using System;
+
+class C
+{
+    private readonly string s;
+    void M1(string s!!)
+    {
+    }
+
+    void M2(string s!!)
+    {
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestNotCustomReferenceEqualsCheck()
+        {
+            var testCode = @"
+using System;
+
+class C
+{
+    private readonly string s;
+    void M(string s)
+    {
+        if (ReferenceEquals(s, null))
+        {
+            throw new ArgumentNullException(nameof(s));
+        }
+    }
+
+    bool ReferenceEquals(object o1, object o2) => false;
+}";
+            await new VerifyCS.Test()
+            {
+                TestCode = testCode,
+                FixedCode = testCode,
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestNotEqualitySwapped()
+        {
+            // https://github.com/dotnet/roslyn/issues/58699
+            var testCode = @"using System;
+
+class C
+{
+    void M(string s)
+    {
+        if (null != (object)s)
+            throw new ArgumentNullException(nameof(s));
+    }
+}";
+            await new VerifyCS.Test()
+            {
+                TestCode = testCode,
+                FixedCode = testCode,
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestMissingPreCSharp11()
+        {
+            var testCode = @"
+using System;
+
+class C
+{
+    void M(string s)
+    {
+        if ((object)s == null)
+            throw new ArgumentNullException(nameof(s));
+    }
+}";
+            await new VerifyCS.Test()
+            {
+                TestCode = testCode,
+                FixedCode = testCode,
+                LanguageVersion = LanguageVersion.CSharp10
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestOnlyForObjectCast()
+        {
+            var testCode = @"using System;
+
+class C
+{
+    void M(string s)
+    {
+        if ((string)s == null)
+            throw new ArgumentNullException(nameof(s));
+    }
+}";
+            await new VerifyCS.Test()
+            {
+                TestCode = testCode,
+                FixedCode = testCode,
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestFixAll1()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"
+using System;
+
+class C
+{
+    void M(string s1, string s2)
+    {
+        [|if ((object)s1 == null)
+            throw new ArgumentNullException(nameof(s1));|]
+
+        [|if (null == (object)s2)
+            throw new ArgumentNullException(nameof(s2));|]
+    }
+}",
+                FixedCode = @"
+using System;
+
+class C
+{
+    void M(string s1!!, string s2!!)
+    {
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestNested1()
+        {
+            var testCode = @"using System;
+
+class C
+{
+    void M(string s2)
+    {
+        if ((object)((object)s2 == null) == null)
+            throw new ArgumentNullException(nameof(s2));
+    }
+}";
+            await new VerifyCS.Test()
+            {
+                TestCode = testCode,
+                FixedCode = testCode,
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestNestedStatements()
+        {
+            var testCode = @"using System;
+
+class C
+{
+    void M(string s2)
+    {
+        {
+            if (s2 == null)
+                throw new ArgumentNullException(nameof(s2));
+        }
+    }
+}";
+            await new VerifyCS.Test()
+            {
+                TestCode = testCode,
+                FixedCode = testCode,
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestConstrainedTypeParameter()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"
+using System;
+
+class C
+{
+    void M<T>(T s) where T : class
+    {
+        [|if ((object)s == null)
+            throw new ArgumentNullException(nameof(s));|]
+    }
+}",
+                FixedCode = @"
+using System;
+
+class C
+{
+    void M<T>(T s!!) where T : class
+    {
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestOnStructConstrainedTypeParameter()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"
+using System;
+
+class C
+{
+    void M1<T>(T s) where T : struct
+    {
+        if ((object)s == null)
+            throw new ArgumentNullException(nameof(s));
+    }
+
+    void M2<T>(T? s) where T : struct
+    {
+        [|if ((object)s == null)
+            throw new ArgumentNullException(nameof(s));|]
+    }
+}",
+                FixedCode = @"
+using System;
+
+class C
+{
+    void M1<T>(T s) where T : struct
+    {
+        if ((object)s == null)
+            throw new ArgumentNullException(nameof(s));
+    }
+
+    void M2<T>(T? s!!) where T : struct
+    {
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestUnconstrainedTypeParameter()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode =
+@"using System;
+
+class C
+{
+    void M<T>(T s)
+    {
+        [|if ((object)s == null)
+            throw new ArgumentNullException(nameof(s));|]
+    }
+}",
+                FixedCode =
+@"using System;
+
+class C
+{
+    void M<T>(T s!!)
+    {
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestComplexExpr()
+        {
+            var testCode = @"using System;
+
+class C
+{
+    void M(string[] s)
+    {
+        if ((object)s[0] == null)
+            throw new ArgumentNullException(nameof(s));
+    }
+}";
+            await new VerifyCS.Test()
+            {
+                TestCode = testCode,
+                FixedCode = testCode,
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestComplexExpr2()
+        {
+            var testCode = @"using System;
+
+class C
+{
+    void M(string s1, string s2)
+    {
+        if (s1 == null || s2 == null)
+            throw new ArgumentNullException(nameof(s1));
+    }
+}";
+            await new VerifyCS.Test()
+            {
+                TestCode = testCode,
+                FixedCode = testCode,
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestNotOnDefault()
+        {
+            var testCode = @"
+using System;
+
+class C
+{
+    void M(string s)
+    {
+        if ((object)s == default)
+            throw new ArgumentNullException(nameof(s));
+    }
+}";
+            await new VerifyCS.Test()
+            {
+                TestCode = testCode,
+                FixedCode = testCode,
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestOptionalParameter()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"
+using System;
+
+class C
+{
+    void M(string s = ""a"")
+    {
+        [|if ((object)s == null)
+            throw new ArgumentNullException(nameof(s));|]
+    }
+}",
+                FixedCode = @"
+using System;
+
+class C
+{
+    void M(string s!! = ""a"")
+    {
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestWithStringExceptionArgument()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"
+using System;
+
+class C
+{
+    void M(string s)
+    {
+        [|if (s == null)
+            throw new ArgumentNullException(""s"");|]
+    }
+}",
+                FixedCode = @"
+using System;
+
+class C
+{
+    void M(string s!!)
+    {
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestWithStringExceptionArgument2()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"
+using System;
+
+class C
+{
+    void M(string HelloWorld)
+    {
+        [|if (HelloWorld == null)
+            throw new ArgumentNullException(""Hello"" + ""World"");|]
+    }
+}",
+                FixedCode = @"
+using System;
+
+class C
+{
+    void M(string HelloWorld!!)
+    {
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestNotWithUnexpectedExceptionArgument()
+        {
+            var testCode = @"using System;
+
+class C
+{
+    void M(string s)
+    {
+        if (s == null)
+            throw new ArgumentNullException(""banana"");
+    }
+}";
+            await new VerifyCS.Test()
+            {
+                TestCode = testCode,
+                FixedCode = testCode,
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestWithExceptionNoArguments()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"using System;
+
+class C
+{
+    void M(string s)
+    {
+        [|if (s == null)
+            throw new ArgumentNullException();|]
+    }
+}",
+                FixedCode = @"using System;
+
+class C
+{
+    void M(string s!!)
+    {
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestSimpleLambda()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"using System;
+
+class C
+{
+    Action<string> lambda = x =>
+    {
+        [|if (x is null)
+            throw new ArgumentNullException(nameof(x));|]
+    };
+}
+",
+                FixedCode = @"using System;
+
+class C
+{
+    Action<string> lambda = x!! =>
+    {
+    };
+}
+",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestParenthesizedLambdaNoType()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"using System;
+
+class C
+{
+    Action<string> lambda = (x) =>
+    {
+        [|if (x is null)
+            throw new ArgumentNullException(nameof(x));|]
+    };
+}
+",
+                FixedCode = @"using System;
+
+class C
+{
+    Action<string> lambda = (x!!) =>
+    {
+    };
+}
+",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestParenthesizedLambdaWithType()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"using System;
+
+class C
+{
+    Action<string> lambda = (string x) =>
+    {
+        [|if (x is null)
+            throw new ArgumentNullException(nameof(x));|]
+    };
+}
+",
+                FixedCode = @"using System;
+
+class C
+{
+    Action<string> lambda = (string x!!) =>
+    {
+    };
+}
+",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestAnonymousMethod()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"using System;
+
+class C
+{
+    Action<string> lambda = delegate (string x)
+    {
+        [|if (x is null)
+            throw new ArgumentNullException(nameof(x));|]
+    };
+}
+",
+                FixedCode = @"using System;
+
+class C
+{
+    Action<string> lambda = delegate (string x!!)
+    {
+    };
+}
+",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestLocalFunctionWithinAccessor()
+        {
+            var testCode = @"using System;
+class C
+{
+    private int _p;
+
+    public int P
+    {
+        get => _p;
+        set
+        {
+            local();
+
+            void local()
+            {
+                if (value == null) throw new ArgumentNullException(nameof(value));
+                _p = value;
+            }
+        }
+    }
+}
+";
+            await new VerifyCS.Test()
+            {
+                TestCode = testCode,
+                FixedCode = testCode,
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestLocalFunctionCapturingParameter()
+        {
+            var testCode = @"using System;
+class C
+{
+    void M(string param)
+    {
+        local();
+
+        void local()
+        {
+            if (param == null)
+                throw new ArgumentNullException(nameof(param));
+        }
+    }
+}
+";
+            await new VerifyCS.Test()
+            {
+                TestCode = testCode,
+                FixedCode = testCode,
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestNotWithUserDefinedOperator()
+        {
+            var testCode = @"using System;
+class C
+{
+    public static bool operator ==(C c1, C c2) => true;
+    public static bool operator !=(C c1, C c2) => false;
+
+    static void M(C c)
+    {
+        if (c == null)
+            throw new ArgumentNullException(nameof(c));
+    }
+}
+";
+            await new VerifyCS.Test()
+            {
+                TestCode = testCode,
+                FixedCode = testCode,
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestWithUnusedUserDefinedOperator()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"using System;
+class C
+{
+    public static bool operator ==(C c1, C c2) => true;
+    public static bool operator !=(C c1, C c2) => false;
+
+    static void M(C c)
+    {
+        [|if ((object)c == null)
+            throw new ArgumentNullException(nameof(c));|]
+    }
+}
+",
+                FixedCode = @"using System;
+class C
+{
+    public static bool operator ==(C c1, C c2) => true;
+    public static bool operator !=(C c1, C c2) => false;
+
+    static void M(C c!!)
+    {
+    }
+}
+",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestIsWithUnusedUserDefinedOperator()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"using System;
+class C
+{
+    public static bool operator ==(C c1, C c2) => true;
+    public static bool operator !=(C c1, C c2) => false;
+
+    static void M(C c)
+    {
+        [|if (c is null)
+            throw new ArgumentNullException(nameof(c));|]
+    }
+}
+",
+                FixedCode = @"using System;
+class C
+{
+    public static bool operator ==(C c1, C c2) => true;
+    public static bool operator !=(C c1, C c2) => false;
+
+    static void M(C c!!)
+    {
+    }
+}
+",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestWithPreprocessorDirective()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"using System;
+class C
+{
+    static void M(C c)
+    {
+#nullable enable
+        [|if ((object)c == null)
+            throw new ArgumentNullException(nameof(c));|]
+#nullable disable
+    }
+}
+",
+                FixedCode = @"using System;
+class C
+{
+    static void M(C c!!)
+    {
+#nullable disable
+    }
+}
+",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestWithIfPreprocessorDirective()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"#define DEBUG
+using System;
+class C
+{
+    static void M(C c)
+    {
+#if DEBUG
+        [|if ((object)c == null)
+            throw new ArgumentNullException(nameof(c));|]
+#endif
+    }
+}
+",
+                FixedCode = @"#define DEBUG
+using System;
+class C
+{
+    static void M(C c!!)
+    {
+
+#if DEBUG
+#endif
+    }
+}
+",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestWithAlias()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"using Ex = System.ArgumentNullException;
+class C
+{
+    static void M(C c)
+    {
+        [|if ((object)c == null)
+            throw new Ex(nameof(c));|]
+    }
+}
+",
+                FixedCode = @"using Ex = System.ArgumentNullException;
+class C
+{
+    static void M(C c!!)
+    {
+    }
+}
+",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestPointer()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"using System;
+class C
+{
+    static unsafe void M(int* ptr)
+    {
+        [|if (ptr == null)
+            throw new ArgumentNullException(nameof(ptr));|]
+    }
+}
+",
+                FixedCode = @"using System;
+class C
+{
+    static unsafe void M(int* ptr!!)
+    {
+    }
+}
+",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestFunctionPointer()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"using System;
+class C
+{
+    static unsafe void M(delegate*<int, void> ptr)
+    {
+        [|if (ptr == null)
+            throw new ArgumentNullException(nameof(ptr));|]
+    }
+}
+",
+                FixedCode = @"using System;
+class C
+{
+    static unsafe void M(delegate*<int, void> ptr!!)
+    {
+    }
+}
+",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestPartialMethod()
+        {
+            var partialDeclaration = @"
+partial class C
+{
+    static partial void M(C c);
+}
+";
+
+            await new VerifyCS.Test()
+            {
+                TestState =
+                {
+                    Sources =
+                    {
+                        partialDeclaration,
+                        @"using System;
+partial class C
+{
+    static partial void M(C c)
+    {
+        [|if ((object)c == null)
+            throw new ArgumentNullException(nameof(c));|]
+    }
+}
+"
+                    }
+                },
+                FixedState =
+                {
+                    Sources =
+                    {
+                        partialDeclaration,
+                        @"using System;
+partial class C
+{
+    static partial void M(C c!!)
+    {
+    }
+}
+"
+                    }
+                },
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+    }
+}
diff --git a/src/Analyzers/Core/Analyzers/EnforceOnBuildValues.cs b/src/Analyzers/Core/Analyzers/EnforceOnBuildValues.cs
index e1026b4c559a1..4f5e6d27eedfe 100644
--- a/src/Analyzers/Core/Analyzers/EnforceOnBuildValues.cs
+++ b/src/Analyzers/Core/Analyzers/EnforceOnBuildValues.cs
@@ -87,6 +87,7 @@ internal static class EnforceOnBuildValues
         public const EnforceOnBuild PopulateSwitchStatement = /*IDE0010*/ EnforceOnBuild.WhenExplicitlyEnabled;
         public const EnforceOnBuild UseInferredMemberName = /*IDE0037*/ EnforceOnBuild.WhenExplicitlyEnabled;
         public const EnforceOnBuild UseIsNullCheck = /*IDE0041*/ EnforceOnBuild.WhenExplicitlyEnabled;
+        public const EnforceOnBuild UseParameterNullChecking = /*IDE0190*/ EnforceOnBuild.WhenExplicitlyEnabled;
         public const EnforceOnBuild AddRequiredParentheses = /*IDE0048*/ EnforceOnBuild.WhenExplicitlyEnabled;
         public const EnforceOnBuild ExpressionValueIsUnused = /*IDE0058*/ EnforceOnBuild.WhenExplicitlyEnabled;
         public const EnforceOnBuild MakeStructFieldsWritable = /*IDE0064*/ EnforceOnBuild.WhenExplicitlyEnabled;
diff --git a/src/Analyzers/Core/Analyzers/IDEDiagnosticIds.cs b/src/Analyzers/Core/Analyzers/IDEDiagnosticIds.cs
index 0b02a866c04ed..592390e6f38ab 100644
--- a/src/Analyzers/Core/Analyzers/IDEDiagnosticIds.cs
+++ b/src/Analyzers/Core/Analyzers/IDEDiagnosticIds.cs
@@ -167,6 +167,8 @@ internal static class IDEDiagnosticIds
 
         public const string UseTupleSwapDiagnosticId = "IDE0180";
 
+        public const string UseParameterNullCheckingId = "IDE0190";
+
         // Analyzer error Ids
         public const string AnalyzerChangedId = "IDE1001";
         public const string AnalyzerDependencyConflictId = "IDE1002";
diff --git a/src/Analyzers/Core/CodeFixes/PredefinedCodeFixProviderNames.cs b/src/Analyzers/Core/CodeFixes/PredefinedCodeFixProviderNames.cs
index 68ee4523ee54a..e84bd13bf549f 100644
--- a/src/Analyzers/Core/CodeFixes/PredefinedCodeFixProviderNames.cs
+++ b/src/Analyzers/Core/CodeFixes/PredefinedCodeFixProviderNames.cs
@@ -133,6 +133,7 @@ internal static class PredefinedCodeFixProviderNames
         public const string UseInterpolatedVerbatimString = nameof(UseInterpolatedVerbatimString);
         public const string UseIsNotExpression = nameof(UseIsNotExpression);
         public const string UseIsNullCheck = nameof(UseIsNullCheck);
+        public const string UseParameterNullChecking = nameof(UseParameterNullChecking);
         public const string UseIsNullCheckForCastAndEqualityOperator = nameof(UseIsNullCheckForCastAndEqualityOperator);
         public const string UseIsNullCheckForReferenceEquals = nameof(UseIsNullCheckForReferenceEquals);
         public const string UseLocalFunction = nameof(UseLocalFunction);
diff --git a/src/Compilers/Test/Core/Traits/Traits.cs b/src/Compilers/Test/Core/Traits/Traits.cs
index 66a26418fe87d..cb0992ea28c49 100644
--- a/src/Compilers/Test/Core/Traits/Traits.cs
+++ b/src/Compilers/Test/Core/Traits/Traits.cs
@@ -194,6 +194,7 @@ public static class Features
             public const string CodeActionsUseInterpolatedVerbatimString = "CodeActions.UseInterpolatedVerbatimString";
             public const string CodeActionsUseIsNotExpression = "CodeActions.UseIsNotExpression";
             public const string CodeActionsUseIsNullCheck = "CodeActions.UseIsNullCheck";
+            public const string CodeActionsUseParameterNullChecking = "CodeActions.UseParameterNullChecking";
             public const string CodeActionsUseLocalFunction = "CodeActions.UseLocalFunction";
             public const string CodeActionsUseNamedArguments = "CodeActions.UseNamedArguments";
             public const string CodeActionsUseNotPattern = "CodeActions.UseNotPattern";
diff --git a/src/EditorFeatures/CSharpTest/InitializeParameter/AddParameterCheckTests.cs b/src/EditorFeatures/CSharpTest/InitializeParameter/AddParameterCheckTests.cs
index 7470bfef5aabb..5a7a43b86ad35 100644
--- a/src/EditorFeatures/CSharpTest/InitializeParameter/AddParameterCheckTests.cs
+++ b/src/EditorFeatures/CSharpTest/InitializeParameter/AddParameterCheckTests.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
@@ -76,6 +76,27 @@ public C([||]string s!!)
             }.RunAsync();
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInitializeParameter)]
+        public async Task TestRecordPrimaryConstructor()
+        {
+            // https://github.com/dotnet/roslyn/issues/58779
+            // Note: we declare a field within the record to work around missing IsExternalInit errors
+            await new VerifyCS.Test
+            {
+                LanguageVersion = LanguageVersionExtensions.CSharpNext,
+                TestCode = @"
+using System;
+
+record Rec([||]string s) { public string s = s; }
+",
+                FixedCode = @"
+using System;
+
+record Rec(string s) { public string s = s; }
+"
+            }.RunAsync();
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInitializeParameter)]
         public async Task TestSimpleReferenceType_AlreadyNullChecked2()
         {
diff --git a/src/EditorFeatures/Test/Diagnostics/IDEDiagnosticIDConfigurationTests.cs b/src/EditorFeatures/Test/Diagnostics/IDEDiagnosticIDConfigurationTests.cs
index 02c55dcec4e8c..5d8b95a977999 100644
--- a/src/EditorFeatures/Test/Diagnostics/IDEDiagnosticIDConfigurationTests.cs
+++ b/src/EditorFeatures/Test/Diagnostics/IDEDiagnosticIDConfigurationTests.cs
@@ -429,6 +429,9 @@ public void CSharp_VerifyIDEDiagnosticSeveritiesAreConfigurable()
 # IDE0180
 dotnet_diagnostic.IDE0180.severity = %value%
 
+# IDE0190
+dotnet_diagnostic.IDE0190.severity = %value%
+
 # IDE2000
 dotnet_diagnostic.IDE2000.severity = %value%
 
@@ -1010,6 +1013,9 @@ No editorconfig based code style option
 # IDE0180, PreferTupleSwap
 csharp_style_prefer_tuple_swap = true
 
+# IDE0190, PreferParameterNullChecking
+csharp_style_prefer_parameter_null_checking = true
+
 # IDE1005, PreferConditionalDelegateCall
 csharp_style_conditional_delegate_call = true
 
diff --git a/src/VisualStudio/CSharp/Impl/CSharpVSResources.resx b/src/VisualStudio/CSharp/Impl/CSharpVSResources.resx
index 258958fa8a8b1..40a3b3131603e 100644
--- a/src/VisualStudio/CSharp/Impl/CSharpVSResources.resx
+++ b/src/VisualStudio/CSharp/Impl/CSharpVSResources.resx
@@ -524,6 +524,9 @@
     <value>Prefer 'is null' for reference equality checks</value>
     <comment>'is null' is a C# string and should not be localized.</comment>
   </data>
+  <data name="Prefer_parameter_null_checking" xml:space="preserve">
+    <value>Prefer parameter null checking</value>
+  </data>
   <data name="Report_invalid_placeholders_in_string_dot_format_calls" xml:space="preserve">
     <value>Report invalid placeholders in 'string.Format' calls</value>
   </data>
diff --git a/src/VisualStudio/CSharp/Impl/EditorConfigSettings/DataProvider/CodeStyle/CSharpCodeStyleSettingsProvider.cs b/src/VisualStudio/CSharp/Impl/EditorConfigSettings/DataProvider/CodeStyle/CSharpCodeStyleSettingsProvider.cs
index 1e726b9de6f24..5a391c3d78d37 100644
--- a/src/VisualStudio/CSharp/Impl/EditorConfigSettings/DataProvider/CodeStyle/CSharpCodeStyleSettingsProvider.cs
+++ b/src/VisualStudio/CSharp/Impl/EditorConfigSettings/DataProvider/CodeStyle/CSharpCodeStyleSettingsProvider.cs
@@ -103,6 +103,10 @@ private IEnumerable<CodeStyleSetting> GetNullCheckingCodeStyleOptions(AnalyzerCo
                 description: CSharpVSResources.Prefer_null_check_over_type_check,
                 editorConfigOptions: editorConfigOptions,
                 visualStudioOptions: visualStudioOptions, updater: updaterService, fileName: FileName);
+            yield return CodeStyleSetting.Create(option: CSharpCodeStyleOptions.PreferParameterNullChecking,
+                description: CSharpVSResources.Prefer_parameter_null_checking,
+                editorConfigOptions: editorConfigOptions,
+                visualStudioOptions: visualStudioOptions, updater: updaterService, fileName: FileName);
         }
 
         private IEnumerable<CodeStyleSetting> GetModifierCodeStyleOptions(AnalyzerConfigOptions editorConfigOptions, OptionSet visualStudioOptions, OptionUpdater updaterService)
diff --git a/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.Style.cs b/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.Style.cs
index e8f977663d36b..f4b23b785a1b0 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.Style.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.Style.cs
@@ -237,6 +237,12 @@ public string Style_PreferIsNullCheckOverReferenceEqualityMethod
             set { SetXmlOption(CodeStyleOptions2.PreferIsNullCheckOverReferenceEqualityMethod, value); }
         }
 
+        public string Style_PreferParameterNullChecking
+        {
+            get { return GetXmlOption(CSharpCodeStyleOptions.PreferParameterNullChecking); }
+            set { SetXmlOption(CSharpCodeStyleOptions.PreferParameterNullChecking, value); }
+        }
+
         public string Style_PreferNullCheckOverTypeCheck
         {
             get { return GetXmlOption(CSharpCodeStyleOptions.PreferNullCheckOverTypeCheck); }
diff --git a/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs b/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs
index d2fbb60139c4b..4a4d360b1675b 100644
--- a/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs
@@ -1122,6 +1122,28 @@ void M2(string value1, string value2)
 //]
     }}
 }}
+";
+
+        private static readonly string s_preferParameterNullChecking = $@"
+using System;
+
+class Customer
+{{
+//[
+    // {ServicesVSResources.Prefer_colon}
+    void M1(string value!!)
+    {{
+    }}
+//]
+//[
+    // {ServicesVSResources.Over_colon}
+    void M2(string value)
+    {{
+        if (value is null)
+            throw new ArgumentNullException(nameof(value));
+    }}
+//]
+}}
 ";
 
         private static readonly string s_preferNullcheckOverTypeCheck = $@"
@@ -2108,6 +2130,7 @@ internal StyleViewModel(OptionStore optionStore, IServiceProvider serviceProvide
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CodeStyleOptions2.PreferCoalesceExpression, ServicesVSResources.Prefer_coalesce_expression, s_preferCoalesceExpression, s_preferCoalesceExpression, this, optionStore, nullCheckingGroupTitle));
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CodeStyleOptions2.PreferNullPropagation, ServicesVSResources.Prefer_null_propagation, s_preferNullPropagation, s_preferNullPropagation, this, optionStore, nullCheckingGroupTitle));
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CodeStyleOptions2.PreferIsNullCheckOverReferenceEqualityMethod, CSharpVSResources.Prefer_is_null_for_reference_equality_checks, s_preferIsNullOverReferenceEquals, s_preferIsNullOverReferenceEquals, this, optionStore, nullCheckingGroupTitle));
+            CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.PreferParameterNullChecking, CSharpVSResources.Prefer_parameter_null_checking, s_preferParameterNullChecking, s_preferParameterNullChecking, this, optionStore, nullCheckingGroupTitle));
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.PreferNullCheckOverTypeCheck, CSharpVSResources.Prefer_null_check_over_type_check, s_preferNullcheckOverTypeCheck, s_preferNullcheckOverTypeCheck, this, optionStore, nullCheckingGroupTitle));
 
             // Using directive preferences.
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.cs.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.cs.xlf
index bcb0b9dda1e3a..c06cecf28b22f 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.cs.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.cs.xlf
@@ -142,6 +142,11 @@
         <target state="translated">Upřednostňovat kontrolu hodnoty null před kontrolou typu</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_parameter_null_checking">
+        <source>Prefer parameter null checking</source>
+        <target state="new">Prefer parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Upřednostňovat porovnávání vzorů</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.de.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.de.xlf
index c8727c855de95..5939f02eec3c0 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.de.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.de.xlf
@@ -142,6 +142,11 @@
         <target state="translated">"NULL"-Überprüfung vor Typüberprüfung bevorzugen</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_parameter_null_checking">
+        <source>Prefer parameter null checking</source>
+        <target state="new">Prefer parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Musterabgleich bevorzugen</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.es.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.es.xlf
index 9f520f7aa0694..9881a2f526e40 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.es.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.es.xlf
@@ -142,6 +142,11 @@
         <target state="translated">Preferir comprobación "null' sobre comprobación de tipo</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_parameter_null_checking">
+        <source>Prefer parameter null checking</source>
+        <target state="new">Prefer parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Preferir coincidencia de patrones</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.fr.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.fr.xlf
index 4b3d4bbe92c02..bd23ab7804c77 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.fr.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.fr.xlf
@@ -142,6 +142,11 @@
         <target state="translated">Préférer la vérification « null » à la vérification de type</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_parameter_null_checking">
+        <source>Prefer parameter null checking</source>
+        <target state="new">Prefer parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Préférer les critères spéciaux</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.it.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.it.xlf
index 436467d250a55..129b9798d0e8e 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.it.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.it.xlf
@@ -142,6 +142,11 @@
         <target state="translated">Preferisci il controllo 'null' al controllo del tipo</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_parameter_null_checking">
+        <source>Prefer parameter null checking</source>
+        <target state="new">Prefer parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Preferisci i criteri di ricerca</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ja.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ja.xlf
index 74ded6521f820..23702d25d215c 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ja.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ja.xlf
@@ -142,6 +142,11 @@
         <target state="translated">型のチェックよりも 'null 値' チェックを優先する</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_parameter_null_checking">
+        <source>Prefer parameter null checking</source>
+        <target state="new">Prefer parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">パターン マッチングを優先する</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ko.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ko.xlf
index ae5e528b54aef..7c44d4a628d73 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ko.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ko.xlf
@@ -142,6 +142,11 @@
         <target state="translated">형식 검사보다 'null' 검사 선호</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_parameter_null_checking">
+        <source>Prefer parameter null checking</source>
+        <target state="new">Prefer parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">패턴 일치 선호</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pl.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pl.xlf
index 230dbc961c0fd..c6fc1fd110317 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pl.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pl.xlf
@@ -142,6 +142,11 @@
         <target state="translated">Ustaw preferencje na sprawdzanie wartości „null” zamiast sprawdzania typu</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_parameter_null_checking">
+        <source>Prefer parameter null checking</source>
+        <target state="new">Prefer parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Preferuj dopasowywanie do wzorca</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pt-BR.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pt-BR.xlf
index c5ae128b775b0..d6544ac27686b 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pt-BR.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.pt-BR.xlf
@@ -142,6 +142,11 @@
         <target state="translated">Preferir a verificação 'nula' à verificação de tipo</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_parameter_null_checking">
+        <source>Prefer parameter null checking</source>
+        <target state="new">Prefer parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Preferir a correspondência de padrões</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ru.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ru.xlf
index c020550f114e7..40f05e0f8675c 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ru.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.ru.xlf
@@ -142,6 +142,11 @@
         <target state="translated">Предпочитать проверку "null" проверке типа</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_parameter_null_checking">
+        <source>Prefer parameter null checking</source>
+        <target state="new">Prefer parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Предпочитать соответствие шаблону</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.tr.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.tr.xlf
index d95ae7aa6044c..c0ec9176998da 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.tr.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.tr.xlf
@@ -142,6 +142,11 @@
         <target state="translated">Tür denetimi yerine 'null' denetimini tercih edin</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_parameter_null_checking">
+        <source>Prefer parameter null checking</source>
+        <target state="new">Prefer parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">Desen eşleştirmeyi tercih et</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hans.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hans.xlf
index 36757db206d37..c6461e38bfd9e 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hans.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hans.xlf
@@ -142,6 +142,11 @@
         <target state="translated">与类型检查相比，首选 Null 检查</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_parameter_null_checking">
+        <source>Prefer parameter null checking</source>
+        <target state="new">Prefer parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">首选模式匹配</target>
diff --git a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hant.xlf b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hant.xlf
index d020b3844fde6..e922ea7b6dfd6 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hant.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/CSharpVSResources.zh-Hant.xlf
@@ -142,6 +142,11 @@
         <target state="translated">建議使用 'null' 檢查而非鍵入檢查</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_parameter_null_checking">
+        <source>Prefer parameter null checking</source>
+        <target state="new">Prefer parameter null checking</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_pattern_matching">
         <source>Prefer pattern matching</source>
         <target state="translated">建議使用模式比對</target>
diff --git a/src/VisualStudio/Core/Test/Options/CSharpEditorConfigGeneratorTests.vb b/src/VisualStudio/Core/Test/Options/CSharpEditorConfigGeneratorTests.vb
index 9ba945865f45c..0fd050a669a7b 100644
--- a/src/VisualStudio/Core/Test/Options/CSharpEditorConfigGeneratorTests.vb
+++ b/src/VisualStudio/Core/Test/Options/CSharpEditorConfigGeneratorTests.vb
@@ -118,6 +118,7 @@ csharp_style_prefer_switch_expression = true
 
 # Null-checking preferences
 csharp_style_conditional_delegate_call = true
+csharp_style_prefer_parameter_null_checking = true
 
 # Modifier preferences
 csharp_prefer_static_local_function = true
@@ -351,6 +352,7 @@ csharp_style_prefer_switch_expression = true
 
 # Null-checking preferences
 csharp_style_conditional_delegate_call = true
+csharp_style_prefer_parameter_null_checking = true
 
 # Modifier preferences
 csharp_prefer_static_local_function = true
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/CodeStyle/CSharpCodeStyleOptions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/CodeStyle/CSharpCodeStyleOptions.cs
index be5c6225f880a..a9430fceb2571 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/CodeStyle/CSharpCodeStyleOptions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/CodeStyle/CSharpCodeStyleOptions.cs
@@ -300,6 +300,12 @@ private static Option2<CodeStyleOption2<AddImportPlacement>> CreateUsingDirectiv
             "csharp_style_prefer_null_check_over_type_check",
             $"TextEditor.CSharp.Specific.{nameof(PreferNullCheckOverTypeCheck)}");
 
+        internal static readonly Option2<CodeStyleOption2<bool>> PreferParameterNullChecking = CreateOption(
+            CSharpCodeStyleOptionGroups.NullCheckingPreferences, nameof(PreferParameterNullChecking),
+            defaultValue: s_trueWithSuggestionEnforcement,
+            "csharp_style_prefer_parameter_null_checking",
+            $"TextEditor.CSharp.Specific.{nameof(PreferParameterNullChecking)}");
+
         public static Option2<CodeStyleOption2<bool>> AllowEmbeddedStatementsOnSameLine { get; } = CreateOption(
             CSharpCodeStyleOptionGroups.NewLinePreferences, nameof(AllowEmbeddedStatementsOnSameLine),
             defaultValue: CodeStyleOptions2.TrueWithSilentEnforcement,

From d34406e11002f8a055f5b4b9101c83c2855d3d5e 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: Tue, 11 Jan 2022 17:22:24 -0800
Subject: [PATCH 314/444] Remove OptionSet and Workspace from TypeScript and F#
 Inline Rename interfaces (#58381)

* Remove OptionSet and Workspace from TypeScript Inline Rename interfaces

* F#

* Fixes

* Fix OmniSharpRenamer

* Feedback

* Fix null
---
 .../IVSTypeScriptEditorInlineRenameService.cs | 10 ++
 .../Api/IVSTypeScriptInlineRenameInfo.cs      |  2 +
 .../IVSTypeScriptInlineRenameLocationSet.cs   | 28 ++++++
 ...VSTypeScriptInlineRenameReplacementInfo.cs | 31 ++++++-
 .../Api/VSTypeScriptDocumentSpan.cs           | 22 +++++
 .../Api/VSTypeScriptInlineRenameInfo.cs       | 93 ++++++++-----------
 ...ypeScriptInlineRenameReplacementWrapper.cs | 10 +-
 .../VSTypeScriptEditorInlineRenameService.cs  | 36 ++++---
 ...TypeScriptInlineRenameInfoLegacyWrapper.cs | 83 +++++++++++++++++
 ...ptInlineRenameLocationSetLegacyWrapper.cs} | 11 ++-
 ...lineRenameReplacementInfoLegacyWrapper.cs} |  9 +-
 ...neRenameService.FailureInlineRenameInfo.cs |  4 +-
 .../IEditorInlineRenameService.cs             |  2 +
 .../IFSharpEditorInlineRenameService.cs       | 40 +-------
 .../InlineRename/FSharpInlineRenameInfo.cs    | 60 ++++++++++++
 .../FSharpInlineRenameLocation.cs             | 22 +++++
 .../FSharpInlineRenameLocationSet.cs          | 40 ++++++++
 .../FSharpInlineRenameReplacement.cs          | 24 +++++
 .../FSharpInlineRenameReplacementInfo.cs      | 40 ++++++++
 .../FSharpInlineRenameReplacementKind.cs      | 17 ++++
 ...FSharpInlineRenameServiceImplementation.cs | 14 +++
 .../FSharp/FSharpEditorFeaturesResources.cs   |  2 +
 .../Editor/FSharpEditorInlineRenameService.cs | 48 ++++++----
 .../OmniSharp/Rename/OmniSharpRenamer.cs      |  9 +-
 24 files changed, 520 insertions(+), 137 deletions(-)
 create mode 100644 src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/VSTypeScriptDocumentSpan.cs
 create mode 100644 src/EditorFeatures/Core/ExternalAccess/VSTypeScript/VSTypeScriptInlineRenameInfoLegacyWrapper.cs
 rename src/EditorFeatures/Core/ExternalAccess/VSTypeScript/{Api/VSTypeScriptInlineRenameLocationSet.cs => VSTypeScriptInlineRenameLocationSetLegacyWrapper.cs} (76%)
 rename src/EditorFeatures/Core/ExternalAccess/VSTypeScript/{Api/VSTypeScriptInlineRenameReplacementInfo.cs => VSTypeScriptInlineRenameReplacementInfoLegacyWrapper.cs} (77%)
 create mode 100644 src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameInfo.cs
 create mode 100644 src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameLocation.cs
 create mode 100644 src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameLocationSet.cs
 create mode 100644 src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameReplacement.cs
 create mode 100644 src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameReplacementInfo.cs
 create mode 100644 src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameReplacementKind.cs
 create mode 100644 src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameServiceImplementation.cs

diff --git a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/IVSTypeScriptEditorInlineRenameService.cs b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/IVSTypeScriptEditorInlineRenameService.cs
index 9777e2e4aeab3..6996e1db29ff2 100644
--- a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/IVSTypeScriptEditorInlineRenameService.cs
+++ b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/IVSTypeScriptEditorInlineRenameService.cs
@@ -4,6 +4,7 @@
 
 #nullable disable
 
+using System;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -12,8 +13,17 @@ namespace Microsoft.CodeAnalysis.ExternalAccess.VSTypeScript.Api
     /// <summary>
     /// Language service that allows a language to participate in the editor's inline rename feature.
     /// </summary>
+    [Obsolete]
     internal interface IVSTypeScriptEditorInlineRenameService
     {
         Task<IVSTypeScriptInlineRenameInfo> GetRenameInfoAsync(Document document, int position, CancellationToken cancellationToken);
     }
+
+    /// <summary>
+    /// Language service that allows a language to participate in the editor's inline rename feature.
+    /// </summary>
+    internal abstract class VSTypeScriptEditorInlineRenameServiceImplementation
+    {
+        public abstract Task<VSTypeScriptInlineRenameInfo> GetRenameInfoAsync(Document document, int position, CancellationToken cancellationToken);
+    }
 }
diff --git a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/IVSTypeScriptInlineRenameInfo.cs b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/IVSTypeScriptInlineRenameInfo.cs
index fc7b0ec2d5ce5..1810ad4112086 100644
--- a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/IVSTypeScriptInlineRenameInfo.cs
+++ b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/IVSTypeScriptInlineRenameInfo.cs
@@ -4,6 +4,7 @@
 
 #nullable disable
 
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Threading;
@@ -13,6 +14,7 @@
 
 namespace Microsoft.CodeAnalysis.ExternalAccess.VSTypeScript.Api
 {
+    [Obsolete]
     internal interface IVSTypeScriptInlineRenameInfo
     {
         /// <summary>
diff --git a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/IVSTypeScriptInlineRenameLocationSet.cs b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/IVSTypeScriptInlineRenameLocationSet.cs
index dc77279d9d754..f537d6f9201f1 100644
--- a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/IVSTypeScriptInlineRenameLocationSet.cs
+++ b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/IVSTypeScriptInlineRenameLocationSet.cs
@@ -4,13 +4,17 @@
 
 #nullable disable
 
+using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Options;
 
 namespace Microsoft.CodeAnalysis.ExternalAccess.VSTypeScript.Api
 {
+    [Obsolete]
     internal interface IVSTypeScriptInlineRenameLocationSet
     {
         /// <summary>
@@ -28,4 +32,28 @@ internal interface IVSTypeScriptInlineRenameLocationSet
         /// </summary>
         Task<IVSTypeScriptInlineRenameReplacementInfo> GetReplacementsAsync(string replacementText, OptionSet optionSet, CancellationToken cancellationToken);
     }
+
+    internal abstract class VSTypeScriptInlineRenameLocationSet : IInlineRenameLocationSet
+    {
+        /// <summary>
+        /// The set of locations that need to be updated with the replacement text that the user
+        /// has entered in the inline rename session.  These are the locations are all relative
+        /// to the solution when the inline rename session began.
+        /// </summary>
+        public abstract IList<VSTypeScriptInlineRenameLocationWrapper> Locations { get; }
+
+        IList<InlineRenameLocation> IInlineRenameLocationSet.Locations
+            => Locations?.Select(x => new InlineRenameLocation(x.Document, x.TextSpan)).ToList();
+
+        /// <summary>
+        /// Returns the set of replacements and their possible resolutions if the user enters the
+        /// provided replacement text and options.  Replacements are keyed by their document id
+        /// and TextSpan in the original solution, and specify their new span and possible conflict
+        /// resolution.
+        /// </summary>
+        public abstract Task<VSTypeScriptInlineRenameReplacementInfo> GetReplacementsAsync(string replacementText, CancellationToken cancellationToken);
+
+        async Task<IInlineRenameReplacementInfo> IInlineRenameLocationSet.GetReplacementsAsync(string replacementText, OptionSet optionSet, CancellationToken cancellationToken)
+            => await GetReplacementsAsync(replacementText, cancellationToken).ConfigureAwait(false);
+    }
 }
diff --git a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/IVSTypeScriptInlineRenameReplacementInfo.cs b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/IVSTypeScriptInlineRenameReplacementInfo.cs
index e312773631a5a..916247ac0ecf4 100644
--- a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/IVSTypeScriptInlineRenameReplacementInfo.cs
+++ b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/IVSTypeScriptInlineRenameReplacementInfo.cs
@@ -4,11 +4,14 @@
 
 #nullable disable
 
+using System;
 using System.Collections.Generic;
+using System.Linq;
+using Microsoft.CodeAnalysis.Editor;
 
 namespace Microsoft.CodeAnalysis.ExternalAccess.VSTypeScript.Api
-
 {
+    [Obsolete]
     internal interface IVSTypeScriptInlineRenameReplacementInfo
     {
         /// <summary>
@@ -31,4 +34,30 @@ internal interface IVSTypeScriptInlineRenameReplacementInfo
         /// </summary>
         IEnumerable<VSTypeScriptInlineRenameReplacementWrapper> GetReplacements(DocumentId documentId);
     }
+
+    internal abstract class VSTypeScriptInlineRenameReplacementInfo : IInlineRenameReplacementInfo
+    {
+        /// <summary>
+        /// The solution obtained after resolving all conflicts.
+        /// </summary>
+        public abstract Solution NewSolution { get; }
+
+        /// <summary>
+        /// Whether or not the replacement text entered by the user is valid.
+        /// </summary>
+        public abstract bool ReplacementTextValid { get; }
+
+        /// <summary>
+        /// The documents that need to be updated.
+        /// </summary>
+        public abstract IEnumerable<DocumentId> DocumentIds { get; }
+
+        /// <summary>
+        /// Returns all the replacements that need to be performed for the specified document.
+        /// </summary>
+        public abstract IEnumerable<VSTypeScriptInlineRenameReplacementWrapper> GetReplacements(DocumentId documentId);
+
+        IEnumerable<InlineRenameReplacement> IInlineRenameReplacementInfo.GetReplacements(DocumentId documentId)
+            => GetReplacements(documentId).Select(r => r.UnderlyingObject);
+    }
 }
diff --git a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/VSTypeScriptDocumentSpan.cs b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/VSTypeScriptDocumentSpan.cs
new file mode 100644
index 0000000000000..2af32609217b3
--- /dev/null
+++ b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/VSTypeScriptDocumentSpan.cs
@@ -0,0 +1,22 @@
+// 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.Text;
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.VSTypeScript.Api
+{
+    internal readonly struct VSTypeScriptDocumentSpan
+    {
+        public Document Document { get; }
+        public TextSpan SourceSpan { get; }
+
+        public VSTypeScriptDocumentSpan(Document document, TextSpan sourceSpan)
+        {
+            Document = document;
+            SourceSpan = sourceSpan;
+        }
+    }
+}
diff --git a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/VSTypeScriptInlineRenameInfo.cs b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/VSTypeScriptInlineRenameInfo.cs
index 91ed9fe7fe016..26c5184ebbd87 100644
--- a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/VSTypeScriptInlineRenameInfo.cs
+++ b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/VSTypeScriptInlineRenameInfo.cs
@@ -4,77 +4,58 @@
 
 #nullable disable
 
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Rename;
 using Microsoft.CodeAnalysis.Text;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.ExternalAccess.VSTypeScript.Api
 {
-    internal sealed class VSTypeScriptInlineRenameInfo : IInlineRenameInfo
+    internal abstract class VSTypeScriptInlineRenameInfo : IInlineRenameInfo
     {
-        private readonly IVSTypeScriptInlineRenameInfo _info;
-
-        public VSTypeScriptInlineRenameInfo(IVSTypeScriptInlineRenameInfo info)
-        {
-            Contract.ThrowIfNull(info);
-            _info = info;
-        }
-
-        public bool CanRename => _info.CanRename;
-
-        public string LocalizedErrorMessage => _info.LocalizedErrorMessage;
-
-        public TextSpan TriggerSpan => _info.TriggerSpan;
-
-        public bool HasOverloads => _info.HasOverloads;
-
-        public bool ForceRenameOverloads => _info.ForceRenameOverloads;
-
-        public string DisplayName => _info.DisplayName;
-
-        public string FullDisplayName => _info.FullDisplayName;
-
-        public Glyph Glyph => VSTypeScriptGlyphHelpers.ConvertTo(_info.Glyph);
-
-        public ImmutableArray<DocumentSpan> DefinitionLocations => _info.DefinitionLocations;
-
-        public async Task<IInlineRenameLocationSet> FindRenameLocationsAsync(OptionSet optionSet, CancellationToken cancellationToken)
-        {
-            var set = await _info.FindRenameLocationsAsync(optionSet, cancellationToken).ConfigureAwait(false);
-            if (set != null)
-            {
-                return new VSTypeScriptInlineRenameLocationSet(set);
-            }
-            else
-            {
-                return null;
-            }
-        }
-
-        public TextSpan? GetConflictEditSpan(InlineRenameLocation location, string triggerText, string replacementText, CancellationToken cancellationToken)
-        {
-            return _info.GetConflictEditSpan(new VSTypeScriptInlineRenameLocationWrapper(
+        public abstract bool CanRename { get; }
+        public abstract string DisplayName { get; }
+        public abstract string FullDisplayName { get; }
+        public abstract VSTypeScriptGlyph Glyph { get; }
+        public abstract bool HasOverloads { get; }
+        public abstract bool ForceRenameOverloads { get; }
+        public abstract string LocalizedErrorMessage { get; }
+        public abstract TextSpan TriggerSpan { get; }
+        public abstract ImmutableArray<VSTypeScriptDocumentSpan> DefinitionLocations { get; }
+        public abstract Task<VSTypeScriptInlineRenameLocationSet> FindRenameLocationsAsync(bool renameInStrings, bool renameInComments, CancellationToken cancellationToken);
+        public abstract TextSpan? GetConflictEditSpan(VSTypeScriptInlineRenameLocationWrapper location, string replacementText, CancellationToken cancellationToken);
+        public abstract string GetFinalSymbolName(string replacementText);
+        public abstract TextSpan GetReferenceEditSpan(VSTypeScriptInlineRenameLocationWrapper location, CancellationToken cancellationToken);
+
+        Glyph IInlineRenameInfo.Glyph
+            => VSTypeScriptGlyphHelpers.ConvertTo(Glyph);
+
+        ImmutableArray<DocumentSpan> IInlineRenameInfo.DefinitionLocations
+            => DefinitionLocations.SelectAsArray(l => new DocumentSpan(l.Document, l.SourceSpan));
+
+        async Task<IInlineRenameLocationSet> IInlineRenameInfo.FindRenameLocationsAsync(OptionSet optionSet, CancellationToken cancellationToken)
+            => await FindRenameLocationsAsync(
+                optionSet.GetOption(RenameOptions.RenameInStrings),
+                optionSet.GetOption(RenameOptions.RenameInComments),
+                cancellationToken).ConfigureAwait(false);
+
+        TextSpan? IInlineRenameInfo.GetConflictEditSpan(InlineRenameLocation location, string triggerText, string replacementText, CancellationToken cancellationToken)
+            => GetConflictEditSpan(new VSTypeScriptInlineRenameLocationWrapper(
                 new InlineRenameLocation(location.Document, location.TextSpan)), replacementText, cancellationToken);
-        }
-
-        public string GetFinalSymbolName(string replacementText)
-            => _info.GetFinalSymbolName(replacementText);
 
-        public TextSpan GetReferenceEditSpan(InlineRenameLocation location, string triggerText, CancellationToken cancellationToken)
-        {
-            return _info.GetReferenceEditSpan(new VSTypeScriptInlineRenameLocationWrapper(
+        TextSpan IInlineRenameInfo.GetReferenceEditSpan(InlineRenameLocation location, string triggerText, CancellationToken cancellationToken)
+            => GetReferenceEditSpan(new VSTypeScriptInlineRenameLocationWrapper(
                 new InlineRenameLocation(location.Document, location.TextSpan)), cancellationToken);
-        }
 
-        public bool TryOnAfterGlobalSymbolRenamed(Workspace workspace, IEnumerable<DocumentId> changedDocumentIDs, string replacementText)
-            => _info.TryOnAfterGlobalSymbolRenamed(workspace, changedDocumentIDs, replacementText);
+        bool IInlineRenameInfo.TryOnAfterGlobalSymbolRenamed(Workspace workspace, IEnumerable<DocumentId> changedDocumentIDs, string replacementText)
+            => true;
 
-        public bool TryOnBeforeGlobalSymbolRenamed(Workspace workspace, IEnumerable<DocumentId> changedDocumentIDs, string replacementText)
-            => _info.TryOnBeforeGlobalSymbolRenamed(workspace, changedDocumentIDs, replacementText);
+        bool IInlineRenameInfo.TryOnBeforeGlobalSymbolRenamed(Workspace workspace, IEnumerable<DocumentId> changedDocumentIDs, string replacementText)
+            => true;
     }
 }
diff --git a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/VSTypeScriptInlineRenameReplacementWrapper.cs b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/VSTypeScriptInlineRenameReplacementWrapper.cs
index f71c0a6f60455..f0c9c3fa5cb4e 100644
--- a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/VSTypeScriptInlineRenameReplacementWrapper.cs
+++ b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/VSTypeScriptInlineRenameReplacementWrapper.cs
@@ -11,13 +11,13 @@ namespace Microsoft.CodeAnalysis.ExternalAccess.VSTypeScript.Api
 {
     internal readonly struct VSTypeScriptInlineRenameReplacementWrapper
     {
-        private readonly InlineRenameReplacement _underlyingObject;
+        internal readonly InlineRenameReplacement UnderlyingObject;
 
         public VSTypeScriptInlineRenameReplacementWrapper(InlineRenameReplacement underlyingObject)
-            => _underlyingObject = underlyingObject;
+            => UnderlyingObject = underlyingObject;
 
-        public VSTypeScriptInlineRenameReplacementKind Kind => VSTypeScriptInlineRenameReplacementKindHelpers.ConvertFrom(_underlyingObject.Kind);
-        public TextSpan OriginalSpan => _underlyingObject.OriginalSpan;
-        public TextSpan NewSpan => _underlyingObject.NewSpan;
+        public VSTypeScriptInlineRenameReplacementKind Kind => VSTypeScriptInlineRenameReplacementKindHelpers.ConvertFrom(UnderlyingObject.Kind);
+        public TextSpan OriginalSpan => UnderlyingObject.OriginalSpan;
+        public TextSpan NewSpan => UnderlyingObject.NewSpan;
     }
 }
diff --git a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/VSTypeScriptEditorInlineRenameService.cs b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/VSTypeScriptEditorInlineRenameService.cs
index cf14751ed5a01..e747339577090 100644
--- a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/VSTypeScriptEditorInlineRenameService.cs
+++ b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/VSTypeScriptEditorInlineRenameService.cs
@@ -2,16 +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.
 
-#nullable disable
-
+using System;
+using System.Composition;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor;
-using Roslyn.Utilities;
-using System.Composition;
-using Microsoft.CodeAnalysis.Host.Mef;
-using System;
+using Microsoft.CodeAnalysis.Editor.Implementation.InlineRename;
 using Microsoft.CodeAnalysis.ExternalAccess.VSTypeScript.Api;
+using Microsoft.CodeAnalysis.Host.Mef;
 
 namespace Microsoft.CodeAnalysis.ExternalAccess.VSTypeScript
 {
@@ -19,27 +17,37 @@ namespace Microsoft.CodeAnalysis.ExternalAccess.VSTypeScript
     [ExportLanguageService(typeof(IEditorInlineRenameService), InternalLanguageNames.TypeScript)]
     internal sealed class VSTypeScriptEditorInlineRenameService : IEditorInlineRenameService
     {
-        private readonly Lazy<IVSTypeScriptEditorInlineRenameService> _service;
+        [Obsolete]
+        private readonly Lazy<IVSTypeScriptEditorInlineRenameService>? _legacyService;
+
+        private readonly Lazy<VSTypeScriptEditorInlineRenameServiceImplementation>? _service;
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public VSTypeScriptEditorInlineRenameService(Lazy<IVSTypeScriptEditorInlineRenameService> service)
+        public VSTypeScriptEditorInlineRenameService(
+            [Import(AllowDefault = true)] Lazy<IVSTypeScriptEditorInlineRenameService>? legacyService,
+            [Import(AllowDefault = true)] Lazy<VSTypeScriptEditorInlineRenameServiceImplementation>? service)
         {
-            Contract.ThrowIfNull(service);
             _service = service;
+            _legacyService = legacyService;
         }
 
         public async Task<IInlineRenameInfo> GetRenameInfoAsync(Document document, int position, CancellationToken cancellationToken)
         {
-            var info = await _service.Value.GetRenameInfoAsync(document, position, cancellationToken).ConfigureAwait(false);
-            if (info != null)
+#pragma warning disable CS0612 // Type or member is obsolete
+            if (_legacyService != null)
             {
-                return new VSTypeScriptInlineRenameInfo(info);
+                var info = await _legacyService.Value.GetRenameInfoAsync(document, position, cancellationToken).ConfigureAwait(false);
+                return (info != null) ? new VSTypeScriptInlineRenameInfoLegacyWrapper(info) : AbstractEditorInlineRenameService.DefaultFailureInfo;
             }
-            else
+#pragma warning restore
+
+            if (_service != null)
             {
-                return null;
+                return await _service.Value.GetRenameInfoAsync(document, position, cancellationToken).ConfigureAwait(false);
             }
+
+            return AbstractEditorInlineRenameService.DefaultFailureInfo;
         }
     }
 }
diff --git a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/VSTypeScriptInlineRenameInfoLegacyWrapper.cs b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/VSTypeScriptInlineRenameInfoLegacyWrapper.cs
new file mode 100644
index 0000000000000..74373d9879823
--- /dev/null
+++ b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/VSTypeScriptInlineRenameInfoLegacyWrapper.cs
@@ -0,0 +1,83 @@
+// 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 System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Editor;
+using Microsoft.CodeAnalysis.ExternalAccess.VSTypeScript.Api;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Text;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.VSTypeScript
+{
+    [Obsolete]
+    internal sealed class VSTypeScriptInlineRenameInfoLegacyWrapper : IInlineRenameInfo
+    {
+        private readonly IVSTypeScriptInlineRenameInfo _info;
+
+        public VSTypeScriptInlineRenameInfoLegacyWrapper(IVSTypeScriptInlineRenameInfo info)
+        {
+            Contract.ThrowIfNull(info);
+            _info = info;
+        }
+
+        public bool CanRename => _info.CanRename;
+
+        public string LocalizedErrorMessage => _info.LocalizedErrorMessage;
+
+        public TextSpan TriggerSpan => _info.TriggerSpan;
+
+        public bool HasOverloads => _info.HasOverloads;
+
+        public bool ForceRenameOverloads => _info.ForceRenameOverloads;
+
+        public string DisplayName => _info.DisplayName;
+
+        public string FullDisplayName => _info.FullDisplayName;
+
+        public Glyph Glyph => VSTypeScriptGlyphHelpers.ConvertTo(_info.Glyph);
+
+        public ImmutableArray<DocumentSpan> DefinitionLocations => _info.DefinitionLocations;
+
+        public async Task<IInlineRenameLocationSet> FindRenameLocationsAsync(OptionSet optionSet, CancellationToken cancellationToken)
+        {
+            var set = await _info.FindRenameLocationsAsync(optionSet, cancellationToken).ConfigureAwait(false);
+            if (set != null)
+            {
+                return new VSTypeScriptInlineRenameLocationSetLegacyWrapper(set);
+            }
+            else
+            {
+                return null;
+            }
+        }
+
+        public TextSpan? GetConflictEditSpan(InlineRenameLocation location, string triggerText, string replacementText, CancellationToken cancellationToken)
+        {
+            return _info.GetConflictEditSpan(new VSTypeScriptInlineRenameLocationWrapper(
+                new InlineRenameLocation(location.Document, location.TextSpan)), replacementText, cancellationToken);
+        }
+
+        public string GetFinalSymbolName(string replacementText)
+            => _info.GetFinalSymbolName(replacementText);
+
+        public TextSpan GetReferenceEditSpan(InlineRenameLocation location, string triggerText, CancellationToken cancellationToken)
+        {
+            return _info.GetReferenceEditSpan(new VSTypeScriptInlineRenameLocationWrapper(
+                new InlineRenameLocation(location.Document, location.TextSpan)), cancellationToken);
+        }
+
+        public bool TryOnAfterGlobalSymbolRenamed(Workspace workspace, IEnumerable<DocumentId> changedDocumentIDs, string replacementText)
+            => _info.TryOnAfterGlobalSymbolRenamed(workspace, changedDocumentIDs, replacementText);
+
+        public bool TryOnBeforeGlobalSymbolRenamed(Workspace workspace, IEnumerable<DocumentId> changedDocumentIDs, string replacementText)
+            => _info.TryOnBeforeGlobalSymbolRenamed(workspace, changedDocumentIDs, replacementText);
+    }
+}
diff --git a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/VSTypeScriptInlineRenameLocationSet.cs b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/VSTypeScriptInlineRenameLocationSetLegacyWrapper.cs
similarity index 76%
rename from src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/VSTypeScriptInlineRenameLocationSet.cs
rename to src/EditorFeatures/Core/ExternalAccess/VSTypeScript/VSTypeScriptInlineRenameLocationSetLegacyWrapper.cs
index 37f453668dce1..457c054ecd15c 100644
--- a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/VSTypeScriptInlineRenameLocationSet.cs
+++ b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/VSTypeScriptInlineRenameLocationSetLegacyWrapper.cs
@@ -4,21 +4,24 @@
 
 #nullable disable
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor;
+using Microsoft.CodeAnalysis.ExternalAccess.VSTypeScript.Api;
 using Microsoft.CodeAnalysis.Options;
 using Roslyn.Utilities;
 
-namespace Microsoft.CodeAnalysis.ExternalAccess.VSTypeScript.Api
+namespace Microsoft.CodeAnalysis.ExternalAccess.VSTypeScript
 {
-    internal sealed class VSTypeScriptInlineRenameLocationSet : IInlineRenameLocationSet
+    [Obsolete]
+    internal sealed class VSTypeScriptInlineRenameLocationSetLegacyWrapper : IInlineRenameLocationSet
     {
         private readonly IVSTypeScriptInlineRenameLocationSet _set;
 
-        public VSTypeScriptInlineRenameLocationSet(IVSTypeScriptInlineRenameLocationSet set)
+        public VSTypeScriptInlineRenameLocationSetLegacyWrapper(IVSTypeScriptInlineRenameLocationSet set)
         {
             Contract.ThrowIfNull(set);
             _set = set;
@@ -32,7 +35,7 @@ public async Task<IInlineRenameReplacementInfo> GetReplacementsAsync(string repl
             var info = await _set.GetReplacementsAsync(replacementText, optionSet, cancellationToken).ConfigureAwait(false);
             if (info != null)
             {
-                return new VSTypeScriptInlineRenameReplacementInfo(info);
+                return new VSTypeScriptInlineRenameReplacementInfoLegacyWrapper(info);
             }
             else
             {
diff --git a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/VSTypeScriptInlineRenameReplacementInfo.cs b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/VSTypeScriptInlineRenameReplacementInfoLegacyWrapper.cs
similarity index 77%
rename from src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/VSTypeScriptInlineRenameReplacementInfo.cs
rename to src/EditorFeatures/Core/ExternalAccess/VSTypeScript/VSTypeScriptInlineRenameReplacementInfoLegacyWrapper.cs
index 60fb037582482..cfa1b4282b8aa 100644
--- a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/Api/VSTypeScriptInlineRenameReplacementInfo.cs
+++ b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/VSTypeScriptInlineRenameReplacementInfoLegacyWrapper.cs
@@ -4,18 +4,21 @@
 
 #nullable disable
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using Microsoft.CodeAnalysis.Editor;
+using Microsoft.CodeAnalysis.ExternalAccess.VSTypeScript.Api;
 using Roslyn.Utilities;
 
-namespace Microsoft.CodeAnalysis.ExternalAccess.VSTypeScript.Api
+namespace Microsoft.CodeAnalysis.ExternalAccess.VSTypeScript
 {
-    internal sealed class VSTypeScriptInlineRenameReplacementInfo : IInlineRenameReplacementInfo
+    [Obsolete]
+    internal sealed class VSTypeScriptInlineRenameReplacementInfoLegacyWrapper : IInlineRenameReplacementInfo
     {
         private readonly IVSTypeScriptInlineRenameReplacementInfo _info;
 
-        public VSTypeScriptInlineRenameReplacementInfo(IVSTypeScriptInlineRenameReplacementInfo info)
+        public VSTypeScriptInlineRenameReplacementInfoLegacyWrapper(IVSTypeScriptInlineRenameReplacementInfo info)
         {
             Contract.ThrowIfNull(info);
             _info = info;
diff --git a/src/EditorFeatures/Core/Implementation/InlineRename/AbstractEditorInlineRenameService.FailureInlineRenameInfo.cs b/src/EditorFeatures/Core/Implementation/InlineRename/AbstractEditorInlineRenameService.FailureInlineRenameInfo.cs
index 5be670ca869ec..a0f4d0b21a798 100644
--- a/src/EditorFeatures/Core/Implementation/InlineRename/AbstractEditorInlineRenameService.FailureInlineRenameInfo.cs
+++ b/src/EditorFeatures/Core/Implementation/InlineRename/AbstractEditorInlineRenameService.FailureInlineRenameInfo.cs
@@ -15,7 +15,9 @@ namespace Microsoft.CodeAnalysis.Editor.Implementation.InlineRename
 {
     internal abstract partial class AbstractEditorInlineRenameService
     {
-        private class FailureInlineRenameInfo : IInlineRenameInfo
+        internal static readonly IInlineRenameInfo DefaultFailureInfo = new FailureInlineRenameInfo(EditorFeaturesResources.You_cannot_rename_this_element);
+
+        private sealed class FailureInlineRenameInfo : IInlineRenameInfo
         {
             public FailureInlineRenameInfo(string localizedErrorMessage)
                 => this.LocalizedErrorMessage = localizedErrorMessage;
diff --git a/src/EditorFeatures/Core/Implementation/InlineRename/IEditorInlineRenameService.cs b/src/EditorFeatures/Core/Implementation/InlineRename/IEditorInlineRenameService.cs
index 00e0deafb732b..34208262782d3 100644
--- a/src/EditorFeatures/Core/Implementation/InlineRename/IEditorInlineRenameService.cs
+++ b/src/EditorFeatures/Core/Implementation/InlineRename/IEditorInlineRenameService.cs
@@ -249,6 +249,8 @@ internal interface IInlineRenameInfoWithFileRename : IInlineRenameInfo
         InlineRenameFileRenameInfo GetFileRenameInfo();
     }
 
+#nullable enable
+
     /// <summary>
     /// Language service that allows a language to participate in the editor's inline rename feature.
     /// </summary>
diff --git a/src/Tools/ExternalAccess/FSharp/Editor/IFSharpEditorInlineRenameService.cs b/src/Tools/ExternalAccess/FSharp/Editor/IFSharpEditorInlineRenameService.cs
index 7041deec76cac..fc2346566e0b8 100644
--- a/src/Tools/ExternalAccess/FSharp/Editor/IFSharpEditorInlineRenameService.cs
+++ b/src/Tools/ExternalAccess/FSharp/Editor/IFSharpEditorInlineRenameService.cs
@@ -4,6 +4,7 @@
 
 #nullable disable
 
+using System;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
@@ -13,41 +14,7 @@
 
 namespace Microsoft.CodeAnalysis.ExternalAccess.FSharp.Editor
 {
-    internal readonly struct FSharpInlineRenameLocation
-    {
-        public Document Document { get; }
-        public TextSpan TextSpan { get; }
-
-        public FSharpInlineRenameLocation(Document document, TextSpan textSpan)
-        {
-            this.Document = document;
-            this.TextSpan = textSpan;
-        }
-    }
-
-    internal enum FSharpInlineRenameReplacementKind
-    {
-        NoConflict,
-        ResolvedReferenceConflict,
-        ResolvedNonReferenceConflict,
-        UnresolvedConflict,
-        Complexified,
-    }
-
-    internal readonly struct FSharpInlineRenameReplacement
-    {
-        public FSharpInlineRenameReplacementKind Kind { get; }
-        public TextSpan OriginalSpan { get; }
-        public TextSpan NewSpan { get; }
-
-        public FSharpInlineRenameReplacement(FSharpInlineRenameReplacementKind kind, TextSpan originalSpan, TextSpan newSpan)
-        {
-            this.Kind = kind;
-            this.OriginalSpan = originalSpan;
-            this.NewSpan = newSpan;
-        }
-    }
-
+    [Obsolete]
     internal interface IFSharpInlineRenameReplacementInfo
     {
         /// <summary>
@@ -71,6 +38,7 @@ internal interface IFSharpInlineRenameReplacementInfo
         IEnumerable<FSharpInlineRenameReplacement> GetReplacements(DocumentId documentId);
     }
 
+    [Obsolete]
     internal interface IFSharpInlineRenameLocationSet
     {
         /// <summary>
@@ -89,6 +57,7 @@ internal interface IFSharpInlineRenameLocationSet
         Task<IFSharpInlineRenameReplacementInfo> GetReplacementsAsync(string replacementText, OptionSet optionSet, CancellationToken cancellationToken);
     }
 
+    [Obsolete]
     internal interface IFSharpInlineRenameInfo
     {
         /// <summary>
@@ -175,6 +144,7 @@ internal interface IFSharpInlineRenameInfo
     /// <summary>
     /// Language service that allows a language to participate in the editor's inline rename feature.
     /// </summary>
+    [Obsolete]
     internal interface IFSharpEditorInlineRenameService
     {
         Task<IFSharpInlineRenameInfo> GetRenameInfoAsync(Document document, int position, CancellationToken cancellationToken);
diff --git a/src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameInfo.cs b/src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameInfo.cs
new file mode 100644
index 0000000000000..97083cf5d5f6c
--- /dev/null
+++ b/src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameInfo.cs
@@ -0,0 +1,60 @@
+// 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 System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Editor;
+using Microsoft.CodeAnalysis.ExternalAccess.FSharp.Internal;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Rename;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.FSharp.Editor
+{
+    internal abstract class FSharpInlineRenameInfo : IInlineRenameInfo
+    {
+        public abstract bool CanRename { get; }
+        public abstract string DisplayName { get; }
+        public abstract string FullDisplayName { get; }
+        public abstract FSharpGlyph Glyph { get; }
+        public abstract bool HasOverloads { get; }
+        public abstract bool ForceRenameOverloads { get; }
+        public abstract string LocalizedErrorMessage { get; }
+        public abstract TextSpan TriggerSpan { get; }
+        public abstract ImmutableArray<FSharpInlineRenameLocation> DefinitionLocations { get; }
+        public abstract Task<FSharpInlineRenameLocationSet> FindRenameLocationsAsync(bool renameInStrings, bool renameInComments, CancellationToken cancellationToken);
+        public abstract TextSpan? GetConflictEditSpan(FSharpInlineRenameLocation location, string replacementText, CancellationToken cancellationToken);
+        public abstract string GetFinalSymbolName(string replacementText);
+        public abstract TextSpan GetReferenceEditSpan(FSharpInlineRenameLocation location, CancellationToken cancellationToken);
+
+        Glyph IInlineRenameInfo.Glyph
+            => FSharpGlyphHelpers.ConvertTo(Glyph);
+
+        ImmutableArray<DocumentSpan> IInlineRenameInfo.DefinitionLocations
+            => DefinitionLocations.SelectAsArray(l => new DocumentSpan(l.Document, l.TextSpan));
+
+        async Task<IInlineRenameLocationSet> IInlineRenameInfo.FindRenameLocationsAsync(OptionSet optionSet, CancellationToken cancellationToken)
+            => await FindRenameLocationsAsync(
+                optionSet.GetOption(RenameOptions.RenameInStrings),
+                optionSet.GetOption(RenameOptions.RenameInComments),
+                cancellationToken).ConfigureAwait(false);
+
+        TextSpan? IInlineRenameInfo.GetConflictEditSpan(InlineRenameLocation location, string triggerText, string replacementText, CancellationToken cancellationToken)
+            => GetConflictEditSpan(new FSharpInlineRenameLocation(location.Document, location.TextSpan), replacementText, cancellationToken);
+
+        TextSpan IInlineRenameInfo.GetReferenceEditSpan(InlineRenameLocation location, string triggerText, CancellationToken cancellationToken)
+            => GetReferenceEditSpan(new FSharpInlineRenameLocation(location.Document, location.TextSpan), cancellationToken);
+
+        bool IInlineRenameInfo.TryOnAfterGlobalSymbolRenamed(Workspace workspace, IEnumerable<DocumentId> changedDocumentIDs, string replacementText)
+            => true;
+
+        bool IInlineRenameInfo.TryOnBeforeGlobalSymbolRenamed(Workspace workspace, IEnumerable<DocumentId> changedDocumentIDs, string replacementText)
+            => true;
+    }
+}
diff --git a/src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameLocation.cs b/src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameLocation.cs
new file mode 100644
index 0000000000000..bb7fadd347527
--- /dev/null
+++ b/src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameLocation.cs
@@ -0,0 +1,22 @@
+// 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.Text;
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.FSharp.Editor
+{
+    internal readonly struct FSharpInlineRenameLocation
+    {
+        public Document Document { get; }
+        public TextSpan TextSpan { get; }
+
+        public FSharpInlineRenameLocation(Document document, TextSpan textSpan)
+        {
+            this.Document = document;
+            this.TextSpan = textSpan;
+        }
+    }
+}
diff --git a/src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameLocationSet.cs b/src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameLocationSet.cs
new file mode 100644
index 0000000000000..22059c2475841
--- /dev/null
+++ b/src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameLocationSet.cs
@@ -0,0 +1,40 @@
+// 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 System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Editor;
+using Microsoft.CodeAnalysis.Options;
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.FSharp.Editor
+{
+    internal abstract class FSharpInlineRenameLocationSet : IInlineRenameLocationSet
+    {
+        /// <summary>
+        /// The set of locations that need to be updated with the replacement text that the user
+        /// has entered in the inline rename session.  These are the locations are all relative
+        /// to the solution when the inline rename session began.
+        /// </summary>
+        public abstract IList<FSharpInlineRenameLocation> Locations { get; }
+
+        IList<InlineRenameLocation> IInlineRenameLocationSet.Locations
+            => Locations?.Select(x => new InlineRenameLocation(x.Document, x.TextSpan)).ToList();
+
+        /// <summary>
+        /// Returns the set of replacements and their possible resolutions if the user enters the
+        /// provided replacement text and options.  Replacements are keyed by their document id
+        /// and TextSpan in the original solution, and specify their new span and possible conflict
+        /// resolution.
+        /// </summary>
+        public abstract Task<FSharpInlineRenameReplacementInfo> GetReplacementsAsync(string replacementText, CancellationToken cancellationToken);
+
+        async Task<IInlineRenameReplacementInfo> IInlineRenameLocationSet.GetReplacementsAsync(string replacementText, OptionSet optionSet, CancellationToken cancellationToken)
+            => await GetReplacementsAsync(replacementText, cancellationToken).ConfigureAwait(false);
+    }
+}
diff --git a/src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameReplacement.cs b/src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameReplacement.cs
new file mode 100644
index 0000000000000..c437c15517372
--- /dev/null
+++ b/src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameReplacement.cs
@@ -0,0 +1,24 @@
+// 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.Text;
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.FSharp.Editor
+{
+    internal readonly struct FSharpInlineRenameReplacement
+    {
+        public FSharpInlineRenameReplacementKind Kind { get; }
+        public TextSpan OriginalSpan { get; }
+        public TextSpan NewSpan { get; }
+
+        public FSharpInlineRenameReplacement(FSharpInlineRenameReplacementKind kind, TextSpan originalSpan, TextSpan newSpan)
+        {
+            this.Kind = kind;
+            this.OriginalSpan = originalSpan;
+            this.NewSpan = newSpan;
+        }
+    }
+}
diff --git a/src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameReplacementInfo.cs b/src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameReplacementInfo.cs
new file mode 100644
index 0000000000000..035d18ef86c94
--- /dev/null
+++ b/src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameReplacementInfo.cs
@@ -0,0 +1,40 @@
+// 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 System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.CodeAnalysis.Editor;
+using Microsoft.CodeAnalysis.ExternalAccess.FSharp.Internal.Editor;
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.FSharp.Editor
+{
+    internal abstract class FSharpInlineRenameReplacementInfo : IInlineRenameReplacementInfo
+    {
+        /// <summary>
+        /// The solution obtained after resolving all conflicts.
+        /// </summary>
+        public abstract Solution NewSolution { get; }
+
+        /// <summary>
+        /// Whether or not the replacement text entered by the user is valid.
+        /// </summary>
+        public abstract bool ReplacementTextValid { get; }
+
+        /// <summary>
+        /// The documents that need to be updated.
+        /// </summary>
+        public abstract IEnumerable<DocumentId> DocumentIds { get; }
+
+        /// <summary>
+        /// Returns all the replacements that need to be performed for the specified document.
+        /// </summary>
+        public abstract IEnumerable<FSharpInlineRenameReplacement> GetReplacements(DocumentId documentId);
+
+        IEnumerable<InlineRenameReplacement> IInlineRenameReplacementInfo.GetReplacements(DocumentId documentId)
+            => GetReplacements(documentId).Select(r => new InlineRenameReplacement(FSharpInlineRenameReplacementKindHelpers.ConvertTo(r.Kind), r.OriginalSpan, r.NewSpan));
+    }
+}
diff --git a/src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameReplacementKind.cs b/src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameReplacementKind.cs
new file mode 100644
index 0000000000000..ea81beb3c5d29
--- /dev/null
+++ b/src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameReplacementKind.cs
@@ -0,0 +1,17 @@
+// 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
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.FSharp.Editor
+{
+    internal enum FSharpInlineRenameReplacementKind
+    {
+        NoConflict,
+        ResolvedReferenceConflict,
+        ResolvedNonReferenceConflict,
+        UnresolvedConflict,
+        Complexified,
+    }
+}
diff --git a/src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameServiceImplementation.cs b/src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameServiceImplementation.cs
new file mode 100644
index 0000000000000..f853f189b494d
--- /dev/null
+++ b/src/Tools/ExternalAccess/FSharp/Editor/InlineRename/FSharpInlineRenameServiceImplementation.cs
@@ -0,0 +1,14 @@
+// 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.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.FSharp.Editor
+{
+    internal abstract class FSharpInlineRenameServiceImplementation
+    {
+        public abstract Task<FSharpInlineRenameInfo?> GetRenameInfoAsync(Document document, int position, CancellationToken cancellationToken);
+    }
+}
diff --git a/src/Tools/ExternalAccess/FSharp/FSharpEditorFeaturesResources.cs b/src/Tools/ExternalAccess/FSharp/FSharpEditorFeaturesResources.cs
index 9b0a0169f383b..ead5781134856 100644
--- a/src/Tools/ExternalAccess/FSharp/FSharpEditorFeaturesResources.cs
+++ b/src/Tools/ExternalAccess/FSharp/FSharpEditorFeaturesResources.cs
@@ -4,10 +4,12 @@
 
 #nullable disable
 
+using System;
 using Microsoft.CodeAnalysis.Editor;
 
 namespace Microsoft.CodeAnalysis.ExternalAccess.FSharp
 {
+    [Obsolete]
     internal static class FSharpEditorFeaturesResources
     {
         public static string You_cannot_rename_this_element => EditorFeaturesResources.You_cannot_rename_this_element;
diff --git a/src/Tools/ExternalAccess/FSharp/Internal/Editor/FSharpEditorInlineRenameService.cs b/src/Tools/ExternalAccess/FSharp/Internal/Editor/FSharpEditorInlineRenameService.cs
index 0f645ef1565e3..1821d93502eef 100644
--- a/src/Tools/ExternalAccess/FSharp/Internal/Editor/FSharpEditorInlineRenameService.cs
+++ b/src/Tools/ExternalAccess/FSharp/Internal/Editor/FSharpEditorInlineRenameService.cs
@@ -7,16 +7,17 @@
 using System;
 using System.Linq;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Composition;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor;
+using Microsoft.CodeAnalysis.Editor.Implementation.InlineRename;
 using Microsoft.CodeAnalysis.ExternalAccess.FSharp.Editor;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
-using System.Collections.Immutable;
 
 namespace Microsoft.CodeAnalysis.ExternalAccess.FSharp.Internal.Editor
 {
@@ -59,11 +60,12 @@ public static InlineRenameReplacementKind ConvertTo(FSharpInlineRenameReplacemen
         }
     }
 
-    internal class FSharpInlineRenameReplacementInfo : IInlineRenameReplacementInfo
+    [Obsolete]
+    internal class FSharpInlineRenameReplacementInfoLegacyWrapper : IInlineRenameReplacementInfo
     {
         private readonly IFSharpInlineRenameReplacementInfo _info;
 
-        public FSharpInlineRenameReplacementInfo(IFSharpInlineRenameReplacementInfo info)
+        public FSharpInlineRenameReplacementInfoLegacyWrapper(IFSharpInlineRenameReplacementInfo info)
         {
             _info = info;
         }
@@ -81,12 +83,13 @@ public IEnumerable<InlineRenameReplacement> GetReplacements(DocumentId documentI
         }
     }
 
-    internal class FSharpInlineRenameLocationSet : IInlineRenameLocationSet
+    [Obsolete]
+    internal class FSharpInlineRenameLocationSetLegacyWrapper : IInlineRenameLocationSet
     {
         private readonly IFSharpInlineRenameLocationSet _set;
         private readonly IList<InlineRenameLocation> _locations;
 
-        public FSharpInlineRenameLocationSet(IFSharpInlineRenameLocationSet set)
+        public FSharpInlineRenameLocationSetLegacyWrapper(IFSharpInlineRenameLocationSet set)
         {
             _set = set;
             _locations = set.Locations?.Select(x => new InlineRenameLocation(x.Document, x.TextSpan)).ToList();
@@ -99,7 +102,7 @@ public async Task<IInlineRenameReplacementInfo> GetReplacementsAsync(string repl
             var info = await _set.GetReplacementsAsync(replacementText, optionSet, cancellationToken).ConfigureAwait(false);
             if (info != null)
             {
-                return new FSharpInlineRenameReplacementInfo(info);
+                return new FSharpInlineRenameReplacementInfoLegacyWrapper(info);
             }
             else
             {
@@ -108,11 +111,12 @@ public async Task<IInlineRenameReplacementInfo> GetReplacementsAsync(string repl
         }
     }
 
-    internal class FSharpInlineRenameInfo : IInlineRenameInfo
+    [Obsolete]
+    internal class FSharpInlineRenameInfoLegacyWrapper : IInlineRenameInfo
     {
         private readonly IFSharpInlineRenameInfo _info;
 
-        public FSharpInlineRenameInfo(IFSharpInlineRenameInfo info)
+        public FSharpInlineRenameInfoLegacyWrapper(IFSharpInlineRenameInfo info)
         {
             _info = info;
         }
@@ -141,7 +145,7 @@ public async Task<IInlineRenameLocationSet> FindRenameLocationsAsync(OptionSet o
             var set = await _info.FindRenameLocationsAsync(optionSet, cancellationToken).ConfigureAwait(false);
             if (set != null)
             {
-                return new FSharpInlineRenameLocationSet(set);
+                return new FSharpInlineRenameLocationSetLegacyWrapper(set);
             }
             else
             {
@@ -175,30 +179,42 @@ public bool TryOnBeforeGlobalSymbolRenamed(Workspace workspace, IEnumerable<Docu
         }
     }
 
+#nullable enable
     [Shared]
     [ExportLanguageService(typeof(IEditorInlineRenameService), LanguageNames.FSharp)]
     internal class FSharpEditorInlineRenameService : IEditorInlineRenameService
     {
-        private readonly IFSharpEditorInlineRenameService _service;
+        [Obsolete]
+        private readonly IFSharpEditorInlineRenameService? _legacyService;
+
+        private readonly FSharpInlineRenameServiceImplementation? _service;
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public FSharpEditorInlineRenameService(IFSharpEditorInlineRenameService service)
+        public FSharpEditorInlineRenameService(
+            [Import(AllowDefault = true)] IFSharpEditorInlineRenameService? legacyService,
+            [Import(AllowDefault = true)] FSharpInlineRenameServiceImplementation? service)
         {
+            _legacyService = legacyService;
             _service = service;
         }
 
         public async Task<IInlineRenameInfo> GetRenameInfoAsync(Document document, int position, CancellationToken cancellationToken)
         {
-            var info = await _service.GetRenameInfoAsync(document, position, cancellationToken).ConfigureAwait(false);
-            if (info != null)
+#pragma warning disable CS0612 // Type or member is obsolete
+            if (_legacyService != null)
             {
-                return new FSharpInlineRenameInfo(info);
+                var info = await _legacyService.GetRenameInfoAsync(document, position, cancellationToken).ConfigureAwait(false);
+                return (info != null) ? new FSharpInlineRenameInfoLegacyWrapper(info) : AbstractEditorInlineRenameService.DefaultFailureInfo;
             }
-            else
+#pragma warning restore CS0612 // Type or member is obsolete
+
+            if (_service != null)
             {
-                return null;
+                return await _service.GetRenameInfoAsync(document, position, cancellationToken).ConfigureAwait(false) ?? AbstractEditorInlineRenameService.DefaultFailureInfo;
             }
+
+            return AbstractEditorInlineRenameService.DefaultFailureInfo;
         }
     }
 }
diff --git a/src/Tools/ExternalAccess/OmniSharp/Rename/OmniSharpRenamer.cs b/src/Tools/ExternalAccess/OmniSharp/Rename/OmniSharpRenamer.cs
index d62aced448ddb..e0cc58f5333bf 100644
--- a/src/Tools/ExternalAccess/OmniSharp/Rename/OmniSharpRenamer.cs
+++ b/src/Tools/ExternalAccess/OmniSharp/Rename/OmniSharpRenamer.cs
@@ -12,13 +12,18 @@ namespace Microsoft.CodeAnalysis.ExternalAccess.OmniSharp
 {
     internal static class OmniSharpRenamer
     {
-        public static Task<ConflictResolution> RenameSymbolAsync(
+        public readonly record struct RenameResult(Solution Solution, string? ErrorMessage);
+
+        public static async Task<RenameResult> RenameSymbolAsync(
             Solution solution,
             ISymbol symbol,
             string newName,
             OmniSharpRenameOptions options,
             ImmutableHashSet<ISymbol>? nonConflictSymbols,
             CancellationToken cancellationToken)
-            => Renamer.RenameSymbolAsync(solution, symbol, newName, options.ToRenameOptions(), nonConflictSymbols, cancellationToken);
+        {
+            var resolution = await Renamer.RenameSymbolAsync(solution, symbol, newName, options.ToRenameOptions(), nonConflictSymbols, cancellationToken).ConfigureAwait(false);
+            return new RenameResult(resolution.NewSolution, resolution.ErrorMessage);
+        }
     }
 }

From 96b305834204142b0f50d69b99b0b1f09445773a Mon Sep 17 00:00:00 2001
From: Fred Silberberg <frsilb@microsoft.com>
Date: Tue, 11 Jan 2022 18:27:25 -0800
Subject: [PATCH 315/444] Make IOperation.ChildOperations public (#52923)

Fixes https://github.com/dotnet/roslyn/issues/49475.
---
 .../SuppressMessageAttributeState.cs          |    2 +-
 ...lExpressionForAssignmentCodeFixProvider.cs |    2 +-
 .../IOperationTests_IVariableDeclaration.cs   |   28 +-
 .../Test/Semantic/Semantics/OperatorTests.cs  |    2 +-
 .../Generated/Operations.Generated.cs         | 2430 +++++++++++++++--
 .../Operations/ControlFlowGraphBuilder.cs     |    8 +-
 .../IOperation.OperationList.Reversed.cs      |  142 +
 .../Operations/IOperation.OperationList.cs    |  161 ++
 .../Core/Portable/Operations/IOperation.cs    |   11 +-
 .../Operations/Operation.Enumerable.cs        |  107 -
 .../Core/Portable/Operations/Operation.cs     |   25 +-
 .../Operations/OperationExtensions.cs         |    2 +-
 .../Portable/Operations/OperationNodes.cs     |  179 +-
 .../Core/Portable/PublicAPI.Unshipped.txt     |   25 +
 src/Compilers/Test/Core/CommonTestBase.cs     |    2 +-
 .../Core/Compilation/OperationTreeVerifier.cs |    4 +-
 .../Core/Compilation/TestOperationVisitor.cs  |  299 +-
 .../IOperationTests_IConversionExpression.vb  |    2 +-
 .../Semantic/Semantics/BinaryOperators.vb     |    2 +-
 .../ValueTracker.OperationCollector.cs        |    4 +-
 .../IOperationClassWriter.cs                  |  137 +-
 21 files changed, 3022 insertions(+), 552 deletions(-)
 create mode 100644 src/Compilers/Core/Portable/Operations/IOperation.OperationList.Reversed.cs
 create mode 100644 src/Compilers/Core/Portable/Operations/IOperation.OperationList.cs
 delete mode 100644 src/Compilers/Core/Portable/Operations/Operation.Enumerable.cs

diff --git a/src/Analyzers/Core/Analyzers/RemoveUnnecessarySuppressions/SuppressMessageAttributeState.cs b/src/Analyzers/Core/Analyzers/RemoveUnnecessarySuppressions/SuppressMessageAttributeState.cs
index 0e08ce1c010e1..8f8c2f0b8f667 100644
--- a/src/Analyzers/Core/Analyzers/RemoveUnnecessarySuppressions/SuppressMessageAttributeState.cs
+++ b/src/Analyzers/Core/Analyzers/RemoveUnnecessarySuppressions/SuppressMessageAttributeState.cs
@@ -65,7 +65,7 @@ public bool IsSuppressMessageAttributeWithNamedArguments(
             // Each named attribute argument is represented as an 'ISimpleAssignmentOperation'
             // with a constant value assignment to an 'IPropertyReferenceOperation' in the operation tree.
             using var _ = ArrayBuilder<(string name, IOperation value)>.GetInstance(out var builder);
-            foreach (var childOperation in attribute.Children)
+            foreach (var childOperation in attribute.ChildOperations)
             {
                 if (childOperation is ISimpleAssignmentOperation simpleAssignment &&
                     simpleAssignment.Target is IPropertyReferenceOperation propertyReference &&
diff --git a/src/Analyzers/Core/CodeFixes/UseConditionalExpression/ForAssignment/AbstractUseConditionalExpressionForAssignmentCodeFixProvider.cs b/src/Analyzers/Core/CodeFixes/UseConditionalExpression/ForAssignment/AbstractUseConditionalExpressionForAssignmentCodeFixProvider.cs
index 3d75945a9b589..01e8bd060b48a 100644
--- a/src/Analyzers/Core/CodeFixes/UseConditionalExpression/ForAssignment/AbstractUseConditionalExpressionForAssignmentCodeFixProvider.cs
+++ b/src/Analyzers/Core/CodeFixes/UseConditionalExpression/ForAssignment/AbstractUseConditionalExpressionForAssignmentCodeFixProvider.cs
@@ -250,7 +250,7 @@ private bool ReferencesLocalVariable(IOperation operation, ILocalSymbol variable
                 return true;
             }
 
-            foreach (var child in operation.Children)
+            foreach (var child in operation.ChildOperations)
             {
                 if (ReferencesLocalVariable(child, variable))
                 {
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IVariableDeclaration.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IVariableDeclaration.cs
index 06d72bea0319d..72c52bd669f32 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IVariableDeclaration.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IVariableDeclaration.cs
@@ -610,9 +610,9 @@ void M1()
             var compilation = CreateEmptyCompilation(source);
             (var operation, _) = GetOperationAndSyntaxForTest<VariableDeclaratorSyntax>(compilation);
             var declarator = (IVariableDeclaratorOperation)operation;
-            Assert.Equal(2, declarator.Children.Count());
-            Assert.Equal(OperationKind.Literal, declarator.Children.First().Kind);
-            Assert.Equal(OperationKind.VariableInitializer, declarator.Children.ElementAt(1).Kind);
+            Assert.Equal(2, declarator.ChildOperations.Count());
+            Assert.Equal(OperationKind.Literal, declarator.ChildOperations.First().Kind);
+            Assert.Equal(OperationKind.VariableInitializer, declarator.ChildOperations.ElementAt(1).Kind);
         }
 
         [CompilerTrait(CompilerFeature.IOperation)]
@@ -632,8 +632,8 @@ void M1()
             var compilation = CreateEmptyCompilation(source);
             (var operation, _) = GetOperationAndSyntaxForTest<VariableDeclaratorSyntax>(compilation);
             var declarator = (IVariableDeclaratorOperation)operation;
-            Assert.Equal(1, declarator.Children.Count());
-            Assert.Equal(OperationKind.Literal, declarator.Children.First().Kind);
+            Assert.Equal(1, declarator.ChildOperations.Count());
+            Assert.Equal(OperationKind.Literal, declarator.ChildOperations.First().Kind);
         }
 
         [CompilerTrait(CompilerFeature.IOperation)]
@@ -653,8 +653,8 @@ void M1()
             var compilation = CreateEmptyCompilation(source);
             (var operation, _) = GetOperationAndSyntaxForTest<VariableDeclaratorSyntax>(compilation);
             var declarator = (IVariableDeclaratorOperation)operation;
-            Assert.Equal(1, declarator.Children.Count());
-            Assert.Equal(OperationKind.VariableInitializer, declarator.Children.ElementAt(0).Kind);
+            Assert.Equal(1, declarator.ChildOperations.Count());
+            Assert.Equal(OperationKind.VariableInitializer, declarator.ChildOperations.ElementAt(0).Kind);
         }
 
         [CompilerTrait(CompilerFeature.IOperation)]
@@ -673,7 +673,7 @@ void M1()
 
             var compilation = CreateEmptyCompilation(source);
             (var operation, _) = GetOperationAndSyntaxForTest<VariableDeclaratorSyntax>(compilation);
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
         }
 
         [CompilerTrait(CompilerFeature.IOperation)]
@@ -848,9 +848,9 @@ void M1()
             var compilation = CreateEmptyCompilation(source);
             (var operation, _) = GetOperationAndSyntaxForTest<VariableDeclarationSyntax>(compilation);
             var declaration = (IVariableDeclarationOperation)operation;
-            Assert.Equal(2, declaration.Children.Count());
-            Assert.Equal(OperationKind.Literal, declaration.Children.First().Kind);
-            Assert.Equal(OperationKind.VariableDeclarator, declaration.Children.ElementAt(1).Kind);
+            Assert.Equal(2, declaration.ChildOperations.Count());
+            Assert.Equal(OperationKind.Literal, declaration.ChildOperations.First().Kind);
+            Assert.Equal(OperationKind.VariableDeclarator, declaration.ChildOperations.ElementAt(1).Kind);
         }
 
         [CompilerTrait(CompilerFeature.IOperation)]
@@ -870,9 +870,9 @@ void M1()
             var compilation = CreateEmptyCompilation(source);
             (var operation, _) = GetOperationAndSyntaxForTest<VariableDeclarationSyntax>(compilation);
             var declaration = (IVariableDeclarationOperation)operation;
-            Assert.Equal(2, declaration.Children.Count());
-            Assert.Equal(OperationKind.Literal, declaration.Children.First().Kind);
-            Assert.Equal(OperationKind.VariableDeclarator, declaration.Children.ElementAt(1).Kind);
+            Assert.Equal(2, declaration.ChildOperations.Count());
+            Assert.Equal(OperationKind.Literal, declaration.ChildOperations.First().Kind);
+            Assert.Equal(OperationKind.VariableDeclarator, declaration.ChildOperations.ElementAt(1).Kind);
         }
 
         [CompilerTrait(CompilerFeature.IOperation)]
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/OperatorTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/OperatorTests.cs
index a65f2332c223d..659ccca0544f9 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/OperatorTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/OperatorTests.cs
@@ -11189,7 +11189,7 @@ void enumerateChildren(IOperation iop)
             {
                 numChildren++;
                 Assert.NotNull(iop);
-                foreach (var child in iop.Children)
+                foreach (var child in iop.ChildOperations)
                 {
                     enumerateChildren(child);
                 }
diff --git a/src/Compilers/Core/Portable/Generated/Operations.Generated.cs b/src/Compilers/Core/Portable/Generated/Operations.Generated.cs
index 5284d803ab5be..1cbfb70d533b2 100644
--- a/src/Compilers/Core/Portable/Generated/Operations.Generated.cs
+++ b/src/Compilers/Core/Portable/Generated/Operations.Generated.cs
@@ -3552,14 +3552,16 @@ internal BlockOperation(ImmutableArray<IOperation> operations, ImmutableArray<IL
         }
         public ImmutableArray<IOperation> Operations { get; }
         public ImmutableArray<ILocalSymbol> Locals { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            Operations.Length;
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when index < Operations.Length
                     => Operations[index],
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -3575,6 +3577,22 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!Operations.IsEmpty) return (true, 0, Operations.Length - 1);
+                    else goto case 0;
+                case 0 when previousIndex > 0:
+                    return (true, 0, previousIndex - 1);
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.Block;
@@ -3589,14 +3607,16 @@ internal VariableDeclarationGroupOperation(ImmutableArray<IVariableDeclarationOp
             Declarations = SetParentOperation(declarations, this);
         }
         public ImmutableArray<IVariableDeclarationOperation> Declarations { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            Declarations.Length;
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when index < Declarations.Length
                     => Declarations[index],
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -3612,6 +3632,22 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!Declarations.IsEmpty) return (true, 0, Declarations.Length - 1);
+                    else goto case 0;
+                case 0 when previousIndex > 0:
+                    return (true, 0, previousIndex - 1);
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.VariableDeclarationGroup;
@@ -3632,7 +3668,10 @@ internal SwitchOperation(ImmutableArray<ILocalSymbol> locals, IOperation value,
         public IOperation Value { get; }
         public ImmutableArray<ISwitchCaseOperation> Cases { get; }
         public ILabelSymbol ExitLabel { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Value is null ? 0 : 1) +
+            Cases.Length;
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Value != null
@@ -3641,7 +3680,7 @@ 1 when index < Cases.Length
                     => Cases[index],
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -3660,6 +3699,25 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!Cases.IsEmpty) return (true, 1, Cases.Length - 1);
+                    else goto case 1;
+                case 1 when previousIndex > 0:
+                    return (true, 1, previousIndex - 1);
+                case 1:
+                    if (Value != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.Switch;
@@ -3698,7 +3756,12 @@ internal ForEachLoopOperation(IOperation loopControlVariable, IOperation collect
         public ImmutableArray<IOperation> NextVariables { get; }
         public ForEachLoopOperationInfo? Info { get; }
         public bool IsAsynchronous { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (LoopControlVariable is null ? 0 : 1) +
+            (Collection is null ? 0 : 1) +
+            NextVariables.Length +
+            (Body is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Collection != null
@@ -3711,7 +3774,7 @@ 3 when index < NextVariables.Length
                     => NextVariables[index],
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -3736,6 +3799,31 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!NextVariables.IsEmpty) return (true, 3, NextVariables.Length - 1);
+                    else goto case 3;
+                case 3 when previousIndex > 0:
+                    return (true, 3, previousIndex - 1);
+                case 3:
+                    if (Body != null) return (true, 2, 0);
+                    else goto case 2;
+                case 2:
+                    if (LoopControlVariable != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (Collection != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.Loop;
@@ -3756,7 +3844,12 @@ internal ForLoopOperation(ImmutableArray<IOperation> before, ImmutableArray<ILoc
         public ImmutableArray<ILocalSymbol> ConditionLocals { get; }
         public IOperation? Condition { get; }
         public ImmutableArray<IOperation> AtLoopBottom { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            Before.Length +
+            (Condition is null ? 0 : 1) +
+            AtLoopBottom.Length +
+            (Body is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when index < Before.Length
@@ -3769,7 +3862,7 @@ 3 when index < AtLoopBottom.Length
                     => AtLoopBottom[index],
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -3796,6 +3889,33 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!AtLoopBottom.IsEmpty) return (true, 3, AtLoopBottom.Length - 1);
+                    else goto case 3;
+                case 3 when previousIndex > 0:
+                    return (true, 3, previousIndex - 1);
+                case 3:
+                    if (Body != null) return (true, 2, 0);
+                    else goto case 2;
+                case 2:
+                    if (Condition != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (!Before.IsEmpty) return (true, 0, Before.Length - 1);
+                    else goto case 0;
+                case 0 when previousIndex > 0:
+                    return (true, 0, previousIndex - 1);
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.Loop;
@@ -3822,7 +3942,14 @@ internal ForToLoopOperation(IOperation loopControlVariable, IOperation initialVa
         public bool IsChecked { get; }
         public ImmutableArray<IOperation> NextVariables { get; }
         public (ILocalSymbol LoopObject, ForToLoopOperationUserDefinedInfo UserDefinedInfo) Info { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (LoopControlVariable is null ? 0 : 1) +
+            (InitialValue is null ? 0 : 1) +
+            (LimitValue is null ? 0 : 1) +
+            (StepValue is null ? 0 : 1) +
+            NextVariables.Length +
+            (Body is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when LoopControlVariable != null
@@ -3839,7 +3966,7 @@ 5 when index < NextVariables.Length
                     => NextVariables[index],
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -3870,6 +3997,37 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!NextVariables.IsEmpty) return (true, 5, NextVariables.Length - 1);
+                    else goto case 5;
+                case 5 when previousIndex > 0:
+                    return (true, 5, previousIndex - 1);
+                case 5:
+                    if (Body != null) return (true, 4, 0);
+                    else goto case 4;
+                case 4:
+                    if (StepValue != null) return (true, 3, 0);
+                    else goto case 3;
+                case 3:
+                    if (LimitValue != null) return (true, 2, 0);
+                    else goto case 2;
+                case 2:
+                    if (InitialValue != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (LoopControlVariable != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.Loop;
@@ -3890,6 +4048,10 @@ internal WhileLoopOperation(IOperation? condition, bool conditionIsTop, bool con
         public bool ConditionIsTop { get; }
         public bool ConditionIsUntil { get; }
         public IOperation? IgnoredCondition { get; }
+        internal override int ChildOperationsCount =>
+            (Condition is null ? 0 : 1) +
+            (IgnoredCondition is null ? 0 : 1) +
+            (Body is null ? 0 : 1);
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.Loop;
@@ -3906,14 +4068,16 @@ internal LabeledOperation(ILabelSymbol label, IOperation? operation, SemanticMod
         }
         public ILabelSymbol Label { get; }
         public IOperation? Operation { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Operation is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Operation != null
                     => Operation,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -3927,6 +4091,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Operation != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.Labeled;
@@ -3943,8 +4121,10 @@ internal BranchOperation(ILabelSymbol target, BranchKind branchKind, SemanticMod
         }
         public ILabelSymbol Target { get; }
         public BranchKind BranchKind { get; }
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override int ChildOperationsCount => 0;
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.Branch;
@@ -3955,8 +4135,10 @@ internal sealed partial class EmptyOperation : Operation, IEmptyOperation
     {
         internal EmptyOperation(SemanticModel? semanticModel, SyntaxNode syntax, bool isImplicit)
             : base(semanticModel, syntax, isImplicit) { }
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override int ChildOperationsCount => 0;
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.Empty;
@@ -3972,14 +4154,16 @@ internal ReturnOperation(IOperation? returnedValue, OperationKind kind, Semantic
             Kind = kind;
         }
         public IOperation? ReturnedValue { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (ReturnedValue is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when ReturnedValue != null
                     => ReturnedValue,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -3993,6 +4177,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (ReturnedValue != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind { get; }
@@ -4011,7 +4209,10 @@ internal LockOperation(IOperation lockedValue, IOperation body, ILocalSymbol? lo
         public IOperation LockedValue { get; }
         public IOperation Body { get; }
         public ILocalSymbol? LockTakenSymbol { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (LockedValue is null ? 0 : 1) +
+            (Body is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when LockedValue != null
@@ -4020,7 +4221,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => Body,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -4037,6 +4238,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Body != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (LockedValue != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.Lock;
@@ -4057,7 +4275,11 @@ internal TryOperation(IBlockOperation body, ImmutableArray<ICatchClauseOperation
         public ImmutableArray<ICatchClauseOperation> Catches { get; }
         public IBlockOperation? Finally { get; }
         public ILabelSymbol? ExitLabel { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Body is null ? 0 : 1) +
+            Catches.Length +
+            (Finally is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Body != null
@@ -4068,7 +4290,7 @@ 1 when index < Catches.Length
                     => Finally,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -4090,6 +4312,28 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Finally != null) return (true, 2, 0);
+                    else goto case 2;
+                case 2:
+                    if (!Catches.IsEmpty) return (true, 1, Catches.Length - 1);
+                    else goto case 1;
+                case 1 when previousIndex > 0:
+                    return (true, 1, previousIndex - 1);
+                case 1:
+                    if (Body != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.Try;
@@ -4112,7 +4356,10 @@ internal UsingOperation(IOperation resources, IOperation body, ImmutableArray<IL
         public ImmutableArray<ILocalSymbol> Locals { get; }
         public bool IsAsynchronous { get; }
         public DisposeOperationInfo DisposeInfo { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Resources is null ? 0 : 1) +
+            (Body is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Resources != null
@@ -4121,7 +4368,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => Body,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -4138,6 +4385,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Body != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (Resources != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.Using;
@@ -4152,14 +4416,16 @@ internal ExpressionStatementOperation(IOperation operation, SemanticModel? seman
             Operation = SetParentOperation(operation, this);
         }
         public IOperation Operation { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Operation is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Operation != null
                     => Operation,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -4173,6 +4439,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Operation != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.ExpressionStatement;
@@ -4191,7 +4471,10 @@ internal LocalFunctionOperation(IMethodSymbol symbol, IBlockOperation? body, IBl
         public IMethodSymbol Symbol { get; }
         public IBlockOperation? Body { get; }
         public IBlockOperation? IgnoredBody { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Body is null ? 0 : 1) +
+            (IgnoredBody is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Body != null
@@ -4200,7 +4483,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => IgnoredBody,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -4217,6 +4500,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (IgnoredBody != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (Body != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.LocalFunction;
@@ -4227,8 +4527,10 @@ internal sealed partial class StopOperation : Operation, IStopOperation
     {
         internal StopOperation(SemanticModel? semanticModel, SyntaxNode syntax, bool isImplicit)
             : base(semanticModel, syntax, isImplicit) { }
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override int ChildOperationsCount => 0;
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.Stop;
@@ -4239,8 +4541,10 @@ internal sealed partial class EndOperation : Operation, IEndOperation
     {
         internal EndOperation(SemanticModel? semanticModel, SyntaxNode syntax, bool isImplicit)
             : base(semanticModel, syntax, isImplicit) { }
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override int ChildOperationsCount => 0;
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.End;
@@ -4257,7 +4561,10 @@ internal RaiseEventOperation(IEventReferenceOperation eventReference, ImmutableA
         }
         public IEventReferenceOperation EventReference { get; }
         public ImmutableArray<IArgumentOperation> Arguments { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (EventReference is null ? 0 : 1) +
+            Arguments.Length;
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when EventReference != null
@@ -4266,7 +4573,7 @@ 1 when index < Arguments.Length
                     => Arguments[index],
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -4285,6 +4592,25 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!Arguments.IsEmpty) return (true, 1, Arguments.Length - 1);
+                    else goto case 1;
+                case 1 when previousIndex > 0:
+                    return (true, 1, previousIndex - 1);
+                case 1:
+                    if (EventReference != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.RaiseEvent;
@@ -4299,8 +4625,10 @@ internal LiteralOperation(SemanticModel? semanticModel, SyntaxNode syntax, IType
             OperationConstantValue = constantValue;
             Type = type;
         }
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override int ChildOperationsCount => 0;
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue { get; }
         public override OperationKind Kind => OperationKind.Literal;
@@ -4324,14 +4652,16 @@ internal ConversionOperation(IOperation operand, IConvertibleConversion conversi
         public CommonConversion Conversion => ConversionConvertible.ToCommonConversion();
         public bool IsTryCast { get; }
         public bool IsChecked { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Operand is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Operand != null
                     => Operand,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -4345,6 +4675,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Operand != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue { get; }
         public override OperationKind Kind => OperationKind.Conversion;
@@ -4366,7 +4710,10 @@ internal InvocationOperation(IMethodSymbol targetMethod, IOperation? instance, b
         public IOperation? Instance { get; }
         public bool IsVirtual { get; }
         public ImmutableArray<IArgumentOperation> Arguments { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Instance is null ? 0 : 1) +
+            Arguments.Length;
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Instance != null
@@ -4375,7 +4722,7 @@ 1 when index < Arguments.Length
                     => Arguments[index],
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -4394,6 +4741,25 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!Arguments.IsEmpty) return (true, 1, Arguments.Length - 1);
+                    else goto case 1;
+                case 1 when previousIndex > 0:
+                    return (true, 1, previousIndex - 1);
+                case 1:
+                    if (Instance != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.Invocation;
@@ -4411,7 +4777,10 @@ internal ArrayElementReferenceOperation(IOperation arrayReference, ImmutableArra
         }
         public IOperation ArrayReference { get; }
         public ImmutableArray<IOperation> Indices { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (ArrayReference is null ? 0 : 1) +
+            Indices.Length;
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when ArrayReference != null
@@ -4420,7 +4789,7 @@ 1 when index < Indices.Length
                     => Indices[index],
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -4439,6 +4808,25 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!Indices.IsEmpty) return (true, 1, Indices.Length - 1);
+                    else goto case 1;
+                case 1 when previousIndex > 0:
+                    return (true, 1, previousIndex - 1);
+                case 1:
+                    if (ArrayReference != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.ArrayElementReference;
@@ -4457,8 +4845,10 @@ internal LocalReferenceOperation(ILocalSymbol local, bool isDeclaration, Semanti
         }
         public ILocalSymbol Local { get; }
         public bool IsDeclaration { get; }
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override int ChildOperationsCount => 0;
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue { get; }
         public override OperationKind Kind => OperationKind.LocalReference;
@@ -4474,8 +4864,10 @@ internal ParameterReferenceOperation(IParameterSymbol parameter, SemanticModel?
             Type = type;
         }
         public IParameterSymbol Parameter { get; }
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override int ChildOperationsCount => 0;
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.ParameterReference;
@@ -4503,14 +4895,16 @@ internal FieldReferenceOperation(IFieldSymbol field, bool isDeclaration, IOperat
         }
         public IFieldSymbol Field { get; }
         public bool IsDeclaration { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Instance is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Instance != null
                     => Instance,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -4524,6 +4918,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Instance != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue { get; }
         public override OperationKind Kind => OperationKind.FieldReference;
@@ -4541,14 +4949,16 @@ internal MethodReferenceOperation(IMethodSymbol method, bool isVirtual, IOperati
         }
         public IMethodSymbol Method { get; }
         public bool IsVirtual { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Instance is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Instance != null
                     => Instance,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -4562,15 +4972,29 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
-        public override ITypeSymbol? Type { get; }
-        internal override ConstantValue? OperationConstantValue => null;
-        public override OperationKind Kind => OperationKind.MethodReference;
-        public override void Accept(OperationVisitor visitor) => visitor.VisitMethodReference(this);
-        public override TResult? Accept<TArgument, TResult>(OperationVisitor<TArgument, TResult> visitor, TArgument argument) where TResult : default => visitor.VisitMethodReference(this, argument);
-    }
-    internal sealed partial class PropertyReferenceOperation : BaseMemberReferenceOperation, IPropertyReferenceOperation
-    {
-        internal PropertyReferenceOperation(IPropertySymbol property, ImmutableArray<IArgumentOperation> arguments, IOperation? instance, SemanticModel? semanticModel, SyntaxNode syntax, ITypeSymbol? type, bool isImplicit)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Instance != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
+        public override ITypeSymbol? Type { get; }
+        internal override ConstantValue? OperationConstantValue => null;
+        public override OperationKind Kind => OperationKind.MethodReference;
+        public override void Accept(OperationVisitor visitor) => visitor.VisitMethodReference(this);
+        public override TResult? Accept<TArgument, TResult>(OperationVisitor<TArgument, TResult> visitor, TArgument argument) where TResult : default => visitor.VisitMethodReference(this, argument);
+    }
+    internal sealed partial class PropertyReferenceOperation : BaseMemberReferenceOperation, IPropertyReferenceOperation
+    {
+        internal PropertyReferenceOperation(IPropertySymbol property, ImmutableArray<IArgumentOperation> arguments, IOperation? instance, SemanticModel? semanticModel, SyntaxNode syntax, ITypeSymbol? type, bool isImplicit)
             : base(instance, semanticModel, syntax, isImplicit)
         {
             Property = property;
@@ -4579,7 +5003,10 @@ internal PropertyReferenceOperation(IPropertySymbol property, ImmutableArray<IAr
         }
         public IPropertySymbol Property { get; }
         public ImmutableArray<IArgumentOperation> Arguments { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            Arguments.Length +
+            (Instance is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Instance != null
@@ -4588,7 +5015,7 @@ 1 when index < Arguments.Length
                     => Arguments[index],
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -4607,6 +5034,25 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!Arguments.IsEmpty) return (true, 1, Arguments.Length - 1);
+                    else goto case 1;
+                case 1 when previousIndex > 0:
+                    return (true, 1, previousIndex - 1);
+                case 1:
+                    if (Instance != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.PropertyReference;
@@ -4622,14 +5068,16 @@ internal EventReferenceOperation(IEventSymbol @event, IOperation? instance, Sema
             Type = type;
         }
         public IEventSymbol Event { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Instance is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Instance != null
                     => Instance,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -4643,6 +5091,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Instance != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.EventReference;
@@ -4667,14 +5129,16 @@ internal UnaryOperation(UnaryOperatorKind operatorKind, IOperation operand, bool
         public bool IsLifted { get; }
         public bool IsChecked { get; }
         public IMethodSymbol? OperatorMethod { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Operand is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Operand != null
                     => Operand,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -4688,6 +5152,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Operand != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue { get; }
         public override OperationKind Kind => OperationKind.Unary;
@@ -4718,7 +5196,10 @@ internal BinaryOperation(BinaryOperatorKind operatorKind, IOperation leftOperand
         public bool IsCompareText { get; }
         public IMethodSymbol? OperatorMethod { get; }
         public IMethodSymbol? UnaryOperatorMethod { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (LeftOperand is null ? 0 : 1) +
+            (RightOperand is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when LeftOperand != null
@@ -4727,7 +5208,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => RightOperand,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -4744,6 +5225,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (RightOperand != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (LeftOperand != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue { get; }
         public override OperationKind Kind => OperationKind.Binary;
@@ -4766,7 +5264,11 @@ internal ConditionalOperation(IOperation condition, IOperation whenTrue, IOperat
         public IOperation WhenTrue { get; }
         public IOperation? WhenFalse { get; }
         public bool IsRef { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Condition is null ? 0 : 1) +
+            (WhenTrue is null ? 0 : 1) +
+            (WhenFalse is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Condition != null
@@ -4777,7 +5279,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => WhenFalse,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -4797,6 +5299,26 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (WhenFalse != null) return (true, 2, 0);
+                    else goto case 2;
+                case 2:
+                    if (WhenTrue != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (Condition != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue { get; }
         public override OperationKind Kind => OperationKind.Conditional;
@@ -4818,7 +5340,10 @@ internal CoalesceOperation(IOperation value, IOperation whenNull, IConvertibleCo
         public IOperation WhenNull { get; }
         internal IConvertibleConversion ValueConversionConvertible { get; }
         public CommonConversion ValueConversion => ValueConversionConvertible.ToCommonConversion();
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Value is null ? 0 : 1) +
+            (WhenNull is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Value != null
@@ -4827,7 +5352,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => WhenNull,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -4844,6 +5369,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (WhenNull != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (Value != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue { get; }
         public override OperationKind Kind => OperationKind.Coalesce;
@@ -4860,14 +5402,16 @@ internal AnonymousFunctionOperation(IMethodSymbol symbol, IBlockOperation body,
         }
         public IMethodSymbol Symbol { get; }
         public IBlockOperation Body { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Body is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Body != null
                     => Body,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -4881,6 +5425,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Body != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.AnonymousFunction;
@@ -4901,7 +5459,10 @@ internal ObjectCreationOperation(IMethodSymbol? constructor, IObjectOrCollection
         public IMethodSymbol? Constructor { get; }
         public IObjectOrCollectionInitializerOperation? Initializer { get; }
         public ImmutableArray<IArgumentOperation> Arguments { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Initializer is null ? 0 : 1) +
+            Arguments.Length;
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when index < Arguments.Length
@@ -4910,7 +5471,7 @@ 0 when index < Arguments.Length
                     => Initializer,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -4929,6 +5490,25 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Initializer != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (!Arguments.IsEmpty) return (true, 0, Arguments.Length - 1);
+                    else goto case 0;
+                case 0 when previousIndex > 0:
+                    return (true, 0, previousIndex - 1);
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue { get; }
         public override OperationKind Kind => OperationKind.ObjectCreation;
@@ -4944,14 +5524,16 @@ internal TypeParameterObjectCreationOperation(IObjectOrCollectionInitializerOper
             Type = type;
         }
         public IObjectOrCollectionInitializerOperation? Initializer { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Initializer is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Initializer != null
                     => Initializer,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -4965,6 +5547,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Initializer != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.TypeParameterObjectCreation;
@@ -4982,7 +5578,10 @@ internal ArrayCreationOperation(ImmutableArray<IOperation> dimensionSizes, IArra
         }
         public ImmutableArray<IOperation> DimensionSizes { get; }
         public IArrayInitializerOperation? Initializer { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            DimensionSizes.Length +
+            (Initializer is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when index < DimensionSizes.Length
@@ -4991,7 +5590,7 @@ 0 when index < DimensionSizes.Length
                     => Initializer,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -5010,6 +5609,25 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Initializer != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (!DimensionSizes.IsEmpty) return (true, 0, DimensionSizes.Length - 1);
+                    else goto case 0;
+                case 0 when previousIndex > 0:
+                    return (true, 0, previousIndex - 1);
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.ArrayCreation;
@@ -5025,8 +5643,10 @@ internal InstanceReferenceOperation(InstanceReferenceKind referenceKind, Semanti
             Type = type;
         }
         public InstanceReferenceKind ReferenceKind { get; }
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override int ChildOperationsCount => 0;
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.InstanceReference;
@@ -5046,14 +5666,16 @@ internal IsTypeOperation(IOperation valueOperand, ITypeSymbol typeOperand, bool
         public IOperation ValueOperand { get; }
         public ITypeSymbol TypeOperand { get; }
         public bool IsNegated { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (ValueOperand is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when ValueOperand != null
                     => ValueOperand,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -5067,6 +5689,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (ValueOperand != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.IsType;
@@ -5082,14 +5718,16 @@ internal AwaitOperation(IOperation operation, SemanticModel? semanticModel, Synt
             Type = type;
         }
         public IOperation Operation { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Operation is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Operation != null
                     => Operation,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -5103,6 +5741,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Operation != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.Await;
@@ -5130,7 +5782,10 @@ internal SimpleAssignmentOperation(bool isRef, IOperation target, IOperation val
             Type = type;
         }
         public bool IsRef { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Target is null ? 0 : 1) +
+            (Value is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Target != null
@@ -5139,7 +5794,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => Value,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -5156,6 +5811,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Value != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (Target != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue { get; }
         public override OperationKind Kind => OperationKind.SimpleAssignment;
@@ -5183,7 +5855,10 @@ internal CompoundAssignmentOperation(IConvertibleConversion inConversion, IConve
         public bool IsLifted { get; }
         public bool IsChecked { get; }
         public IMethodSymbol? OperatorMethod { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Target is null ? 0 : 1) +
+            (Value is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Target != null
@@ -5192,7 +5867,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => Value,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -5209,6 +5884,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Value != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (Target != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.CompoundAssignment;
@@ -5225,14 +5917,16 @@ internal ParenthesizedOperation(IOperation operand, SemanticModel? semanticModel
             Type = type;
         }
         public IOperation Operand { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Operand is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Operand != null
                     => Operand,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -5246,6 +5940,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Operand != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue { get; }
         public override OperationKind Kind => OperationKind.Parenthesized;
@@ -5265,7 +5973,10 @@ internal EventAssignmentOperation(IOperation eventReference, IOperation handlerV
         public IOperation EventReference { get; }
         public IOperation HandlerValue { get; }
         public bool Adds { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (EventReference is null ? 0 : 1) +
+            (HandlerValue is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when EventReference != null
@@ -5274,7 +5985,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => HandlerValue,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -5291,6 +6002,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (HandlerValue != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (EventReference != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.EventAssignment;
@@ -5308,7 +6036,10 @@ internal ConditionalAccessOperation(IOperation operation, IOperation whenNotNull
         }
         public IOperation Operation { get; }
         public IOperation WhenNotNull { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Operation is null ? 0 : 1) +
+            (WhenNotNull is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Operation != null
@@ -5317,7 +6048,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => WhenNotNull,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -5334,6 +6065,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (WhenNotNull != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (Operation != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.ConditionalAccess;
@@ -5347,8 +6095,10 @@ internal ConditionalAccessInstanceOperation(SemanticModel? semanticModel, Syntax
         {
             Type = type;
         }
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override int ChildOperationsCount => 0;
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.ConditionalAccessInstance;
@@ -5365,14 +6115,16 @@ internal InterpolatedStringOperation(ImmutableArray<IInterpolatedStringContentOp
             Type = type;
         }
         public ImmutableArray<IInterpolatedStringContentOperation> Parts { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            Parts.Length;
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when index < Parts.Length
                     => Parts[index],
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -5388,6 +6140,22 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!Parts.IsEmpty) return (true, 0, Parts.Length - 1);
+                    else goto case 0;
+                case 0 when previousIndex > 0:
+                    return (true, 0, previousIndex - 1);
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue { get; }
         public override OperationKind Kind => OperationKind.InterpolatedString;
@@ -5403,14 +6171,16 @@ internal AnonymousObjectCreationOperation(ImmutableArray<IOperation> initializer
             Type = type;
         }
         public ImmutableArray<IOperation> Initializers { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            Initializers.Length;
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when index < Initializers.Length
                     => Initializers[index],
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -5426,6 +6196,22 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!Initializers.IsEmpty) return (true, 0, Initializers.Length - 1);
+                    else goto case 0;
+                case 0 when previousIndex > 0:
+                    return (true, 0, previousIndex - 1);
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.AnonymousObjectCreation;
@@ -5441,14 +6227,16 @@ internal ObjectOrCollectionInitializerOperation(ImmutableArray<IOperation> initi
             Type = type;
         }
         public ImmutableArray<IOperation> Initializers { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            Initializers.Length;
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when index < Initializers.Length
                     => Initializers[index],
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -5464,6 +6252,22 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!Initializers.IsEmpty) return (true, 0, Initializers.Length - 1);
+                    else goto case 0;
+                case 0 when previousIndex > 0:
+                    return (true, 0, previousIndex - 1);
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.ObjectOrCollectionInitializer;
@@ -5481,7 +6285,10 @@ internal MemberInitializerOperation(IOperation initializedMember, IObjectOrColle
         }
         public IOperation InitializedMember { get; }
         public IObjectOrCollectionInitializerOperation Initializer { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (InitializedMember is null ? 0 : 1) +
+            (Initializer is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when InitializedMember != null
@@ -5490,7 +6297,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => Initializer,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -5507,6 +6314,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Initializer != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (InitializedMember != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.MemberInitializer;
@@ -5523,14 +6347,16 @@ internal NameOfOperation(IOperation argument, SemanticModel? semanticModel, Synt
             Type = type;
         }
         public IOperation Argument { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Argument is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Argument != null
                     => Argument,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -5544,6 +6370,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Argument != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue { get; }
         public override OperationKind Kind => OperationKind.NameOf;
@@ -5561,14 +6401,16 @@ internal TupleOperation(ImmutableArray<IOperation> elements, ITypeSymbol? natura
         }
         public ImmutableArray<IOperation> Elements { get; }
         public ITypeSymbol? NaturalType { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            Elements.Length;
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when index < Elements.Length
                     => Elements[index],
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -5584,6 +6426,22 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!Elements.IsEmpty) return (true, 0, Elements.Length - 1);
+                    else goto case 0;
+                case 0 when previousIndex > 0:
+                    return (true, 0, previousIndex - 1);
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.Tuple;
@@ -5605,14 +6463,16 @@ internal DynamicMemberReferenceOperation(IOperation? instance, string memberName
         public string MemberName { get; }
         public ImmutableArray<ITypeSymbol> TypeArguments { get; }
         public ITypeSymbol? ContainingType { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Instance is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Instance != null
                     => Instance,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -5626,6 +6486,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Instance != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.DynamicMemberReference;
@@ -5641,14 +6515,16 @@ internal TranslatedQueryOperation(IOperation operation, SemanticModel? semanticM
             Type = type;
         }
         public IOperation Operation { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Operation is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Operation != null
                     => Operation,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -5662,6 +6538,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Operation != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.TranslatedQuery;
@@ -5677,14 +6567,16 @@ internal DelegateCreationOperation(IOperation target, SemanticModel? semanticMod
             Type = type;
         }
         public IOperation Target { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Target is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Target != null
                     => Target,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -5698,6 +6590,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Target != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.DelegateCreation;
@@ -5712,8 +6618,10 @@ internal DefaultValueOperation(SemanticModel? semanticModel, SyntaxNode syntax,
             OperationConstantValue = constantValue;
             Type = type;
         }
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override int ChildOperationsCount => 0;
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue { get; }
         public override OperationKind Kind => OperationKind.DefaultValue;
@@ -5729,8 +6637,10 @@ internal TypeOfOperation(ITypeSymbol typeOperand, SemanticModel? semanticModel,
             Type = type;
         }
         public ITypeSymbol TypeOperand { get; }
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override int ChildOperationsCount => 0;
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.TypeOf;
@@ -5747,8 +6657,10 @@ internal SizeOfOperation(ITypeSymbol typeOperand, SemanticModel? semanticModel,
             Type = type;
         }
         public ITypeSymbol TypeOperand { get; }
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override int ChildOperationsCount => 0;
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue { get; }
         public override OperationKind Kind => OperationKind.SizeOf;
@@ -5764,14 +6676,16 @@ internal AddressOfOperation(IOperation reference, SemanticModel? semanticModel,
             Type = type;
         }
         public IOperation Reference { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Reference is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Reference != null
                     => Reference,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -5785,6 +6699,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Reference != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.AddressOf;
@@ -5802,7 +6730,10 @@ internal IsPatternOperation(IOperation value, IPatternOperation pattern, Semanti
         }
         public IOperation Value { get; }
         public IPatternOperation Pattern { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Value is null ? 0 : 1) +
+            (Pattern is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Value != null
@@ -5811,7 +6742,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => Pattern,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -5828,6 +6759,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Pattern != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (Value != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.IsPattern;
@@ -5852,14 +6800,16 @@ internal IncrementOrDecrementOperation(bool isPostfix, bool isLifted, bool isChe
         public bool IsChecked { get; }
         public IOperation Target { get; }
         public IMethodSymbol? OperatorMethod { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Target is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Target != null
                     => Target,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -5873,6 +6823,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Target != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind { get; }
@@ -5888,14 +6852,16 @@ internal ThrowOperation(IOperation? exception, SemanticModel? semanticModel, Syn
             Type = type;
         }
         public IOperation? Exception { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Exception is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Exception != null
                     => Exception,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -5909,6 +6875,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Exception != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.Throw;
@@ -5922,7 +6902,10 @@ internal DeconstructionAssignmentOperation(IOperation target, IOperation value,
         {
             Type = type;
         }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Target is null ? 0 : 1) +
+            (Value is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Target != null
@@ -5931,7 +6914,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => Value,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -5948,6 +6931,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Value != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (Target != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.DeconstructionAssignment;
@@ -5963,14 +6963,16 @@ internal DeclarationExpressionOperation(IOperation expression, SemanticModel? se
             Type = type;
         }
         public IOperation Expression { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Expression is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Expression != null
                     => Expression,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -5984,6 +6986,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Expression != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.DeclarationExpression;
@@ -5997,8 +7013,10 @@ internal OmittedArgumentOperation(SemanticModel? semanticModel, SyntaxNode synta
         {
             Type = type;
         }
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override int ChildOperationsCount => 0;
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.OmittedArgument;
@@ -6024,14 +7042,16 @@ internal FieldInitializerOperation(ImmutableArray<IFieldSymbol> initializedField
             InitializedFields = initializedFields;
         }
         public ImmutableArray<IFieldSymbol> InitializedFields { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Value is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Value != null
                     => Value,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -6045,6 +7065,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Value != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.FieldInitializer;
@@ -6055,14 +7089,16 @@ internal sealed partial class VariableInitializerOperation : BaseSymbolInitializ
     {
         internal VariableInitializerOperation(ImmutableArray<ILocalSymbol> locals, IOperation value, SemanticModel? semanticModel, SyntaxNode syntax, bool isImplicit)
             : base(locals, value, semanticModel, syntax, isImplicit) { }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Value is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Value != null
                     => Value,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -6076,6 +7112,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Value != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.VariableInitializer;
@@ -6090,14 +7140,16 @@ internal PropertyInitializerOperation(ImmutableArray<IPropertySymbol> initialize
             InitializedProperties = initializedProperties;
         }
         public ImmutableArray<IPropertySymbol> InitializedProperties { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Value is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Value != null
                     => Value,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -6111,6 +7163,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Value != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.PropertyInitializer;
@@ -6125,14 +7191,16 @@ internal ParameterInitializerOperation(IParameterSymbol parameter, ImmutableArra
             Parameter = parameter;
         }
         public IParameterSymbol Parameter { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Value is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Value != null
                     => Value,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -6146,6 +7214,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Value != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.ParameterInitializer;
@@ -6160,14 +7242,16 @@ internal ArrayInitializerOperation(ImmutableArray<IOperation> elementValues, Sem
             ElementValues = SetParentOperation(elementValues, this);
         }
         public ImmutableArray<IOperation> ElementValues { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            ElementValues.Length;
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when index < ElementValues.Length
                     => ElementValues[index],
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -6183,6 +7267,22 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!ElementValues.IsEmpty) return (true, 0, ElementValues.Length - 1);
+                    else goto case 0;
+                case 0 when previousIndex > 0:
+                    return (true, 0, previousIndex - 1);
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.ArrayInitializer;
@@ -6201,7 +7301,10 @@ internal VariableDeclaratorOperation(ILocalSymbol symbol, IVariableInitializerOp
         public ILocalSymbol Symbol { get; }
         public IVariableInitializerOperation? Initializer { get; }
         public ImmutableArray<IOperation> IgnoredArguments { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Initializer is null ? 0 : 1) +
+            IgnoredArguments.Length;
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when index < IgnoredArguments.Length
@@ -6210,7 +7313,7 @@ 0 when index < IgnoredArguments.Length
                     => Initializer,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -6229,6 +7332,25 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Initializer != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (!IgnoredArguments.IsEmpty) return (true, 0, IgnoredArguments.Length - 1);
+                    else goto case 0;
+                case 0 when previousIndex > 0:
+                    return (true, 0, previousIndex - 1);
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.VariableDeclarator;
@@ -6247,7 +7369,11 @@ internal VariableDeclarationOperation(ImmutableArray<IVariableDeclaratorOperatio
         public ImmutableArray<IVariableDeclaratorOperation> Declarators { get; }
         public IVariableInitializerOperation? Initializer { get; }
         public ImmutableArray<IOperation> IgnoredDimensions { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            Declarators.Length +
+            (Initializer is null ? 0 : 1) +
+            IgnoredDimensions.Length;
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when index < IgnoredDimensions.Length
@@ -6258,7 +7384,7 @@ 1 when index < Declarators.Length
                     => Initializer,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -6282,6 +7408,30 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Initializer != null) return (true, 2, 0);
+                    else goto case 2;
+                case 2:
+                    if (!Declarators.IsEmpty) return (true, 1, Declarators.Length - 1);
+                    else goto case 1;
+                case 1 when previousIndex > 0:
+                    return (true, 1, previousIndex - 1);
+                case 1:
+                    if (!IgnoredDimensions.IsEmpty) return (true, 0, IgnoredDimensions.Length - 1);
+                    else goto case 0;
+                case 0 when previousIndex > 0:
+                    return (true, 0, previousIndex - 1);
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.VariableDeclaration;
@@ -6306,14 +7456,16 @@ internal ArgumentOperation(ArgumentKind argumentKind, IParameterSymbol? paramete
         public CommonConversion InConversion => InConversionConvertible.ToCommonConversion();
         internal IConvertibleConversion OutConversionConvertible { get; }
         public CommonConversion OutConversion => OutConversionConvertible.ToCommonConversion();
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Value is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Value != null
                     => Value,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -6327,6 +7479,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Value != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.Argument;
@@ -6349,7 +7515,11 @@ internal CatchClauseOperation(IOperation? exceptionDeclarationOrExpression, ITyp
         public ImmutableArray<ILocalSymbol> Locals { get; }
         public IOperation? Filter { get; }
         public IBlockOperation Handler { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (ExceptionDeclarationOrExpression is null ? 0 : 1) +
+            (Filter is null ? 0 : 1) +
+            (Handler is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when ExceptionDeclarationOrExpression != null
@@ -6360,7 +7530,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => Handler,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -6380,6 +7550,26 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Handler != null) return (true, 2, 0);
+                    else goto case 2;
+                case 2:
+                    if (Filter != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (ExceptionDeclarationOrExpression != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.CatchClause;
@@ -6400,7 +7590,10 @@ internal SwitchCaseOperation(ImmutableArray<ICaseClauseOperation> clauses, Immut
         public ImmutableArray<IOperation> Body { get; }
         public ImmutableArray<ILocalSymbol> Locals { get; }
         public IOperation? Condition { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            Clauses.Length +
+            Body.Length;
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when index < Clauses.Length
@@ -6409,7 +7602,7 @@ 1 when index < Body.Length
                     => Body[index],
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -6430,6 +7623,27 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!Body.IsEmpty) return (true, 1, Body.Length - 1);
+                    else goto case 1;
+                case 1 when previousIndex > 0:
+                    return (true, 1, previousIndex - 1);
+                case 1:
+                    if (!Clauses.IsEmpty) return (true, 0, Clauses.Length - 1);
+                    else goto case 0;
+                case 0 when previousIndex > 0:
+                    return (true, 0, previousIndex - 1);
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.SwitchCase;
@@ -6450,8 +7664,10 @@ internal sealed partial class DefaultCaseClauseOperation : BaseCaseClauseOperati
     {
         internal DefaultCaseClauseOperation(ILabelSymbol? label, SemanticModel? semanticModel, SyntaxNode syntax, bool isImplicit)
             : base(label, semanticModel, syntax, isImplicit) { }
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override int ChildOperationsCount => 0;
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.CaseClause;
@@ -6469,7 +7685,10 @@ internal PatternCaseClauseOperation(ILabelSymbol label, IPatternOperation patter
         public new ILabelSymbol Label => base.Label!;
         public IPatternOperation Pattern { get; }
         public IOperation? Guard { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Pattern is null ? 0 : 1) +
+            (Guard is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Pattern != null
@@ -6478,7 +7697,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => Guard,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -6495,6 +7714,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Guard != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (Pattern != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.CaseClause;
@@ -6511,7 +7747,10 @@ internal RangeCaseClauseOperation(IOperation minimumValue, IOperation maximumVal
         }
         public IOperation MinimumValue { get; }
         public IOperation MaximumValue { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (MinimumValue is null ? 0 : 1) +
+            (MaximumValue is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when MinimumValue != null
@@ -6520,7 +7759,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => MaximumValue,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -6537,6 +7776,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (MaximumValue != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (MinimumValue != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.CaseClause;
@@ -6553,14 +7809,16 @@ internal RelationalCaseClauseOperation(IOperation value, BinaryOperatorKind rela
         }
         public IOperation Value { get; }
         public BinaryOperatorKind Relation { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Value is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Value != null
                     => Value,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -6574,6 +7832,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Value != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.CaseClause;
@@ -6588,14 +7860,16 @@ internal SingleValueCaseClauseOperation(IOperation value, ILabelSymbol? label, S
             Value = SetParentOperation(value, this);
         }
         public IOperation Value { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Value is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Value != null
                     => Value,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -6609,6 +7883,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Value != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.CaseClause;
@@ -6628,14 +7916,16 @@ internal InterpolatedStringTextOperation(IOperation text, SemanticModel? semanti
             Text = SetParentOperation(text, this);
         }
         public IOperation Text { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Text is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Text != null
                     => Text,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -6649,6 +7939,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Text != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.InterpolatedStringText;
@@ -6667,7 +7971,11 @@ internal InterpolationOperation(IOperation expression, IOperation? alignment, IO
         public IOperation Expression { get; }
         public IOperation? Alignment { get; }
         public IOperation? FormatString { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Expression is null ? 0 : 1) +
+            (Alignment is null ? 0 : 1) +
+            (FormatString is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Expression != null
@@ -6678,7 +7986,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => FormatString,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -6698,6 +8006,26 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (FormatString != null) return (true, 2, 0);
+                    else goto case 2;
+                case 2:
+                    if (Alignment != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (Expression != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.Interpolation;
@@ -6723,14 +8051,16 @@ internal ConstantPatternOperation(IOperation value, ITypeSymbol inputType, IType
             Value = SetParentOperation(value, this);
         }
         public IOperation Value { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Value is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Value != null
                     => Value,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -6744,6 +8074,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Value != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.ConstantPattern;
@@ -6762,8 +8106,10 @@ internal DeclarationPatternOperation(ITypeSymbol? matchedType, bool matchesNull,
         public ITypeSymbol? MatchedType { get; }
         public bool MatchesNull { get; }
         public ISymbol? DeclaredSymbol { get; }
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override int ChildOperationsCount => 0;
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.DeclarationPattern;
@@ -6783,7 +8129,10 @@ internal TupleBinaryOperation(BinaryOperatorKind operatorKind, IOperation leftOp
         public BinaryOperatorKind OperatorKind { get; }
         public IOperation LeftOperand { get; }
         public IOperation RightOperand { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (LeftOperand is null ? 0 : 1) +
+            (RightOperand is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when LeftOperand != null
@@ -6792,7 +8141,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => RightOperand,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -6809,6 +8158,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (RightOperand != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (LeftOperand != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.TupleBinary;
@@ -6830,7 +8196,10 @@ internal sealed partial class MethodBodyOperation : BaseMethodBodyBaseOperation,
     {
         internal MethodBodyOperation(IBlockOperation? blockBody, IBlockOperation? expressionBody, SemanticModel? semanticModel, SyntaxNode syntax, bool isImplicit)
             : base(blockBody, expressionBody, semanticModel, syntax, isImplicit) { }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (BlockBody is null ? 0 : 1) +
+            (ExpressionBody is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when BlockBody != null
@@ -6839,7 +8208,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => ExpressionBody,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -6856,6 +8225,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (ExpressionBody != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (BlockBody != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.MethodBody;
@@ -6872,7 +8258,11 @@ internal ConstructorBodyOperation(ImmutableArray<ILocalSymbol> locals, IOperatio
         }
         public ImmutableArray<ILocalSymbol> Locals { get; }
         public IOperation? Initializer { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Initializer is null ? 0 : 1) +
+            (BlockBody is null ? 0 : 1) +
+            (ExpressionBody is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Initializer != null
@@ -6883,7 +8273,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => ExpressionBody,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -6903,6 +8293,26 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (ExpressionBody != null) return (true, 2, 0);
+                    else goto case 2;
+                case 2:
+                    if (BlockBody != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (Initializer != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.ConstructorBody;
@@ -6918,8 +8328,10 @@ internal DiscardOperation(IDiscardSymbol discardSymbol, SemanticModel? semanticM
             Type = type;
         }
         public IDiscardSymbol DiscardSymbol { get; }
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override int ChildOperationsCount => 0;
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.Discard;
@@ -6936,14 +8348,16 @@ internal FlowCaptureOperation(CaptureId id, IOperation value, SemanticModel? sem
         }
         public CaptureId Id { get; }
         public IOperation Value { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Value is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Value != null
                     => Value,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -6957,6 +8371,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Value != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.FlowCapture;
@@ -6975,8 +8403,10 @@ internal FlowCaptureReferenceOperation(CaptureId id, bool isInitialization, Sema
         }
         public CaptureId Id { get; }
         public bool IsInitialization { get; }
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override int ChildOperationsCount => 0;
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue { get; }
         public override OperationKind Kind => OperationKind.FlowCaptureReference;
@@ -6993,14 +8423,16 @@ internal IsNullOperation(IOperation operand, SemanticModel? semanticModel, Synta
             Type = type;
         }
         public IOperation Operand { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Operand is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Operand != null
                     => Operand,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -7014,6 +8446,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Operand != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue { get; }
         public override OperationKind Kind => OperationKind.IsNull;
@@ -7027,8 +8473,10 @@ internal CaughtExceptionOperation(SemanticModel? semanticModel, SyntaxNode synta
         {
             Type = type;
         }
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override int ChildOperationsCount => 0;
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.CaughtException;
@@ -7044,8 +8492,10 @@ internal StaticLocalInitializationSemaphoreOperation(ILocalSymbol local, Semanti
             Type = type;
         }
         public ILocalSymbol Local { get; }
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override int ChildOperationsCount => 0;
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.StaticLocalInitializationSemaphore;
@@ -7059,7 +8509,10 @@ internal CoalesceAssignmentOperation(IOperation target, IOperation value, Semant
         {
             Type = type;
         }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Target is null ? 0 : 1) +
+            (Value is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Target != null
@@ -7068,7 +8521,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => Value,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -7085,6 +8538,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Value != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (Target != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.CoalesceAssignment;
@@ -7106,7 +8576,10 @@ internal RangeOperation(IOperation? leftOperand, IOperation? rightOperand, bool
         public IOperation? RightOperand { get; }
         public bool IsLifted { get; }
         public IMethodSymbol? Method { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (LeftOperand is null ? 0 : 1) +
+            (RightOperand is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when LeftOperand != null
@@ -7115,7 +8588,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => RightOperand,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -7132,6 +8605,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (RightOperand != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (LeftOperand != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.Range;
@@ -7148,14 +8638,16 @@ internal ReDimOperation(ImmutableArray<IReDimClauseOperation> clauses, bool pres
         }
         public ImmutableArray<IReDimClauseOperation> Clauses { get; }
         public bool Preserve { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            Clauses.Length;
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when index < Clauses.Length
                     => Clauses[index],
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -7171,6 +8663,22 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!Clauses.IsEmpty) return (true, 0, Clauses.Length - 1);
+                    else goto case 0;
+                case 0 when previousIndex > 0:
+                    return (true, 0, previousIndex - 1);
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.ReDim;
@@ -7187,7 +8695,10 @@ internal ReDimClauseOperation(IOperation operand, ImmutableArray<IOperation> dim
         }
         public IOperation Operand { get; }
         public ImmutableArray<IOperation> DimensionSizes { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Operand is null ? 0 : 1) +
+            DimensionSizes.Length;
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Operand != null
@@ -7196,7 +8707,7 @@ 1 when index < DimensionSizes.Length
                     => DimensionSizes[index],
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -7215,6 +8726,25 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!DimensionSizes.IsEmpty) return (true, 1, DimensionSizes.Length - 1);
+                    else goto case 1;
+                case 1 when previousIndex > 0:
+                    return (true, 1, previousIndex - 1);
+                case 1:
+                    if (Operand != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.ReDimClause;
@@ -7237,7 +8767,10 @@ internal RecursivePatternOperation(ITypeSymbol matchedType, ISymbol? deconstruct
         public ImmutableArray<IPatternOperation> DeconstructionSubpatterns { get; }
         public ImmutableArray<IPropertySubpatternOperation> PropertySubpatterns { get; }
         public ISymbol? DeclaredSymbol { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            DeconstructionSubpatterns.Length +
+            PropertySubpatterns.Length;
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when index < DeconstructionSubpatterns.Length
@@ -7246,7 +8779,7 @@ 1 when index < PropertySubpatterns.Length
                     => PropertySubpatterns[index],
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -7258,11 +8791,32 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                 case 0:
                     if (!PropertySubpatterns.IsEmpty) return (true, 1, 0);
                     else goto case 1;
-                case 1 when previousIndex + 1 < PropertySubpatterns.Length:
-                    return (true, 1, previousIndex + 1);
+                case 1 when previousIndex + 1 < PropertySubpatterns.Length:
+                    return (true, 1, previousIndex + 1);
+                case 1:
+                case 2:
+                    return (false, 2, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!PropertySubpatterns.IsEmpty) return (true, 1, PropertySubpatterns.Length - 1);
+                    else goto case 1;
+                case 1 when previousIndex > 0:
+                    return (true, 1, previousIndex - 1);
                 case 1:
-                case 2:
-                    return (false, 2, 0);
+                    if (!DeconstructionSubpatterns.IsEmpty) return (true, 0, DeconstructionSubpatterns.Length - 1);
+                    else goto case 0;
+                case 0 when previousIndex > 0:
+                    return (true, 0, previousIndex - 1);
+                case 0:
+                case -1:
+                    return (false, -1, 0);
                 default:
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
@@ -7277,8 +8831,10 @@ internal sealed partial class DiscardPatternOperation : BasePatternOperation, ID
     {
         internal DiscardPatternOperation(ITypeSymbol inputType, ITypeSymbol narrowedType, SemanticModel? semanticModel, SyntaxNode syntax, bool isImplicit)
             : base(inputType, narrowedType, semanticModel, syntax, isImplicit) { }
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override int ChildOperationsCount => 0;
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.DiscardPattern;
@@ -7298,7 +8854,10 @@ internal SwitchExpressionOperation(IOperation value, ImmutableArray<ISwitchExpre
         public IOperation Value { get; }
         public ImmutableArray<ISwitchExpressionArmOperation> Arms { get; }
         public bool IsExhaustive { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Value is null ? 0 : 1) +
+            Arms.Length;
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Value != null
@@ -7307,7 +8866,7 @@ 1 when index < Arms.Length
                     => Arms[index],
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -7326,6 +8885,25 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!Arms.IsEmpty) return (true, 1, Arms.Length - 1);
+                    else goto case 1;
+                case 1 when previousIndex > 0:
+                    return (true, 1, previousIndex - 1);
+                case 1:
+                    if (Value != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.SwitchExpression;
@@ -7346,7 +8924,11 @@ internal SwitchExpressionArmOperation(IPatternOperation pattern, IOperation? gua
         public IOperation? Guard { get; }
         public IOperation Value { get; }
         public ImmutableArray<ILocalSymbol> Locals { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Pattern is null ? 0 : 1) +
+            (Guard is null ? 0 : 1) +
+            (Value is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Pattern != null
@@ -7357,7 +8939,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => Value,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -7377,6 +8959,26 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Value != null) return (true, 2, 0);
+                    else goto case 2;
+                case 2:
+                    if (Guard != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (Pattern != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.SwitchExpressionArm;
@@ -7393,7 +8995,10 @@ internal PropertySubpatternOperation(IOperation member, IPatternOperation patter
         }
         public IOperation Member { get; }
         public IPatternOperation Pattern { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Member is null ? 0 : 1) +
+            (Pattern is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Member != null
@@ -7402,7 +9007,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => Pattern,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -7419,6 +9024,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Pattern != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (Member != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.PropertySubpattern;
@@ -7436,7 +9058,10 @@ internal AggregateQueryOperation(IOperation group, IOperation aggregation, Seman
         }
         public IOperation Group { get; }
         public IOperation Aggregation { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Group is null ? 0 : 1) +
+            (Aggregation is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Group != null
@@ -7445,7 +9070,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => Aggregation,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -7462,6 +9087,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Aggregation != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (Group != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.None;
@@ -7480,7 +9122,10 @@ internal FixedOperation(ImmutableArray<ILocalSymbol> locals, IVariableDeclaratio
         public ImmutableArray<ILocalSymbol> Locals { get; }
         public IVariableDeclarationGroupOperation Variables { get; }
         public IOperation Body { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Variables is null ? 0 : 1) +
+            (Body is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Variables != null
@@ -7489,7 +9134,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => Body,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -7506,6 +9151,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Body != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (Variables != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.None;
@@ -7521,14 +9183,16 @@ internal NoPiaObjectCreationOperation(IObjectOrCollectionInitializerOperation? i
             Type = type;
         }
         public IObjectOrCollectionInitializerOperation? Initializer { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Initializer is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Initializer != null
                     => Initializer,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -7542,6 +9206,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Initializer != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.None;
@@ -7557,8 +9235,10 @@ internal PlaceholderOperation(PlaceholderKind placeholderKind, SemanticModel? se
             Type = type;
         }
         public PlaceholderKind PlaceholderKind { get; }
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override int ChildOperationsCount => 0;
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.None;
@@ -7575,7 +9255,10 @@ internal WithStatementOperation(IOperation body, IOperation value, SemanticModel
         }
         public IOperation Body { get; }
         public IOperation Value { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Body is null ? 0 : 1) +
+            (Value is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Value != null
@@ -7584,7 +9267,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => Body,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -7601,6 +9284,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Body != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (Value != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.None;
@@ -7619,14 +9319,16 @@ internal UsingDeclarationOperation(IVariableDeclarationGroupOperation declaratio
         public IVariableDeclarationGroupOperation DeclarationGroup { get; }
         public bool IsAsynchronous { get; }
         public DisposeOperationInfo DisposeInfo { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (DeclarationGroup is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when DeclarationGroup != null
                     => DeclarationGroup,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -7640,6 +9342,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (DeclarationGroup != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.UsingDeclaration;
@@ -7654,14 +9370,16 @@ internal NegatedPatternOperation(IPatternOperation pattern, ITypeSymbol inputTyp
             Pattern = SetParentOperation(pattern, this);
         }
         public IPatternOperation Pattern { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Pattern is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Pattern != null
                     => Pattern,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -7675,6 +9393,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Pattern != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.NegatedPattern;
@@ -7693,7 +9425,10 @@ internal BinaryPatternOperation(BinaryOperatorKind operatorKind, IPatternOperati
         public BinaryOperatorKind OperatorKind { get; }
         public IPatternOperation LeftPattern { get; }
         public IPatternOperation RightPattern { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (LeftPattern is null ? 0 : 1) +
+            (RightPattern is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when LeftPattern != null
@@ -7702,7 +9437,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => RightPattern,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -7719,6 +9454,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (RightPattern != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (LeftPattern != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.BinaryPattern;
@@ -7733,8 +9485,10 @@ internal TypePatternOperation(ITypeSymbol matchedType, ITypeSymbol inputType, IT
             MatchedType = matchedType;
         }
         public ITypeSymbol MatchedType { get; }
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override int ChildOperationsCount => 0;
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.TypePattern;
@@ -7751,14 +9505,16 @@ internal RelationalPatternOperation(BinaryOperatorKind operatorKind, IOperation
         }
         public BinaryOperatorKind OperatorKind { get; }
         public IOperation Value { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Value is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Value != null
                     => Value,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -7772,6 +9528,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Value != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.RelationalPattern;
@@ -7791,7 +9561,10 @@ internal WithOperation(IOperation operand, IMethodSymbol? cloneMethod, IObjectOr
         public IOperation Operand { get; }
         public IMethodSymbol? CloneMethod { get; }
         public IObjectOrCollectionInitializerOperation Initializer { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Operand is null ? 0 : 1) +
+            (Initializer is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Operand != null
@@ -7800,7 +9573,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => Initializer,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -7817,6 +9590,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Initializer != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (Operand != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.With;
@@ -7838,7 +9628,10 @@ internal InterpolatedStringHandlerCreationOperation(IOperation handlerCreation,
         public bool HandlerCreationHasSuccessParameter { get; }
         public bool HandlerAppendCallsReturnBool { get; }
         public IOperation Content { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (HandlerCreation is null ? 0 : 1) +
+            (Content is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when HandlerCreation != null
@@ -7847,7 +9640,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => Content,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -7864,6 +9657,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Content != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (HandlerCreation != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.InterpolatedStringHandlerCreation;
@@ -7880,7 +9690,10 @@ internal InterpolatedStringAdditionOperation(IOperation left, IOperation right,
         }
         public IOperation Left { get; }
         public IOperation Right { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Left is null ? 0 : 1) +
+            (Right is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Left != null
@@ -7889,7 +9702,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => Right,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -7906,6 +9719,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Right != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (Left != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.InterpolatedStringAddition;
@@ -7921,14 +9751,16 @@ internal InterpolatedStringAppendOperation(IOperation appendCall, OperationKind
             Kind = kind;
         }
         public IOperation AppendCall { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (AppendCall is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when AppendCall != null
                     => AppendCall,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -7942,6 +9774,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (AppendCall != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind { get; }
@@ -7958,8 +9804,10 @@ internal InterpolatedStringHandlerArgumentPlaceholderOperation(int argumentIndex
         }
         public int ArgumentIndex { get; }
         public InterpolatedStringArgumentPlaceholderKind PlaceholderKind { get; }
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override int ChildOperationsCount => 0;
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.InterpolatedStringHandlerArgumentPlaceholder;
@@ -7977,7 +9825,10 @@ internal FunctionPointerInvocationOperation(IOperation target, ImmutableArray<IA
         }
         public IOperation Target { get; }
         public ImmutableArray<IArgumentOperation> Arguments { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Target is null ? 0 : 1) +
+            Arguments.Length;
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Target != null
@@ -7986,7 +9837,7 @@ 1 when index < Arguments.Length
                     => Arguments[index],
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -8005,6 +9856,25 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!Arguments.IsEmpty) return (true, 1, Arguments.Length - 1);
+                    else goto case 1;
+                case 1 when previousIndex > 0:
+                    return (true, 1, previousIndex - 1);
+                case 1:
+                    if (Target != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.FunctionPointerInvocation;
@@ -8025,14 +9895,16 @@ internal ListPatternOperation(ISymbol? lengthSymbol, ISymbol? indexerSymbol, Imm
         public ISymbol? IndexerSymbol { get; }
         public ImmutableArray<IPatternOperation> Patterns { get; }
         public ISymbol? DeclaredSymbol { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            Patterns.Length;
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when index < Patterns.Length
                     => Patterns[index],
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -8048,6 +9920,22 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!Patterns.IsEmpty) return (true, 0, Patterns.Length - 1);
+                    else goto case 0;
+                case 0 when previousIndex > 0:
+                    return (true, 0, previousIndex - 1);
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.ListPattern;
@@ -8064,14 +9952,16 @@ internal SlicePatternOperation(ISymbol? sliceSymbol, IPatternOperation? pattern,
         }
         public ISymbol? SliceSymbol { get; }
         public IPatternOperation? Pattern { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Pattern is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Pattern != null
                     => Pattern,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -8085,6 +9975,20 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Pattern != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.SlicePattern;
@@ -8106,7 +10010,10 @@ internal ImplicitIndexerReferenceOperation(IOperation instance, IOperation argum
         public IOperation Argument { get; }
         public ISymbol LengthSymbol { get; }
         public ISymbol IndexerSymbol { get; }
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount =>
+            (Instance is null ? 0 : 1) +
+            (Argument is null ? 0 : 1);
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Instance != null
@@ -8115,7 +10022,7 @@ protected override IOperation GetCurrent(int slot, int index)
                     => Argument,
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -8132,6 +10039,23 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
                     throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
             }
         }
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Argument != null) return (true, 1, 0);
+                    else goto case 1;
+                case 1:
+                    if (Instance != null) return (true, 0, 0);
+                    else goto case 0;
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.ImplicitIndexerReference;
diff --git a/src/Compilers/Core/Portable/Operations/ControlFlowGraphBuilder.cs b/src/Compilers/Core/Portable/Operations/ControlFlowGraphBuilder.cs
index 9911d367df9bd..87c5b2a600c03 100644
--- a/src/Compilers/Core/Portable/Operations/ControlFlowGraphBuilder.cs
+++ b/src/Compilers/Core/Portable/Operations/ControlFlowGraphBuilder.cs
@@ -1764,7 +1764,7 @@ private void VisitMethodBodies(IBlockOperation? blockBody, IBlockOperation? expr
                 {
                     IOperation? rewrittenThrow = base.Visit(whenTrueConversion.Operand, null);
                     Debug.Assert(rewrittenThrow!.Kind == OperationKind.None);
-                    Debug.Assert(rewrittenThrow.Children.IsEmpty());
+                    Debug.Assert(rewrittenThrow.ChildOperations.IsEmpty());
 
                     UnconditionalBranch(afterIf);
 
@@ -1782,7 +1782,7 @@ private void VisitMethodBodies(IBlockOperation? blockBody, IBlockOperation? expr
 
                     IOperation rewrittenThrow = BaseVisitRequired(whenFalseConversion.Operand, null);
                     Debug.Assert(rewrittenThrow.Kind == OperationKind.None);
-                    Debug.Assert(rewrittenThrow.Children.IsEmpty());
+                    Debug.Assert(rewrittenThrow.ChildOperations.IsEmpty());
                 }
                 else
                 {
@@ -2984,7 +2984,7 @@ private void VisitConditionalBranchCore(IOperation condition, [NotNull] ref Basi
                         IOperation? rewrittenThrow = base.Visit(conversion.Operand, null);
                         Debug.Assert(rewrittenThrow != null);
                         Debug.Assert(rewrittenThrow.Kind == OperationKind.None);
-                        Debug.Assert(rewrittenThrow.Children.IsEmpty());
+                        Debug.Assert(rewrittenThrow.ChildOperations.IsEmpty());
                         dest = dest ?? new BasicBlockBuilder(BasicBlockKind.Block);
                         return;
                     }
@@ -3115,7 +3115,7 @@ public override IOperation VisitCoalesce(ICoalesceOperation operation, int? capt
                 IOperation? rewrittenThrow = base.Visit(conversion.Operand, null);
                 Debug.Assert(rewrittenThrow != null);
                 Debug.Assert(rewrittenThrow.Kind == OperationKind.None);
-                Debug.Assert(rewrittenThrow.Children.IsEmpty());
+                Debug.Assert(rewrittenThrow.ChildOperations.IsEmpty());
             }
             else
             {
diff --git a/src/Compilers/Core/Portable/Operations/IOperation.OperationList.Reversed.cs b/src/Compilers/Core/Portable/Operations/IOperation.OperationList.Reversed.cs
new file mode 100644
index 0000000000000..2f8b0d32ff638
--- /dev/null
+++ b/src/Compilers/Core/Portable/Operations/IOperation.OperationList.Reversed.cs
@@ -0,0 +1,142 @@
+// 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 Microsoft.CodeAnalysis.Operations;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis
+{
+    public partial interface IOperation
+    {
+        public readonly partial struct OperationList
+        {
+            /// <summary>
+            /// Implements a reverse-order struct-based collection of <see cref="Operation"/> nodes.
+            /// This collection is ordered, but random access into the collection is not provided.
+            /// </summary>
+            [NonDefaultable]
+            public readonly struct Reversed : IReadOnlyCollection<IOperation>
+            {
+                private readonly Operation _operation;
+
+                internal Reversed(Operation operation)
+                {
+                    _operation = operation;
+                }
+
+                public int Count => _operation.ChildOperationsCount;
+
+                public Enumerator GetEnumerator() => new Enumerator(_operation);
+
+                public ImmutableArray<IOperation> ToImmutableArray()
+                {
+                    Enumerator enumerator = GetEnumerator();
+                    switch (_operation)
+                    {
+                        case { ChildOperationsCount: 0 }:
+                            return ImmutableArray<IOperation>.Empty;
+                        case NoneOperation { Children: var children }:
+                            return reverseArray(children);
+                        case InvalidOperation { Children: var children }:
+                            return reverseArray(children);
+                        default:
+                            var builder = ArrayBuilder<IOperation>.GetInstance(Count);
+                            foreach (var child in this)
+                            {
+                                builder.Add(child);
+                            }
+                            return builder.ToImmutableAndFree();
+                    }
+
+                    static ImmutableArray<IOperation> reverseArray(ImmutableArray<IOperation> input)
+                    {
+                        var builder = ArrayBuilder<IOperation>.GetInstance(input.Length);
+                        for (int i = input.Length - 1; i >= 0; i--)
+                        {
+                            builder.Add(input[i]);
+                        }
+
+                        return builder.ToImmutableAndFree();
+                    }
+                }
+
+                IEnumerator<IOperation> IEnumerable<IOperation>.GetEnumerator()
+                {
+                    if (this.Count == 0)
+                    {
+                        return SpecializedCollections.EmptyEnumerator<IOperation>();
+                    }
+
+                    return new EnumeratorImpl(new Enumerator(_operation));
+                }
+
+                IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable<IOperation>)this).GetEnumerator();
+
+                /// <summary>
+                /// Implements a reverse-order struct-based enumerator for <see cref="Operation"/> nodes. This type is not hardened
+                /// to <code>default(Enumerator)</code>, and will null reference in these cases. Calling <see cref="Current"/> after
+                /// <see cref="Enumerator.MoveNext"/> has returned false will throw an <see cref="InvalidOperationException"/>.
+                /// </summary>
+                [NonDefaultable]
+                public struct Enumerator
+                {
+                    private readonly Operation _operation;
+                    private int _currentSlot;
+                    private int _currentIndex;
+
+                    internal Enumerator(Operation operation)
+                    {
+                        _operation = operation;
+                        _currentSlot = int.MaxValue;
+                        _currentIndex = int.MaxValue;
+                    }
+
+                    public IOperation Current
+                    {
+                        get
+                        {
+                            Debug.Assert(_operation != null && _currentSlot is >= 0 and not int.MaxValue && _currentIndex is >= 0 and not int.MaxValue);
+                            return _operation.GetCurrent(_currentSlot, _currentIndex);
+                        }
+                    }
+
+                    public bool MoveNext()
+                    {
+                        Debug.Assert((_currentSlot == int.MaxValue) == (_currentIndex == int.MaxValue));
+                        (var result, _currentSlot, _currentIndex) = _operation.MoveNextReversed(_currentSlot, _currentIndex);
+                        return result;
+                    }
+
+                    public void Reset()
+                    {
+                        _currentIndex = int.MaxValue;
+                        _currentSlot = int.MaxValue;
+                    }
+                }
+
+                private sealed class EnumeratorImpl : IEnumerator<IOperation>
+                {
+                    private Enumerator _enumerator;
+
+                    public EnumeratorImpl(Enumerator enumerator)
+                    {
+                        _enumerator = enumerator;
+                    }
+
+                    public IOperation Current => _enumerator.Current;
+                    object? IEnumerator.Current => _enumerator.Current;
+                    public void Dispose() { }
+                    public bool MoveNext() => _enumerator.MoveNext();
+                    public void Reset() => _enumerator.Reset();
+                }
+            }
+        }
+    }
+}
diff --git a/src/Compilers/Core/Portable/Operations/IOperation.OperationList.cs b/src/Compilers/Core/Portable/Operations/IOperation.OperationList.cs
new file mode 100644
index 0000000000000..b1437b0cd1f58
--- /dev/null
+++ b/src/Compilers/Core/Portable/Operations/IOperation.OperationList.cs
@@ -0,0 +1,161 @@
+// 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 Microsoft.CodeAnalysis.Operations;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis
+{
+    public partial interface IOperation
+    {
+        /// <summary>
+        /// Implements a struct-based collection of <see cref="Operation"/> nodes. This collection is ordered, but
+        /// random access into the collection is not provided.
+        /// </summary>
+        [NonDefaultable]
+        public readonly partial struct OperationList : IReadOnlyCollection<IOperation>
+        {
+            private readonly Operation _operation;
+
+            internal OperationList(Operation operation)
+            {
+                _operation = operation;
+            }
+
+            public int Count => _operation.ChildOperationsCount;
+
+            public Enumerator GetEnumerator() => new Enumerator(_operation);
+
+            public ImmutableArray<IOperation> ToImmutableArray()
+            {
+                switch (_operation)
+                {
+                    case { ChildOperationsCount: 0 }:
+                        return ImmutableArray<IOperation>.Empty;
+                    case NoneOperation { Children: var children }:
+                        return children;
+                    case InvalidOperation { Children: var children }:
+                        return children;
+                    default:
+                        var builder = ArrayBuilder<IOperation>.GetInstance(Count);
+                        foreach (var child in this)
+                        {
+                            builder.Add(child);
+                        }
+                        return builder.ToImmutableAndFree();
+                }
+            }
+
+            IEnumerator<IOperation> IEnumerable<IOperation>.GetEnumerator()
+            {
+                if (this.Count == 0)
+                {
+                    return SpecializedCollections.EmptyEnumerator<IOperation>();
+                }
+
+                return new EnumeratorImpl(new Enumerator(_operation));
+            }
+
+            IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable<IOperation>)this).GetEnumerator();
+
+            public bool Any() => Count > 0;
+
+            public IOperation First()
+            {
+                var enumerator = GetEnumerator();
+                if (enumerator.MoveNext())
+                {
+                    return enumerator.Current;
+                }
+
+                throw new InvalidOperationException();
+            }
+
+            public Reversed Reverse() => new Reversed(_operation);
+
+            public IOperation Last()
+            {
+                var enumerator = Reverse().GetEnumerator();
+                if (enumerator.MoveNext())
+                {
+                    return enumerator.Current;
+                }
+
+                throw new InvalidOperationException();
+            }
+
+            /// <summary>
+            /// Implements a struct-based enumerator for <see cref="Operation"/> nodes. This type is not hardened
+            /// to <code>default(Enumerator)</code>, and will null reference in these cases. Calling <see cref="Current"/> after
+            /// <see cref="Enumerator.MoveNext"/> has returned false will throw an <see cref="InvalidOperationException"/>.
+            /// </summary>
+            [NonDefaultable]
+            public struct Enumerator
+            {
+                /// <summary>
+                /// Implementation of the <see cref="Enumerator.MoveNext"/> and <see cref="Enumerator.Current"/>
+                /// members are delegated to the virtual <see cref="Operation.MoveNext(int, int)"/> and
+                /// <see cref="Operation.GetCurrent(int, int)"/> methods, respectively.
+                /// </summary>
+                private readonly Operation _operation;
+                /// <summary>
+                /// 
+                /// </summary>
+                private int _currentSlot;
+                private int _currentIndex;
+
+                internal Enumerator(Operation operation)
+                {
+                    _operation = operation;
+                    _currentSlot = -1;
+                    _currentIndex = -1;
+                }
+
+                public IOperation Current
+                {
+                    get
+                    {
+                        Debug.Assert(_operation != null && _currentSlot >= 0 && _currentIndex >= 0);
+                        return _operation.GetCurrent(_currentSlot, _currentIndex);
+                    }
+                }
+
+                public bool MoveNext()
+                {
+                    bool result;
+                    (result, _currentSlot, _currentIndex) = _operation.MoveNext(_currentSlot, _currentIndex);
+                    return result;
+                }
+
+                public void Reset()
+                {
+                    _currentSlot = -1;
+                    _currentIndex = -1;
+                }
+            }
+
+            private sealed class EnumeratorImpl : IEnumerator<IOperation>
+            {
+                private Enumerator _enumerator;
+
+                public EnumeratorImpl(Enumerator enumerator)
+                {
+                    _enumerator = enumerator;
+                }
+
+                public IOperation Current => _enumerator.Current;
+                object? IEnumerator.Current => _enumerator.Current;
+                public void Dispose() { }
+                public bool MoveNext() => _enumerator.MoveNext();
+                public void Reset() => _enumerator.Reset();
+            }
+        }
+    }
+}
diff --git a/src/Compilers/Core/Portable/Operations/IOperation.cs b/src/Compilers/Core/Portable/Operations/IOperation.cs
index 612febf7fadca..2e8ce5ac3bdee 100644
--- a/src/Compilers/Core/Portable/Operations/IOperation.cs
+++ b/src/Compilers/Core/Portable/Operations/IOperation.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.Runtime.CompilerServices;
 using Microsoft.CodeAnalysis.Operations;
@@ -16,7 +17,7 @@ namespace Microsoft.CodeAnalysis
     /// change it in the future.
     /// </remarks>
     [InternalImplementationOnly]
-    public interface IOperation
+    public partial interface IOperation
     {
         /// <summary>
         /// IOperation that has this operation as a child. Null for the root.
@@ -44,10 +45,16 @@ public interface IOperation
         Optional<object?> ConstantValue { get; }
 
         /// <summary>
-        /// An array of child operations for this operation.
+        /// An array of child operations for this operation. Deprecated: please use <see cref="ChildOperations"/>.
         /// </summary>
+        [Obsolete($"This API has performance penalties, please use {nameof(ChildOperations)} instead.", error: false)]
         IEnumerable<IOperation> Children { get; }
 
+        /// <summary>
+        /// An enumerable of child operations for this operation.
+        /// </summary>
+        OperationList ChildOperations { get; }
+
         /// <summary>
         /// The source language of the IOperation. Possible values are <see cref="LanguageNames.CSharp"/> and <see cref="LanguageNames.VisualBasic"/>.
         /// </summary>
diff --git a/src/Compilers/Core/Portable/Operations/Operation.Enumerable.cs b/src/Compilers/Core/Portable/Operations/Operation.Enumerable.cs
deleted file mode 100644
index a0e1ef8b253dd..0000000000000
--- a/src/Compilers/Core/Portable/Operations/Operation.Enumerable.cs
+++ /dev/null
@@ -1,107 +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.Generic;
-using System.Collections;
-using System;
-using System.Diagnostics;
-using System.Collections.Immutable;
-using Microsoft.CodeAnalysis.Operations;
-using Microsoft.CodeAnalysis.PooledObjects;
-using Roslyn.Utilities;
-
-namespace Microsoft.CodeAnalysis
-{
-    internal abstract partial class Operation : IOperation
-    {
-        /// <summary>
-        /// Implements a struct-based enumerable for <see cref="Operation"/> nodes, using a slot-based system that tracks
-        /// the current slot, and the current index in the slot if the current slot is an immutable array. This type is not hardened
-        /// to <code>default(Enumerable)</code>, and will null reference in these cases.
-        /// </summary>
-        [NonDefaultable]
-        internal readonly struct Enumerable : IEnumerable<IOperation>
-        {
-            private readonly Operation _operation;
-
-            internal Enumerable(Operation operation)
-            {
-                _operation = operation;
-            }
-
-            public Enumerator GetEnumerator() => new Enumerator(_operation);
-
-            public ImmutableArray<IOperation> ToImmutableArray()
-            {
-                switch (_operation)
-                {
-                    case NoneOperation { Children: var children }:
-                        return children;
-                    case InvalidOperation { Children: var children }:
-                        return children;
-                    case var _ when !GetEnumerator().MoveNext():
-                        return ImmutableArray<IOperation>.Empty;
-                    default:
-                        var builder = ArrayBuilder<IOperation>.GetInstance();
-                        foreach (var child in this)
-                        {
-                            builder.Add(child);
-                        }
-                        return builder.ToImmutableAndFree();
-                }
-            }
-
-            IEnumerator<IOperation> IEnumerable<IOperation>.GetEnumerator() => this.GetEnumerator();
-            IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
-        }
-
-        /// <summary>
-        /// Implements a struct-based enumerator for <see cref="Operation"/> nodes, using a slot-based system that tracks
-        /// the current slot, and the current index in the slot if the current slot is an immutable array. This type is not hardened
-        /// to <code>default(Enumerator)</code>, and will null reference in these cases. Implementation of the <see cref="Enumerator.MoveNext"/>
-        /// and <see cref="Enumerator.Current"/> members are delegated to the virtual <see cref="Operation.MoveNext(int, int)"/> and
-        /// <see cref="Operation.GetCurrent(int, int)"/> methods, respectively. Calling <see cref="Current"/> after
-        /// <see cref="Enumerator.MoveNext"/> has returned false will throw an <see cref="InvalidOperationException"/>.
-        /// </summary>
-        [NonDefaultable]
-        internal struct Enumerator : IEnumerator<IOperation>
-        {
-            private readonly Operation _operation;
-            private int _currentSlot;
-            private int _currentIndex;
-
-            public Enumerator(Operation operation)
-            {
-                _operation = operation;
-                _currentSlot = -1;
-                _currentIndex = -1;
-            }
-
-            public IOperation Current
-            {
-                get
-                {
-                    Debug.Assert(_operation != null && _currentSlot >= 0 && _currentIndex >= 0);
-                    return _operation.GetCurrent(_currentSlot, _currentIndex);
-                }
-            }
-
-            public bool MoveNext()
-            {
-                bool result;
-                (result, _currentSlot, _currentIndex) = _operation.MoveNext(_currentSlot, _currentIndex);
-                return result;
-            }
-
-            void IEnumerator.Reset()
-            {
-                _currentSlot = -1;
-                _currentIndex = -1;
-            }
-
-            object? IEnumerator.Current => this.Current;
-            void IDisposable.Dispose() { }
-        }
-    }
-}
diff --git a/src/Compilers/Core/Portable/Operations/Operation.cs b/src/Compilers/Core/Portable/Operations/Operation.cs
index 495b39d3e256c..0eac58b1f866a 100644
--- a/src/Compilers/Core/Portable/Operations/Operation.cs
+++ b/src/Compilers/Core/Portable/Operations/Operation.cs
@@ -2,13 +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 System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 using Microsoft.CodeAnalysis.Operations;
 using Microsoft.CodeAnalysis.PooledObjects;
-using System.Diagnostics.CodeAnalysis;
 
 namespace Microsoft.CodeAnalysis
 {
@@ -111,19 +112,21 @@ public Optional<object?> ConstantValue
             }
         }
 
-        /// <summary>
-        /// In the compiler layer, always prefer <see cref="ChildOperations"/>.
-        /// </summary>
         IEnumerable<IOperation> IOperation.Children => this.ChildOperations;
 
-        /// <remarks>
-        /// Always prefer this over <see cref="IOperation.Children"/> in the compiler layer, as this does not introduce allocations.
-        /// </remarks>
-        // Making this public is tracked by https://github.com/dotnet/roslyn/issues/49475
-        internal Operation.Enumerable ChildOperations => new Operation.Enumerable(this);
+        /// <inheritdoc/>
+        public IOperation.OperationList ChildOperations => new IOperation.OperationList(this);
 
-        protected abstract IOperation GetCurrent(int slot, int index);
-        protected abstract (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex);
+        internal abstract int ChildOperationsCount { get; }
+        internal abstract IOperation GetCurrent(int slot, int index);
+        /// <summary>
+        /// A slot of -1 means start at the beginning.
+        /// </summary>
+        internal abstract (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex);
+        /// <summary>
+        /// A slot of int.MaxValue means start from the end.
+        /// </summary>
+        internal abstract (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex);
 
         SemanticModel? IOperation.SemanticModel => _owningSemanticModelOpt?.ContainingModelOrSelf;
 
diff --git a/src/Compilers/Core/Portable/Operations/OperationExtensions.cs b/src/Compilers/Core/Portable/Operations/OperationExtensions.cs
index 766431c4a3d17..dfba226daf6bb 100644
--- a/src/Compilers/Core/Portable/Operations/OperationExtensions.cs
+++ b/src/Compilers/Core/Portable/Operations/OperationExtensions.cs
@@ -93,7 +93,7 @@ private static IEnumerable<IOperation> Descendants(IOperation? operation, bool i
                 yield return operation;
             }
 
-            var stack = ArrayBuilder<Operation.Enumerator>.GetInstance();
+            var stack = ArrayBuilder<IOperation.OperationList.Enumerator>.GetInstance();
             stack.Push(((Operation)operation).ChildOperations.GetEnumerator());
 
             while (stack.Any())
diff --git a/src/Compilers/Core/Portable/Operations/OperationNodes.cs b/src/Compilers/Core/Portable/Operations/OperationNodes.cs
index 0538014a37cb0..0b38583763bb1 100644
--- a/src/Compilers/Core/Portable/Operations/OperationNodes.cs
+++ b/src/Compilers/Core/Portable/Operations/OperationNodes.cs
@@ -25,7 +25,7 @@ public NoneOperation(ImmutableArray<IOperation> children, SemanticModel? semanti
 
         internal ImmutableArray<IOperation> Children { get; }
 
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when index < Children.Length
@@ -33,7 +33,9 @@ 0 when index < Children.Length
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index))
             };
 
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override int ChildOperationsCount => Children.Length;
+
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -50,6 +52,15 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
             }
         }
 
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+            => previousSlot switch
+            {
+                int.MaxValue when !Children.IsEmpty => (true, 0, Children.Length - 1),
+                0 when previousIndex > 0 => (true, 0, previousIndex - 1),
+                int.MaxValue or 0 or -1 => (false, -1, 0),
+                _ => throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex))
+            };
+
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue { get; }
         public override OperationKind Kind => OperationKind.None;
@@ -84,7 +95,7 @@ public InvalidOperation(ImmutableArray<IOperation> children, SemanticModel? sema
 
         internal ImmutableArray<IOperation> Children { get; }
 
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when index < Children.Length
@@ -92,7 +103,9 @@ 0 when index < Children.Length
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index))
             };
 
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override int ChildOperationsCount => Children.Length;
+
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -109,6 +122,15 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
             }
         }
 
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+            => previousSlot switch
+            {
+                int.MaxValue when !Children.IsEmpty => (true, 0, Children.Length - 1),
+                0 when previousIndex > 0 => (true, 0, previousIndex - 1),
+                int.MaxValue or 0 or -1 => (false, -1, 0),
+                _ => throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex))
+            };
+
         public override ITypeSymbol? Type { get; }
         internal override ConstantValue? OperationConstantValue { get; }
         public override OperationKind Kind => OperationKind.Invalid;
@@ -137,13 +159,16 @@ public FlowAnonymousFunctionOperation(in ControlFlowGraphBuilder.Context context
         }
         public IMethodSymbol Symbol => Original.Symbol;
 
-        protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));
+        internal override int ChildOperationsCount => 0;
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);
 
         public override OperationKind Kind => OperationKind.FlowAnonymousFunction;
         public override ITypeSymbol? Type => null;
         internal override ConstantValue? OperationConstantValue => null;
 
+
         public override void Accept(OperationVisitor visitor)
         {
             visitor.VisitFlowAnonymousFunction(this);
@@ -233,7 +258,9 @@ public DynamicObjectCreationOperation(IObjectOrCollectionInitializerOperation? i
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.DynamicObjectCreation;
 
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount => (Initializer is null ? 0 : 1) + Arguments.Length;
+
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when index < Arguments.Length
@@ -243,7 +270,7 @@ 0 when index < Arguments.Length
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
 
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -267,6 +294,30 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
             }
         }
 
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (Initializer == null) goto case 1;
+                    else return (true, 1, 0);
+
+                case 1:
+                    if (!Arguments.IsEmpty) return (true, 0, Arguments.Length - 1);
+                    else goto case 0;
+
+                case 0 when previousIndex > 0:
+                    return (true, 0, previousIndex - 1);
+
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
+
         public override void Accept(OperationVisitor visitor)
         {
             visitor.VisitDynamicObjectCreation(this);
@@ -285,7 +336,9 @@ public DynamicInvocationOperation(IOperation operation, ImmutableArray<IOperatio
             Operation = SetParentOperation(operation, this);
         }
 
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount => (Operation is null ? 0 : 1) + Arguments.Length;
+
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Operation != null
@@ -295,7 +348,8 @@ 1 when index < Arguments.Length
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
 
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -319,6 +373,30 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
             }
         }
 
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!Arguments.IsEmpty) return (true, 1, Arguments.Length - 1);
+                    else goto case 1;
+
+                case 1 when previousIndex > 0:
+                    return (true, 1, previousIndex - 1);
+
+                case 1:
+                    if (Operation != null) return (true, 0, 0);
+                    else goto case 0;
+
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
+
         public IOperation Operation { get; }
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.DynamicInvocation;
@@ -345,7 +423,9 @@ public DynamicIndexerAccessOperation(IOperation operation, ImmutableArray<IOpera
         internal override ConstantValue? OperationConstantValue => null;
         public override OperationKind Kind => OperationKind.DynamicIndexerAccess;
 
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override int ChildOperationsCount => (Operation is null ? 0 : 1) + Arguments.Length;
+
+        internal override IOperation GetCurrent(int slot, int index)
             => slot switch
             {
                 0 when Operation != null
@@ -355,7 +435,7 @@ 1 when index < Arguments.Length
                 _ => throw ExceptionUtilities.UnexpectedValue((slot, index)),
             };
 
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             switch (previousSlot)
             {
@@ -379,6 +459,30 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
             }
         }
 
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            switch (previousSlot)
+            {
+                case int.MaxValue:
+                    if (!Arguments.IsEmpty) return (true, 1, Arguments.Length - 1);
+                    else goto case 1;
+
+                case 1 when previousIndex > 0:
+                    return (true, 1, previousIndex - 1);
+
+                case 1:
+                    if (Operation != null) return (true, 0, 0);
+                    else goto case 0;
+
+                case 0:
+                case -1:
+                    return (false, -1, 0);
+
+                default:
+                    throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+            }
+        }
+
         public override void Accept(OperationVisitor visitor)
         {
             visitor.VisitDynamicIndexerAccess(this);
@@ -406,7 +510,7 @@ internal sealed partial class ForToLoopOperation
 
     internal sealed partial class WhileLoopOperation
     {
-        protected override IOperation GetCurrent(int slot, int index)
+        internal override IOperation GetCurrent(int slot, int index)
         {
             return ConditionIsTop ? getCurrentSwitchTop() : getCurrentSwitchBottom();
 
@@ -435,7 +539,7 @@ IOperation getCurrentSwitchBottom()
                 };
         }
 
-        protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)
         {
             return ConditionIsTop ? moveNextConditionIsTop() : moveNextConditionIsBottom();
 
@@ -482,6 +586,53 @@ protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int prev
             }
         }
 
+        internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)
+        {
+            return ConditionIsTop ? moveNextConditionIsTop() : moveNextConditionIsBottom();
+
+            (bool hasNext, int nextSlot, int nextIndex) moveNextConditionIsTop()
+            {
+                switch (previousSlot)
+                {
+                    case int.MaxValue:
+                        if (IgnoredCondition != null) return (true, 2, 0);
+                        else goto case 2;
+                    case 2:
+                        if (Body != null) return (true, 1, 0);
+                        else goto case 1;
+                    case 1:
+                        if (Condition != null) return (true, 0, 0);
+                        else goto case 0;
+                    case 0:
+                    case -1:
+                        return (false, -1, 0);
+                    default:
+                        throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+                }
+            }
+
+            (bool hasNext, int nextSlot, int nextIndex) moveNextConditionIsBottom()
+            {
+                switch (previousSlot)
+                {
+                    case int.MaxValue:
+                        if (IgnoredCondition != null) return (true, 2, 0);
+                        else goto case 2;
+                    case 2:
+                        if (Condition != null) return (true, 1, 0);
+                        else goto case 1;
+                    case 1:
+                        if (Body != null) return (true, 0, 0);
+                        else goto case 0;
+                    case 0:
+                    case -1:
+                        return (false, -1, 0);
+                    default:
+                        throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));
+                }
+            }
+        }
+
         public override LoopKind LoopKind => LoopKind.While;
     }
 
diff --git a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
index d77fc95e2bc14..f22ebc0f8224a 100644
--- a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
+++ b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
@@ -38,6 +38,31 @@ Microsoft.CodeAnalysis.GeneratorSyntaxContext.SemanticModel.get -> Microsoft.Cod
 Microsoft.CodeAnalysis.IIncrementalGenerator
 Microsoft.CodeAnalysis.IIncrementalGenerator.Initialize(Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext context) -> void
 Microsoft.CodeAnalysis.IMethodSymbol.IsPartialDefinition.get -> bool
+Microsoft.CodeAnalysis.IOperation.ChildOperations.get -> Microsoft.CodeAnalysis.IOperation.OperationList
+Microsoft.CodeAnalysis.IOperation.OperationList
+Microsoft.CodeAnalysis.IOperation.OperationList.Any() -> bool
+Microsoft.CodeAnalysis.IOperation.OperationList.OperationList() -> void
+Microsoft.CodeAnalysis.IOperation.OperationList.Count.get -> int
+Microsoft.CodeAnalysis.IOperation.OperationList.First() -> Microsoft.CodeAnalysis.IOperation!
+Microsoft.CodeAnalysis.IOperation.OperationList.GetEnumerator() -> Microsoft.CodeAnalysis.IOperation.OperationList.Enumerator
+Microsoft.CodeAnalysis.IOperation.OperationList.Last() -> Microsoft.CodeAnalysis.IOperation!
+Microsoft.CodeAnalysis.IOperation.OperationList.Reverse() -> Microsoft.CodeAnalysis.IOperation.OperationList.Reversed
+Microsoft.CodeAnalysis.IOperation.OperationList.ToImmutableArray() -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.IOperation!>
+Microsoft.CodeAnalysis.IOperation.OperationList.Enumerator
+Microsoft.CodeAnalysis.IOperation.OperationList.Enumerator.Current.get -> Microsoft.CodeAnalysis.IOperation!
+Microsoft.CodeAnalysis.IOperation.OperationList.Enumerator.Enumerator() -> void
+Microsoft.CodeAnalysis.IOperation.OperationList.Enumerator.MoveNext() -> bool
+Microsoft.CodeAnalysis.IOperation.OperationList.Enumerator.Reset() -> void
+Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.Enumerator
+Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.Enumerator.Current.get -> Microsoft.CodeAnalysis.IOperation!
+Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.Enumerator.Enumerator() -> void
+Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.Enumerator.MoveNext() -> bool
+Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.Enumerator.Reset() -> void
+Microsoft.CodeAnalysis.IOperation.OperationList.Reversed
+Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.Reversed() -> void
+Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.Count.get -> int
+Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.GetEnumerator() -> Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.Enumerator
+Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.ToImmutableArray() -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.IOperation!>
 Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext
 Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.AdditionalTextsProvider.get -> Microsoft.CodeAnalysis.IncrementalValuesProvider<Microsoft.CodeAnalysis.AdditionalText!>
 Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.AnalyzerConfigOptionsProvider.get -> Microsoft.CodeAnalysis.IncrementalValueProvider<Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider!>
diff --git a/src/Compilers/Test/Core/CommonTestBase.cs b/src/Compilers/Test/Core/CommonTestBase.cs
index e92f2e5628e72..eb5540293804f 100644
--- a/src/Compilers/Test/Core/CommonTestBase.cs
+++ b/src/Compilers/Test/Core/CommonTestBase.cs
@@ -549,7 +549,7 @@ private static Dictionary<IOperation, IOperation> GetParentOperationsMap(Semanti
         private static void CollectParentOperations(IOperation operation, Dictionary<IOperation, IOperation> map)
         {
             // walk down to collect all parent operation map for this tree
-            foreach (var child in operation.Children.WhereNotNull())
+            foreach (var child in operation.ChildOperations)
             {
                 map.Add(child, operation);
 
diff --git a/src/Compilers/Test/Core/Compilation/OperationTreeVerifier.cs b/src/Compilers/Test/Core/Compilation/OperationTreeVerifier.cs
index 52df40063dcf5..416eb5de0b602 100644
--- a/src/Compilers/Test/Core/Compilation/OperationTreeVerifier.cs
+++ b/src/Compilers/Test/Core/Compilation/OperationTreeVerifier.cs
@@ -387,9 +387,9 @@ internal void VisitRefKindArrayElement(RefKind element)
 
         private void VisitChildren(IOperation operation)
         {
-            Debug.Assert(operation.Children.All(o => o != null));
+            Debug.Assert(operation.ChildOperations.All(o => o != null));
 
-            var children = operation.Children.ToImmutableArray();
+            var children = operation.ChildOperations.ToImmutableArray();
             if (!children.IsEmpty || operation.Kind != OperationKind.None)
             {
                 VisitArray(children, "Children", logElementCount: true);
diff --git a/src/Compilers/Test/Core/Compilation/TestOperationVisitor.cs b/src/Compilers/Test/Core/Compilation/TestOperationVisitor.cs
index b745f614dc66a..c83c1cf512636 100644
--- a/src/Compilers/Test/Core/Compilation/TestOperationVisitor.cs
+++ b/src/Compilers/Test/Core/Compilation/TestOperationVisitor.cs
@@ -62,11 +62,50 @@ public override void Visit(IOperation operation)
 
                 var isImplicit = operation.IsImplicit;
 
-                foreach (IOperation child in operation.Children)
+                var count = ((Operation)operation).ChildOperationsCount;
+                var builder = count == 0 ? null : ArrayBuilder<IOperation>.GetInstance(count);
+                foreach (IOperation child in operation.ChildOperations)
                 {
                     Assert.NotNull(child);
+                    builder.Add(child);
                 }
 
+                Assert.Equal(count, builder?.Count ?? 0);
+
+                if (count > 0)
+                {
+                    Assert.Same(builder[0], operation.ChildOperations.First());
+                    Assert.Same(builder[^1], operation.ChildOperations.Last());
+
+                    var forwards = operation.ChildOperations.GetEnumerator();
+                    Assert.True(forwards.MoveNext());
+                    var first = forwards.Current;
+                    forwards.Reset();
+                    Assert.True(forwards.MoveNext());
+                    Assert.Same(first, forwards.Current);
+
+                    var reversed = operation.ChildOperations.Reverse().GetEnumerator();
+                    Assert.True(reversed.MoveNext());
+                    var last = reversed.Current;
+                    reversed.Reset();
+                    Assert.True(reversed.MoveNext());
+                    Assert.Same(last, reversed.Current);
+                }
+                else
+                {
+                    Assert.Throws<InvalidOperationException>(() => operation.ChildOperations.First());
+                    Assert.Throws<InvalidOperationException>(() => operation.ChildOperations.Last());
+                }
+
+                foreach (IOperation child in operation.ChildOperations.Reverse())
+                {
+                    Assert.NotNull(child);
+                    Assert.Same(child, builder[--count]);
+                }
+
+                Assert.Equal(0, count);
+                builder?.Free();
+
                 if (operation.SemanticModel != null)
                 {
                     Assert.Same(operation.SemanticModel, operation.SemanticModel.ContainingModelOrSelf);
@@ -80,13 +119,13 @@ public override void VisitBlock(IBlockOperation operation)
             Assert.Equal(OperationKind.Block, operation.Kind);
             VisitLocals(operation.Locals);
 
-            AssertEx.Equal(operation.Operations, operation.Children);
+            AssertEx.Equal(operation.Operations, operation.ChildOperations);
         }
 
         public override void VisitVariableDeclarationGroup(IVariableDeclarationGroupOperation operation)
         {
             Assert.Equal(OperationKind.VariableDeclarationGroup, operation.Kind);
-            AssertEx.Equal(operation.Declarations, operation.Children);
+            AssertEx.Equal(operation.Declarations, operation.ChildOperations);
         }
 
         public override void VisitVariableDeclarator(IVariableDeclaratorOperation operation)
@@ -101,7 +140,7 @@ public override void VisitVariableDeclarator(IVariableDeclaratorOperation operat
                 children = children.Concat(new[] { initializer });
             }
 
-            AssertEx.Equal(children, operation.Children);
+            AssertEx.Equal(children, operation.ChildOperations);
         }
 
         public override void VisitVariableDeclaration(IVariableDeclarationOperation operation)
@@ -115,7 +154,7 @@ public override void VisitVariableDeclaration(IVariableDeclarationOperation oper
                 children = children.Concat(new[] { initializer });
             }
 
-            AssertEx.Equal(children, operation.Children);
+            AssertEx.Equal(children, operation.ChildOperations);
         }
 
         public override void VisitSwitch(ISwitchOperation operation)
@@ -123,14 +162,14 @@ public override void VisitSwitch(ISwitchOperation operation)
             Assert.Equal(OperationKind.Switch, operation.Kind);
             VisitLocals(operation.Locals);
             Assert.NotNull(operation.ExitLabel);
-            AssertEx.Equal(new[] { operation.Value }.Concat(operation.Cases), operation.Children);
+            AssertEx.Equal(new[] { operation.Value }.Concat(operation.Cases), operation.ChildOperations);
         }
 
         public override void VisitSwitchCase(ISwitchCaseOperation operation)
         {
             Assert.Equal(OperationKind.SwitchCase, operation.Kind);
             VisitLocals(operation.Locals);
-            AssertEx.Equal(operation.Clauses.Concat(operation.Body), operation.Children);
+            AssertEx.Equal(operation.Clauses.Concat(operation.Body), operation.ChildOperations);
 
             VerifySubTree(((SwitchCaseOperation)operation).Condition, hasNonNullParent: true);
         }
@@ -175,7 +214,7 @@ public override void VisitSingleValueCaseClause(ISingleValueCaseClauseOperation
         {
             VisitCaseClauseOperation(operation);
             Assert.Equal(CaseKind.SingleValue, operation.CaseKind);
-            AssertEx.Equal(new[] { operation.Value }, operation.Children);
+            AssertEx.Equal(new[] { operation.Value }, operation.ChildOperations);
         }
 
         private static void VisitCaseClauseOperation(ICaseClauseOperation operation)
@@ -190,14 +229,14 @@ public override void VisitRelationalCaseClause(IRelationalCaseClauseOperation op
             Assert.Equal(CaseKind.Relational, operation.CaseKind);
             var relation = operation.Relation;
 
-            AssertEx.Equal(new[] { operation.Value }, operation.Children);
+            AssertEx.Equal(new[] { operation.Value }, operation.ChildOperations);
         }
 
         public override void VisitDefaultCaseClause(IDefaultCaseClauseOperation operation)
         {
             VisitCaseClauseOperation(operation);
             Assert.Equal(CaseKind.Default, operation.CaseKind);
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
         }
 
         private static void VisitLocals(ImmutableArray<ILocalSymbol> locals)
@@ -243,7 +282,7 @@ public override void VisitWhileLoop(IWhileLoopOperation operation)
                 }
             }
 
-            AssertEx.Equal(children, operation.Children);
+            AssertEx.Equal(children, operation.ChildOperations);
         }
 
         public override void VisitForLoop(IForLoopOperation operation)
@@ -263,7 +302,7 @@ public override void VisitForLoop(IForLoopOperation operation)
             children = children.Concat(new[] { operation.Body });
             children = children.Concat(operation.AtLoopBottom);
 
-            AssertEx.Equal(children, operation.Children);
+            AssertEx.Equal(children, operation.ChildOperations);
         }
 
         public override void VisitForToLoop(IForToLoopOperation operation)
@@ -284,7 +323,7 @@ public override void VisitForToLoop(IForToLoopOperation operation)
             IEnumerable<IOperation> children;
             children = new[] { operation.LoopControlVariable, operation.InitialValue, operation.LimitValue, operation.StepValue, operation.Body };
             children = children.Concat(operation.NextVariables);
-            AssertEx.Equal(children, operation.Children);
+            AssertEx.Equal(children, operation.ChildOperations);
         }
 
         public override void VisitForEachLoop(IForEachLoopOperation operation)
@@ -293,7 +332,7 @@ public override void VisitForEachLoop(IForEachLoopOperation operation)
             Assert.Equal(LoopKind.ForEach, operation.LoopKind);
 
             IEnumerable<IOperation> children = new[] { operation.Collection, operation.LoopControlVariable, operation.Body }.Concat(operation.NextVariables);
-            AssertEx.Equal(children, operation.Children);
+            AssertEx.Equal(children, operation.ChildOperations);
             ForEachLoopOperationInfo info = ((ForEachLoopOperation)operation).Info;
             if (info != null)
             {
@@ -330,11 +369,11 @@ public override void VisitLabeled(ILabeledOperation operation)
 
             if (operation.Operation == null)
             {
-                Assert.Empty(operation.Children);
+                Assert.Empty(operation.ChildOperations);
             }
             else
             {
-                Assert.Same(operation.Operation, operation.Children.Single());
+                Assert.Same(operation.Operation, operation.ChildOperations.Single());
             }
         }
 
@@ -354,13 +393,13 @@ public override void VisitBranch(IBranchOperation operation)
                     break;
             }
 
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
         }
 
         public override void VisitEmpty(IEmptyOperation operation)
         {
             Assert.Equal(OperationKind.Empty, operation.Kind);
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
         }
 
         public override void VisitReturn(IReturnOperation operation)
@@ -369,18 +408,18 @@ public override void VisitReturn(IReturnOperation operation)
             if (operation.ReturnedValue == null)
             {
                 Assert.NotEqual(OperationKind.YieldReturn, operation.Kind);
-                Assert.Empty(operation.Children);
+                Assert.Empty(operation.ChildOperations);
             }
             else
             {
-                Assert.Same(operation.ReturnedValue, operation.Children.Single());
+                Assert.Same(operation.ReturnedValue, operation.ChildOperations.Single());
             }
         }
 
         public override void VisitLock(ILockOperation operation)
         {
             Assert.Equal(OperationKind.Lock, operation.Kind);
-            AssertEx.Equal(new[] { operation.LockedValue, operation.Body }, operation.Children);
+            AssertEx.Equal(new[] { operation.LockedValue, operation.Body }, operation.ChildOperations);
         }
 
         public override void VisitTry(ITryOperation operation)
@@ -394,7 +433,7 @@ public override void VisitTry(ITryOperation operation)
                 children = children.Concat(new[] { operation.Finally });
             }
 
-            AssertEx.Equal(children, operation.Children);
+            AssertEx.Equal(children, operation.ChildOperations);
         }
 
         public override void VisitCatchClause(ICatchClauseOperation operation)
@@ -415,14 +454,14 @@ public override void VisitCatchClause(ICatchClauseOperation operation)
             }
 
             children = children.Concat(new[] { operation.Handler });
-            AssertEx.Equal(children, operation.Children);
+            AssertEx.Equal(children, operation.ChildOperations);
         }
 
         public override void VisitUsing(IUsingOperation operation)
         {
             Assert.Equal(OperationKind.Using, operation.Kind);
             VisitLocals(operation.Locals);
-            AssertEx.Equal(new[] { operation.Resources, operation.Body }, operation.Children);
+            AssertEx.Equal(new[] { operation.Resources, operation.Body }, operation.ChildOperations);
             Assert.NotEqual(OperationKind.VariableDeclaration, operation.Resources.Kind);
             Assert.NotEqual(OperationKind.VariableDeclarator, operation.Resources.Kind);
 
@@ -442,37 +481,37 @@ internal override void VisitFixed(IFixedOperation operation)
         {
             Assert.Equal(OperationKind.None, operation.Kind);
             VisitLocals(operation.Locals);
-            AssertEx.Equal(new[] { operation.Variables, operation.Body }, operation.Children);
+            AssertEx.Equal(new[] { operation.Variables, operation.Body }, operation.ChildOperations);
         }
 
         internal override void VisitAggregateQuery(IAggregateQueryOperation operation)
         {
             Assert.Equal(OperationKind.None, operation.Kind);
-            AssertEx.Equal(new[] { operation.Group, operation.Aggregation }, operation.Children);
+            AssertEx.Equal(new[] { operation.Group, operation.Aggregation }, operation.ChildOperations);
         }
 
         public override void VisitExpressionStatement(IExpressionStatementOperation operation)
         {
             Assert.Equal(OperationKind.ExpressionStatement, operation.Kind);
-            Assert.Same(operation.Operation, operation.Children.Single());
+            Assert.Same(operation.Operation, operation.ChildOperations.Single());
         }
 
         internal override void VisitWithStatement(IWithStatementOperation operation)
         {
             Assert.Equal(OperationKind.None, operation.Kind);
-            AssertEx.Equal(new[] { operation.Value, operation.Body }, operation.Children);
+            AssertEx.Equal(new[] { operation.Value, operation.Body }, operation.ChildOperations);
         }
 
         public override void VisitStop(IStopOperation operation)
         {
             Assert.Equal(OperationKind.Stop, operation.Kind);
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
         }
 
         public override void VisitEnd(IEndOperation operation)
         {
             Assert.Equal(OperationKind.End, operation.Kind);
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
         }
 
         public override void VisitInvocation(IInvocationOperation operation)
@@ -491,7 +530,7 @@ public override void VisitInvocation(IInvocationOperation operation)
                 children = operation.Arguments;
             }
 
-            AssertEx.Equal(children, operation.Children);
+            AssertEx.Equal(children, operation.ChildOperations);
 
             // Make sure that all static member references or invocations of static methods do not have implicit IInstanceReferenceOperations
             // as their receivers
@@ -513,7 +552,7 @@ public override void VisitFunctionPointerInvocation(IFunctionPointerInvocationOp
             Assert.NotNull(signature);
             Assert.Same(((IFunctionPointerTypeSymbol)operation.Target.Type).Signature, signature);
 
-            AssertEx.Equal(children, operation.Children);
+            AssertEx.Equal(children, operation.ChildOperations);
         }
 
         public override void VisitArgument(IArgumentOperation operation)
@@ -522,7 +561,7 @@ public override void VisitArgument(IArgumentOperation operation)
             Assert.Contains(operation.ArgumentKind, new[] { ArgumentKind.DefaultValue, ArgumentKind.Explicit, ArgumentKind.ParamArray });
             var parameter = operation.Parameter;
 
-            Assert.Same(operation.Value, operation.Children.Single());
+            Assert.Same(operation.Value, operation.ChildOperations.Single());
             var inConversion = operation.InConversion;
             var outConversion = operation.OutConversion;
 
@@ -535,19 +574,19 @@ public override void VisitArgument(IArgumentOperation operation)
         public override void VisitOmittedArgument(IOmittedArgumentOperation operation)
         {
             Assert.Equal(OperationKind.OmittedArgument, operation.Kind);
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
         }
 
         public override void VisitArrayElementReference(IArrayElementReferenceOperation operation)
         {
             Assert.Equal(OperationKind.ArrayElementReference, operation.Kind);
-            AssertEx.Equal(new[] { operation.ArrayReference }.Concat(operation.Indices), operation.Children);
+            AssertEx.Equal(new[] { operation.ArrayReference }.Concat(operation.Indices), operation.ChildOperations);
         }
 
         public override void VisitImplicitIndexerReference(IImplicitIndexerReferenceOperation operation)
         {
             Assert.Equal(OperationKind.ImplicitIndexerReference, operation.Kind);
-            AssertEx.Equal(new[] { operation.Instance, operation.Argument }, operation.Children);
+            AssertEx.Equal(new[] { operation.Instance, operation.Argument }, operation.ChildOperations);
 
             Assert.NotNull(operation.LengthSymbol);
             Assert.NotNull(operation.IndexerSymbol);
@@ -556,7 +595,7 @@ public override void VisitImplicitIndexerReference(IImplicitIndexerReferenceOper
         internal override void VisitPointerIndirectionReference(IPointerIndirectionReferenceOperation operation)
         {
             Assert.Equal(OperationKind.None, operation.Kind);
-            Assert.Same(operation.Pointer, operation.Children.Single());
+            Assert.Same(operation.Pointer, operation.ChildOperations.Single());
         }
 
         public override void VisitLocalReference(ILocalReferenceOperation operation)
@@ -564,20 +603,20 @@ public override void VisitLocalReference(ILocalReferenceOperation operation)
             Assert.Equal(OperationKind.LocalReference, operation.Kind);
             Assert.NotNull(operation.Local);
             var isDeclaration = operation.IsDeclaration;
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
         }
 
         public override void VisitParameterReference(IParameterReferenceOperation operation)
         {
             Assert.Equal(OperationKind.ParameterReference, operation.Kind);
             Assert.NotNull(operation.Parameter);
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
         }
 
         public override void VisitInstanceReference(IInstanceReferenceOperation operation)
         {
             Assert.Equal(OperationKind.InstanceReference, operation.Kind);
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
             var referenceKind = operation.ReferenceKind;
         }
 
@@ -609,7 +648,7 @@ private void VisitMemberReference(IMemberReferenceOperation operation, IEnumerab
                 children = additionalChildren;
             }
 
-            AssertEx.Equal(children, operation.Children);
+            AssertEx.Equal(children, operation.ChildOperations);
         }
 
         public override void VisitFieldReference(IFieldReferenceOperation operation)
@@ -650,26 +689,26 @@ public override void VisitEventAssignment(IEventAssignmentOperation operation)
         {
             Assert.Equal(OperationKind.EventAssignment, operation.Kind);
             var adds = operation.Adds;
-            AssertEx.Equal(new[] { operation.EventReference, operation.HandlerValue }, operation.Children);
+            AssertEx.Equal(new[] { operation.EventReference, operation.HandlerValue }, operation.ChildOperations);
         }
 
         public override void VisitConditionalAccess(IConditionalAccessOperation operation)
         {
             Assert.Equal(OperationKind.ConditionalAccess, operation.Kind);
             Assert.NotNull(operation.Type);
-            AssertEx.Equal(new[] { operation.Operation, operation.WhenNotNull }, operation.Children);
+            AssertEx.Equal(new[] { operation.Operation, operation.WhenNotNull }, operation.ChildOperations);
         }
 
         public override void VisitConditionalAccessInstance(IConditionalAccessInstanceOperation operation)
         {
             Assert.Equal(OperationKind.ConditionalAccessInstance, operation.Kind);
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
         }
 
         internal override void VisitPlaceholder(IPlaceholderOperation operation)
         {
             Assert.Equal(OperationKind.None, operation.Kind);
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
         }
 
         public override void VisitUnaryOperator(IUnaryOperation operation)
@@ -681,7 +720,7 @@ public override void VisitUnaryOperator(IUnaryOperation operation)
             var isLifted = operation.IsLifted;
             var isChecked = operation.IsChecked;
 
-            Assert.Same(operation.Operand, operation.Children.Single());
+            Assert.Same(operation.Operand, operation.ChildOperations.Single());
         }
 
         public override void VisitBinaryOperator(IBinaryOperation operation)
@@ -695,7 +734,7 @@ public override void VisitBinaryOperator(IBinaryOperation operation)
             var isChecked = operation.IsChecked;
             var isCompareText = operation.IsCompareText;
 
-            AssertEx.Equal(new[] { operation.LeftOperand, operation.RightOperand }, operation.Children);
+            AssertEx.Equal(new[] { operation.LeftOperand, operation.RightOperand }, operation.ChildOperations);
         }
 
         public override void VisitTupleBinaryOperator(ITupleBinaryOperation operation)
@@ -704,7 +743,7 @@ public override void VisitTupleBinaryOperator(ITupleBinaryOperation operation)
             Assert.Equal(OperationKind.TupleBinary, operation.Kind);
             var binaryOperationKind = operation.OperatorKind;
 
-            AssertEx.Equal(new[] { operation.LeftOperand, operation.RightOperand }, operation.Children);
+            AssertEx.Equal(new[] { operation.LeftOperand, operation.RightOperand }, operation.ChildOperations);
         }
 
         public override void VisitConversion(IConversionOperation operation)
@@ -730,7 +769,7 @@ public override void VisitConversion(IConversionOperation operation)
                     break;
             }
 
-            Assert.Same(operation.Operand, operation.Children.Single());
+            Assert.Same(operation.Operand, operation.ChildOperations.Single());
         }
 
         public override void VisitConditional(IConditionalOperation operation)
@@ -740,25 +779,25 @@ public override void VisitConditional(IConditionalOperation operation)
 
             if (operation.WhenFalse != null)
             {
-                AssertEx.Equal(new[] { operation.Condition, operation.WhenTrue, operation.WhenFalse }, operation.Children);
+                AssertEx.Equal(new[] { operation.Condition, operation.WhenTrue, operation.WhenFalse }, operation.ChildOperations);
             }
             else
             {
-                AssertEx.Equal(new[] { operation.Condition, operation.WhenTrue }, operation.Children);
+                AssertEx.Equal(new[] { operation.Condition, operation.WhenTrue }, operation.ChildOperations);
             }
         }
 
         public override void VisitCoalesce(ICoalesceOperation operation)
         {
             Assert.Equal(OperationKind.Coalesce, operation.Kind);
-            AssertEx.Equal(new[] { operation.Value, operation.WhenNull }, operation.Children);
+            AssertEx.Equal(new[] { operation.Value, operation.WhenNull }, operation.ChildOperations);
             var valueConversion = operation.ValueConversion;
         }
 
         public override void VisitCoalesceAssignment(ICoalesceAssignmentOperation operation)
         {
             Assert.Equal(OperationKind.CoalesceAssignment, operation.Kind);
-            AssertEx.Equal(new[] { operation.Target, operation.Value }, operation.Children);
+            AssertEx.Equal(new[] { operation.Target, operation.Value }, operation.ChildOperations);
         }
 
         public override void VisitIsType(IIsTypeOperation operation)
@@ -766,35 +805,35 @@ public override void VisitIsType(IIsTypeOperation operation)
             Assert.Equal(OperationKind.IsType, operation.Kind);
             Assert.NotNull(operation.TypeOperand);
             bool isNegated = operation.IsNegated;
-            Assert.Same(operation.ValueOperand, operation.Children.Single());
+            Assert.Same(operation.ValueOperand, operation.ChildOperations.Single());
         }
 
         public override void VisitSizeOf(ISizeOfOperation operation)
         {
             Assert.Equal(OperationKind.SizeOf, operation.Kind);
             Assert.NotNull(operation.TypeOperand);
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
         }
 
         public override void VisitTypeOf(ITypeOfOperation operation)
         {
             Assert.Equal(OperationKind.TypeOf, operation.Kind);
             Assert.NotNull(operation.TypeOperand);
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
         }
 
         public override void VisitAnonymousFunction(IAnonymousFunctionOperation operation)
         {
             Assert.Equal(OperationKind.AnonymousFunction, operation.Kind);
             Assert.NotNull(operation.Symbol);
-            Assert.Same(operation.Body, operation.Children.Single());
+            Assert.Same(operation.Body, operation.ChildOperations.Single());
         }
 
         public override void VisitFlowAnonymousFunction(IFlowAnonymousFunctionOperation operation)
         {
             Assert.Equal(OperationKind.FlowAnonymousFunction, operation.Kind);
             Assert.NotNull(operation.Symbol);
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
         }
 
         public override void VisitLocalFunction(ILocalFunctionOperation operation)
@@ -804,7 +843,7 @@ public override void VisitLocalFunction(ILocalFunctionOperation operation)
 
             if (operation.Body != null)
             {
-                var children = operation.Children.ToImmutableArray();
+                var children = operation.ChildOperations.ToImmutableArray();
                 Assert.Same(operation.Body, children[0]);
                 if (operation.IgnoredBody != null)
                 {
@@ -819,26 +858,26 @@ public override void VisitLocalFunction(ILocalFunctionOperation operation)
             else
             {
                 Assert.Null(operation.IgnoredBody);
-                Assert.Empty(operation.Children);
+                Assert.Empty(operation.ChildOperations);
             }
         }
 
         public override void VisitLiteral(ILiteralOperation operation)
         {
             Assert.Equal(OperationKind.Literal, operation.Kind);
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
         }
 
         public override void VisitAwait(IAwaitOperation operation)
         {
             Assert.Equal(OperationKind.Await, operation.Kind);
-            Assert.Same(operation.Operation, operation.Children.Single());
+            Assert.Same(operation.Operation, operation.ChildOperations.Single());
         }
 
         public override void VisitNameOf(INameOfOperation operation)
         {
             Assert.Equal(OperationKind.NameOf, operation.Kind);
-            Assert.Same(operation.Argument, operation.Children.Single());
+            Assert.Same(operation.Argument, operation.ChildOperations.Single());
         }
 
         public override void VisitThrow(IThrowOperation operation)
@@ -846,18 +885,18 @@ public override void VisitThrow(IThrowOperation operation)
             Assert.Equal(OperationKind.Throw, operation.Kind);
             if (operation.Exception == null)
             {
-                Assert.Empty(operation.Children);
+                Assert.Empty(operation.ChildOperations);
             }
             else
             {
-                Assert.Same(operation.Exception, operation.Children.Single());
+                Assert.Same(operation.Exception, operation.ChildOperations.Single());
             }
         }
 
         public override void VisitAddressOf(IAddressOfOperation operation)
         {
             Assert.Equal(OperationKind.AddressOf, operation.Kind);
-            Assert.Same(operation.Reference, operation.Children.Single());
+            Assert.Same(operation.Reference, operation.ChildOperations.Single());
         }
 
         public override void VisitObjectCreation(IObjectCreationOperation operation)
@@ -882,13 +921,13 @@ public override void VisitObjectCreation(IObjectCreationOperation operation)
                 children = children.Concat(new[] { operation.Initializer });
             }
 
-            AssertEx.Equal(children, operation.Children);
+            AssertEx.Equal(children, operation.ChildOperations);
         }
 
         public override void VisitAnonymousObjectCreation(IAnonymousObjectCreationOperation operation)
         {
             Assert.Equal(OperationKind.AnonymousObjectCreation, operation.Kind);
-            AssertEx.Equal(operation.Initializers, operation.Children);
+            AssertEx.Equal(operation.Initializers, operation.ChildOperations);
             foreach (var initializer in operation.Initializers)
             {
                 var simpleAssignment = (ISimpleAssignmentOperation)initializer;
@@ -909,37 +948,37 @@ public override void VisitDynamicObjectCreation(IDynamicObjectCreationOperation
                 children = children.Concat(new[] { operation.Initializer });
             }
 
-            AssertEx.Equal(children, operation.Children);
+            AssertEx.Equal(children, operation.ChildOperations);
         }
 
         public override void VisitDynamicInvocation(IDynamicInvocationOperation operation)
         {
             Assert.Equal(OperationKind.DynamicInvocation, operation.Kind);
-            AssertEx.Equal(new[] { operation.Operation }.Concat(operation.Arguments), operation.Children);
+            AssertEx.Equal(new[] { operation.Operation }.Concat(operation.Arguments), operation.ChildOperations);
         }
 
         public override void VisitDynamicIndexerAccess(IDynamicIndexerAccessOperation operation)
         {
             Assert.Equal(OperationKind.DynamicIndexerAccess, operation.Kind);
-            AssertEx.Equal(new[] { operation.Operation }.Concat(operation.Arguments), operation.Children);
+            AssertEx.Equal(new[] { operation.Operation }.Concat(operation.Arguments), operation.ChildOperations);
         }
 
         public override void VisitObjectOrCollectionInitializer(IObjectOrCollectionInitializerOperation operation)
         {
             Assert.Equal(OperationKind.ObjectOrCollectionInitializer, operation.Kind);
-            AssertEx.Equal(operation.Initializers, operation.Children);
+            AssertEx.Equal(operation.Initializers, operation.ChildOperations);
         }
 
         public override void VisitMemberInitializer(IMemberInitializerOperation operation)
         {
             Assert.Equal(OperationKind.MemberInitializer, operation.Kind);
-            AssertEx.Equal(new[] { operation.InitializedMember, operation.Initializer }, operation.Children);
+            AssertEx.Equal(new[] { operation.InitializedMember, operation.Initializer }, operation.ChildOperations);
         }
 
         private void VisitSymbolInitializer(ISymbolInitializerOperation operation)
         {
             VisitLocals(operation.Locals);
-            Assert.Same(operation.Value, operation.Children.Single());
+            Assert.Same(operation.Value, operation.ChildOperations.Single());
         }
 
         public override void VisitFieldInitializer(IFieldInitializerOperation operation)
@@ -986,19 +1025,19 @@ public override void VisitArrayCreation(IArrayCreationOperation operation)
                 children = children.Concat(new[] { operation.Initializer });
             }
 
-            AssertEx.Equal(children, operation.Children);
+            AssertEx.Equal(children, operation.ChildOperations);
         }
 
         public override void VisitArrayInitializer(IArrayInitializerOperation operation)
         {
             Assert.Equal(OperationKind.ArrayInitializer, operation.Kind);
             Assert.Null(operation.Type);
-            AssertEx.Equal(operation.ElementValues, operation.Children);
+            AssertEx.Equal(operation.ElementValues, operation.ChildOperations);
         }
 
         private void VisitAssignment(IAssignmentOperation operation)
         {
-            AssertEx.Equal(new[] { operation.Target, operation.Value }, operation.Children);
+            AssertEx.Equal(new[] { operation.Target, operation.Value }, operation.ChildOperations);
         }
 
         public override void VisitSimpleAssignment(ISimpleAssignmentOperation operation)
@@ -1044,13 +1083,13 @@ public override void VisitIncrementOrDecrement(IIncrementOrDecrementOperation op
             var isLifted = operation.IsLifted;
             var isChecked = operation.IsChecked;
 
-            Assert.Same(operation.Target, operation.Children.Single());
+            Assert.Same(operation.Target, operation.ChildOperations.Single());
         }
 
         public override void VisitParenthesized(IParenthesizedOperation operation)
         {
             Assert.Equal(OperationKind.Parenthesized, operation.Kind);
-            Assert.Same(operation.Operand, operation.Children.Single());
+            Assert.Same(operation.Operand, operation.ChildOperations.Single());
         }
 
         public override void VisitDynamicMemberReference(IDynamicMemberReferenceOperation operation)
@@ -1067,18 +1106,18 @@ public override void VisitDynamicMemberReference(IDynamicMemberReferenceOperatio
 
             if (operation.Instance == null)
             {
-                Assert.Empty(operation.Children);
+                Assert.Empty(operation.ChildOperations);
             }
             else
             {
-                Assert.Same(operation.Instance, operation.Children.Single());
+                Assert.Same(operation.Instance, operation.ChildOperations.Single());
             }
         }
 
         public override void VisitDefaultValue(IDefaultValueOperation operation)
         {
             Assert.Equal(OperationKind.DefaultValue, operation.Kind);
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
         }
 
         public override void VisitTypeParameterObjectCreation(ITypeParameterObjectCreationOperation operation)
@@ -1086,11 +1125,11 @@ public override void VisitTypeParameterObjectCreation(ITypeParameterObjectCreati
             Assert.Equal(OperationKind.TypeParameterObjectCreation, operation.Kind);
             if (operation.Initializer == null)
             {
-                Assert.Empty(operation.Children);
+                Assert.Empty(operation.ChildOperations);
             }
             else
             {
-                Assert.Same(operation.Initializer, operation.Children.Single());
+                Assert.Same(operation.Initializer, operation.ChildOperations.Single());
             }
         }
 
@@ -1099,11 +1138,11 @@ internal override void VisitNoPiaObjectCreation(INoPiaObjectCreationOperation op
             Assert.Equal(OperationKind.None, operation.Kind);
             if (operation.Initializer == null)
             {
-                Assert.Empty(operation.Children);
+                Assert.Empty(operation.ChildOperations);
             }
             else
             {
-                Assert.Same(operation.Initializer, operation.Children.Single());
+                Assert.Same(operation.Initializer, operation.ChildOperations.Single());
             }
         }
 
@@ -1116,13 +1155,13 @@ public override void VisitTuple(ITupleOperation operation)
         {
             Assert.Equal(OperationKind.Tuple, operation.Kind);
             var naturalType = operation.NaturalType;
-            AssertEx.Equal(operation.Elements, operation.Children);
+            AssertEx.Equal(operation.Elements, operation.ChildOperations);
         }
 
         public override void VisitInterpolatedString(IInterpolatedStringOperation operation)
         {
             Assert.Equal(OperationKind.InterpolatedString, operation.Kind);
-            AssertEx.Equal(operation.Parts, operation.Children);
+            AssertEx.Equal(operation.Parts, operation.ChildOperations);
         }
 
         public override void VisitInterpolatedStringText(IInterpolatedStringTextOperation operation)
@@ -1132,7 +1171,7 @@ public override void VisitInterpolatedStringText(IInterpolatedStringTextOperatio
             {
                 Assert.Equal(OperationKind.Literal, ((IConversionOperation)operation.Text).Operand.Kind);
             }
-            Assert.Same(operation.Text, operation.Children.Single());
+            Assert.Same(operation.Text, operation.ChildOperations.Single());
         }
 
         public override void VisitInterpolation(IInterpolationOperation operation)
@@ -1153,14 +1192,14 @@ public override void VisitInterpolation(IInterpolationOperation operation)
                 children = children.Concat(new[] { operation.FormatString });
             }
 
-            AssertEx.Equal(children, operation.Children);
+            AssertEx.Equal(children, operation.ChildOperations);
         }
 
         public override void VisitInterpolatedStringHandlerCreation(IInterpolatedStringHandlerCreationOperation operation)
         {
             Assert.Equal(OperationKind.InterpolatedStringHandlerCreation, operation.Kind);
             IEnumerable<IOperation> children = new[] { operation.HandlerCreation, operation.Content };
-            AssertEx.Equal(children, operation.Children);
+            AssertEx.Equal(children, operation.ChildOperations);
             Assert.True(operation.HandlerCreation is IObjectCreationOperation or IDynamicObjectCreationOperation or IInvalidOperation);
             Assert.True(operation.Content is IInterpolatedStringAdditionOperation or IInterpolatedStringOperation);
             _ = operation.HandlerCreationHasSuccessParameter;
@@ -1170,7 +1209,7 @@ public override void VisitInterpolatedStringHandlerCreation(IInterpolatedStringH
         public override void VisitInterpolatedStringAddition(IInterpolatedStringAdditionOperation operation)
         {
             Assert.Equal(OperationKind.InterpolatedStringAddition, operation.Kind);
-            AssertEx.Equal(new[] { operation.Left, operation.Right }, operation.Children);
+            AssertEx.Equal(new[] { operation.Left, operation.Right }, operation.ChildOperations);
             Assert.True(operation.Left is IInterpolatedStringAdditionOperation or IInterpolatedStringOperation);
             Assert.True(operation.Right is IInterpolatedStringAdditionOperation or IInterpolatedStringOperation);
         }
@@ -1207,7 +1246,7 @@ public override void VisitConstantPattern(IConstantPatternOperation operation)
         {
             Assert.Equal(OperationKind.ConstantPattern, operation.Kind);
             VisitPatternCommon(operation);
-            Assert.Same(operation.Value, operation.Children.Single());
+            Assert.Same(operation.Value, operation.ChildOperations.Single());
         }
 
         public override void VisitRelationalPattern(IRelationalPatternOperation operation)
@@ -1220,7 +1259,7 @@ Operations.BinaryOperatorKind.GreaterThanOrEqual or
                                                   Operations.BinaryOperatorKind.Equals or // Error cases
                                                   Operations.BinaryOperatorKind.NotEquals);
             VisitPatternCommon(operation);
-            Assert.Same(operation.Value, operation.Children.Single());
+            Assert.Same(operation.Value, operation.ChildOperations.Single());
         }
 
         public override void VisitBinaryPattern(IBinaryPatternOperation operation)
@@ -1228,7 +1267,7 @@ public override void VisitBinaryPattern(IBinaryPatternOperation operation)
             Assert.Equal(OperationKind.BinaryPattern, operation.Kind);
             VisitPatternCommon(operation);
             Assert.True(operation.OperatorKind switch { Operations.BinaryOperatorKind.Or => true, Operations.BinaryOperatorKind.And => true, _ => false });
-            var children = operation.Children.ToArray();
+            var children = operation.ChildOperations.ToArray();
             Assert.Equal(2, children.Length);
             Assert.Same(operation.LeftPattern, children[0]);
             Assert.Same(operation.RightPattern, children[1]);
@@ -1238,7 +1277,7 @@ public override void VisitNegatedPattern(INegatedPatternOperation operation)
         {
             Assert.Equal(OperationKind.NegatedPattern, operation.Kind);
             VisitPatternCommon(operation);
-            Assert.Same(operation.Pattern, operation.Children.Single());
+            Assert.Same(operation.Pattern, operation.ChildOperations.Single());
         }
 
         public override void VisitTypePattern(ITypePatternOperation operation)
@@ -1246,7 +1285,7 @@ public override void VisitTypePattern(ITypePatternOperation operation)
             Assert.Equal(OperationKind.TypePattern, operation.Kind);
             Assert.NotNull(operation.MatchedType);
             VisitPatternCommon(operation);
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
         }
 
         public override void VisitDeclarationPattern(IDeclarationPatternOperation operation)
@@ -1279,7 +1318,7 @@ public override void VisitDeclarationPattern(IDeclarationPatternOperation operat
                 Assert.Null(operation.DeclaredSymbol);
             }
 
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
         }
 
         public override void VisitSlicePattern(ISlicePatternOperation operation)
@@ -1289,11 +1328,11 @@ public override void VisitSlicePattern(ISlicePatternOperation operation)
 
             if (operation.Pattern != null)
             {
-                Assert.Same(operation.Pattern, operation.Children.Single());
+                Assert.Same(operation.Pattern, operation.ChildOperations.Single());
             }
             else
             {
-                Assert.Empty(operation.Children);
+                Assert.Empty(operation.ChildOperations);
             }
         }
 
@@ -1312,7 +1351,7 @@ public override void VisitListPattern(IListPatternOperation operation)
             }
 
             IEnumerable<IOperation> children = operation.Patterns.Cast<IOperation>();
-            AssertEx.Equal(children, operation.Children);
+            AssertEx.Equal(children, operation.ChildOperations);
         }
 
         public override void VisitRecursivePattern(IRecursivePatternOperation operation)
@@ -1356,14 +1395,14 @@ public override void VisitRecursivePattern(IRecursivePatternOperation operation)
             IEnumerable<IOperation> children = operation.DeconstructionSubpatterns.Cast<IOperation>();
             children = children.Concat(operation.PropertySubpatterns);
 
-            AssertEx.Equal(children, operation.Children);
+            AssertEx.Equal(children, operation.ChildOperations);
         }
 
         public override void VisitPropertySubpattern(IPropertySubpatternOperation operation)
         {
             Assert.NotNull(operation.Pattern);
             var children = new IOperation[] { operation.Member, operation.Pattern };
-            AssertEx.Equal(children, operation.Children);
+            AssertEx.Equal(children, operation.ChildOperations);
 
             if (operation.Member.Kind == OperationKind.Invalid)
             {
@@ -1392,7 +1431,7 @@ public override void VisitSwitchExpression(ISwitchExpressionOperation operation)
             Assert.Equal(OperationKind.SwitchExpression, operation.Kind);
             Assert.NotNull(operation.Value);
             var children = operation.Arms.Cast<IOperation>().Prepend(operation.Value);
-            AssertEx.Equal(children, operation.Children);
+            AssertEx.Equal(children, operation.ChildOperations);
         }
 
         public override void VisitSwitchExpressionArm(ISwitchExpressionArmOperation operation)
@@ -1406,13 +1445,13 @@ public override void VisitSwitchExpressionArm(ISwitchExpressionArmOperation oper
             var children = operation.Guard == null
                 ? new[] { operation.Pattern, operation.Value }
                 : new[] { operation.Pattern, operation.Guard, operation.Value };
-            AssertEx.Equal(children, operation.Children);
+            AssertEx.Equal(children, operation.ChildOperations);
         }
 
         public override void VisitIsPattern(IIsPatternOperation operation)
         {
             Assert.Equal(OperationKind.IsPattern, operation.Kind);
-            AssertEx.Equal(new[] { operation.Value, operation.Pattern }, operation.Children);
+            AssertEx.Equal(new[] { operation.Value, operation.Pattern }, operation.ChildOperations);
         }
 
         public override void VisitPatternCaseClause(IPatternCaseClauseOperation operation)
@@ -1423,24 +1462,24 @@ public override void VisitPatternCaseClause(IPatternCaseClauseOperation operatio
 
             if (operation.Guard != null)
             {
-                AssertEx.Equal(new[] { operation.Pattern, operation.Guard }, operation.Children);
+                AssertEx.Equal(new[] { operation.Pattern, operation.Guard }, operation.ChildOperations);
             }
             else
             {
-                Assert.Same(operation.Pattern, operation.Children.Single());
+                Assert.Same(operation.Pattern, operation.ChildOperations.Single());
             }
         }
 
         public override void VisitTranslatedQuery(ITranslatedQueryOperation operation)
         {
             Assert.Equal(OperationKind.TranslatedQuery, operation.Kind);
-            Assert.Same(operation.Operation, operation.Children.Single());
+            Assert.Same(operation.Operation, operation.ChildOperations.Single());
         }
 
         public override void VisitDeclarationExpression(IDeclarationExpressionOperation operation)
         {
             Assert.Equal(OperationKind.DeclarationExpression, operation.Kind);
-            Assert.Same(operation.Expression, operation.Children.Single());
+            Assert.Same(operation.Expression, operation.ChildOperations.Single());
         }
 
         public override void VisitDeconstructionAssignment(IDeconstructionAssignmentOperation operation)
@@ -1452,20 +1491,20 @@ public override void VisitDeconstructionAssignment(IDeconstructionAssignmentOper
         public override void VisitDelegateCreation(IDelegateCreationOperation operation)
         {
             Assert.Equal(OperationKind.DelegateCreation, operation.Kind);
-            Assert.Same(operation.Target, operation.Children.Single());
+            Assert.Same(operation.Target, operation.ChildOperations.Single());
         }
 
         public override void VisitRaiseEvent(IRaiseEventOperation operation)
         {
             Assert.Equal(OperationKind.RaiseEvent, operation.Kind);
-            AssertEx.Equal(new IOperation[] { operation.EventReference }.Concat(operation.Arguments), operation.Children);
+            AssertEx.Equal(new IOperation[] { operation.EventReference }.Concat(operation.Arguments), operation.ChildOperations);
         }
 
         public override void VisitRangeCaseClause(IRangeCaseClauseOperation operation)
         {
             VisitCaseClauseOperation(operation);
             Assert.Equal(CaseKind.Range, operation.CaseKind);
-            AssertEx.Equal(new[] { operation.MinimumValue, operation.MaximumValue }, operation.Children);
+            AssertEx.Equal(new[] { operation.MinimumValue, operation.MaximumValue }, operation.ChildOperations);
         }
 
         public override void VisitConstructorBodyOperation(IConstructorBodyOperation operation)
@@ -1491,7 +1530,7 @@ public override void VisitConstructorBodyOperation(IConstructorBodyOperation ope
                 builder.Add(operation.ExpressionBody);
             }
 
-            AssertEx.Equal(builder, operation.Children);
+            AssertEx.Equal(builder, operation.ChildOperations);
             builder.Free();
         }
 
@@ -1504,27 +1543,27 @@ public override void VisitMethodBodyOperation(IMethodBodyOperation operation)
             {
                 if (operation.ExpressionBody != null)
                 {
-                    AssertEx.Equal(new[] { operation.BlockBody, operation.ExpressionBody }, operation.Children);
+                    AssertEx.Equal(new[] { operation.BlockBody, operation.ExpressionBody }, operation.ChildOperations);
                 }
                 else
                 {
-                    Assert.Same(operation.BlockBody, operation.Children.Single());
+                    Assert.Same(operation.BlockBody, operation.ChildOperations.Single());
                 }
             }
             else if (operation.ExpressionBody != null)
             {
-                Assert.Same(operation.ExpressionBody, operation.Children.Single());
+                Assert.Same(operation.ExpressionBody, operation.ChildOperations.Single());
             }
             else
             {
-                Assert.Empty(operation.Children);
+                Assert.Empty(operation.ChildOperations);
             }
         }
 
         public override void VisitDiscardOperation(IDiscardOperation operation)
         {
             Assert.Equal(OperationKind.Discard, operation.Kind);
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
 
             var discardSymbol = operation.DiscardSymbol;
             Assert.Equal(operation.Type, discardSymbol.Type);
@@ -1534,14 +1573,14 @@ public override void VisitDiscardPattern(IDiscardPatternOperation operation)
         {
             Assert.Equal(OperationKind.DiscardPattern, operation.Kind);
             VisitPatternCommon(operation);
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
         }
 
         public override void VisitFlowCapture(IFlowCaptureOperation operation)
         {
             Assert.Equal(OperationKind.FlowCapture, operation.Kind);
             Assert.True(operation.IsImplicit);
-            Assert.Same(operation.Value, operation.Children.Single());
+            Assert.Same(operation.Value, operation.ChildOperations.Single());
 
             switch (operation.Value.Kind)
             {
@@ -1573,28 +1612,28 @@ public override void VisitFlowCaptureReference(IFlowCaptureReferenceOperation op
         {
             Assert.Equal(OperationKind.FlowCaptureReference, operation.Kind);
             Assert.True(operation.IsImplicit);
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
         }
 
         public override void VisitIsNull(IIsNullOperation operation)
         {
             Assert.Equal(OperationKind.IsNull, operation.Kind);
             Assert.True(operation.IsImplicit);
-            Assert.Same(operation.Operand, operation.Children.Single());
+            Assert.Same(operation.Operand, operation.ChildOperations.Single());
         }
 
         public override void VisitCaughtException(ICaughtExceptionOperation operation)
         {
             Assert.Equal(OperationKind.CaughtException, operation.Kind);
             Assert.True(operation.IsImplicit);
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
         }
 
         public override void VisitStaticLocalInitializationSemaphore(IStaticLocalInitializationSemaphoreOperation operation)
         {
             Assert.Equal(OperationKind.StaticLocalInitializationSemaphore, operation.Kind);
             Assert.True(operation.IsImplicit);
-            Assert.Empty(operation.Children);
+            Assert.Empty(operation.ChildOperations);
             Assert.NotNull(operation.Local);
             Assert.True(operation.Local.IsStatic);
         }
@@ -1603,7 +1642,7 @@ public override void VisitRangeOperation(IRangeOperation operation)
         {
             Assert.Equal(OperationKind.Range, operation.Kind);
 
-            IOperation[] children = operation.Children.ToArray();
+            IOperation[] children = operation.ChildOperations.ToArray();
 
             int index = 0;
 
@@ -1623,20 +1662,20 @@ public override void VisitRangeOperation(IRangeOperation operation)
         public override void VisitReDim(IReDimOperation operation)
         {
             Assert.Equal(OperationKind.ReDim, operation.Kind);
-            AssertEx.Equal(operation.Clauses, operation.Children);
+            AssertEx.Equal(operation.Clauses, operation.ChildOperations);
             var preserve = operation.Preserve;
         }
 
         public override void VisitReDimClause(IReDimClauseOperation operation)
         {
             Assert.Equal(OperationKind.ReDimClause, operation.Kind);
-            AssertEx.Equal(SpecializedCollections.SingletonEnumerable(operation.Operand).Concat(operation.DimensionSizes), operation.Children);
+            AssertEx.Equal(SpecializedCollections.SingletonEnumerable(operation.Operand).Concat(operation.DimensionSizes), operation.ChildOperations);
         }
 
         public override void VisitUsingDeclaration(IUsingDeclarationOperation operation)
         {
             Assert.NotNull(operation.DeclarationGroup);
-            AssertEx.Equal(SpecializedCollections.SingletonEnumerable(operation.DeclarationGroup), operation.Children);
+            AssertEx.Equal(SpecializedCollections.SingletonEnumerable(operation.DeclarationGroup), operation.ChildOperations);
             Assert.True(operation.DeclarationGroup.IsImplicit);
             Assert.Null(operation.Type);
             Assert.False(operation.ConstantValue.HasValue);
@@ -1659,7 +1698,7 @@ public override void VisitWith(IWithOperation operation)
             Assert.Equal(OperationKind.With, operation.Kind);
             _ = operation.CloneMethod;
             IEnumerable<IOperation> children = SpecializedCollections.SingletonEnumerable(operation.Operand).Concat(operation.Initializer);
-            AssertEx.Equal(children, operation.Children);
+            AssertEx.Equal(children, operation.ChildOperations);
         }
     }
 }
diff --git a/src/Compilers/VisualBasic/Test/IOperation/IOperation/IOperationTests_IConversionExpression.vb b/src/Compilers/VisualBasic/Test/IOperation/IOperation/IOperationTests_IConversionExpression.vb
index ee22a1eee5a18..71e8856ceb2aa 100644
--- a/src/Compilers/VisualBasic/Test/IOperation/IOperation/IOperationTests_IConversionExpression.vb
+++ b/src/Compilers/VisualBasic/Test/IOperation/IOperation/IOperationTests_IConversionExpression.vb
@@ -2599,7 +2599,7 @@ BC30512: Option Strict On disallows implicit conversions from 'Integer' to 'SByt
                                                         Function(operation As IOperation) As IConversionOperation
                                                             Dim initializer As IVariableInitializerOperation = DirectCast(operation, IVariableDeclarationGroupOperation).Declarations.Single().Initializer
                                                             Dim initializerValue As IOperation = initializer.Value
-                                                            Return DirectCast(initializerValue, IInvalidOperation).Children.Cast(Of IConversionOperation).Single()
+                                                            Return DirectCast(initializerValue, IInvalidOperation).ChildOperations.Cast(Of IConversionOperation).Single()
                                                         End Function)
 
             ' TODO: We're not comparing types because the semantic model doesn't return the correct ConvertedType for this expression. See
diff --git a/src/Compilers/VisualBasic/Test/Semantic/Semantics/BinaryOperators.vb b/src/Compilers/VisualBasic/Test/Semantic/Semantics/BinaryOperators.vb
index 2e73394fdcc86..e71ee9ad697c2 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/Semantics/BinaryOperators.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/Semantics/BinaryOperators.vb
@@ -1499,7 +1499,7 @@ End Module
         Private Sub EnumerateChildren(iop As IOperation, ByRef numChildren as Integer)
             numChildren += 1
             Assert.NotNull(iop)
-            For Each child in iop.Children
+            For Each child In iop.ChildOperations
                 EnumerateChildren(child, numChildren)
             Next
         End Sub
diff --git a/src/Features/Core/Portable/ValueTracking/ValueTracker.OperationCollector.cs b/src/Features/Core/Portable/ValueTracking/ValueTracker.OperationCollector.cs
index 87c09da0ac71d..cafbdb3118003 100644
--- a/src/Features/Core/Portable/ValueTracking/ValueTracker.OperationCollector.cs
+++ b/src/Features/Core/Portable/ValueTracking/ValueTracker.OperationCollector.cs
@@ -92,12 +92,12 @@ private async Task VisitDefaultAsync(IOperation operation, CancellationToken can
 
             private async Task<bool> TryVisitChildrenAsync(IOperation operation, CancellationToken cancellationToken)
             {
-                foreach (var child in operation.Children)
+                foreach (var child in operation.ChildOperations)
                 {
                     await VisitAsync(child, cancellationToken).ConfigureAwait(false);
                 }
 
-                return operation.Children.Any();
+                return operation.ChildOperations.Any();
             }
 
             private Task VisitAssignmentOperationAsync(IAssignmentOperation assignmentOperation, CancellationToken cancellationToken)
diff --git a/src/Tools/Source/CompilerGeneratorTools/Source/IOperationGenerator/IOperationClassWriter.cs b/src/Tools/Source/CompilerGeneratorTools/Source/IOperationGenerator/IOperationClassWriter.cs
index a894d43850f08..db5a8a02e5ddb 100644
--- a/src/Tools/Source/CompilerGeneratorTools/Source/IOperationGenerator/IOperationClassWriter.cs
+++ b/src/Tools/Source/CompilerGeneratorTools/Source/IOperationGenerator/IOperationClassWriter.cs
@@ -451,6 +451,7 @@ void writeClass(AbstractNode type)
 
                 if (node != null)
                 {
+                    writeCountProperty(publicIOperationProps);
                     if (!node.SkipChildrenGeneration)
                     {
                         writeEnumeratorMethods(type, publicIOperationProps, node);
@@ -652,6 +653,44 @@ string getKind(AbstractNode node)
                     return GetSubName(node.Name);
                 }
 
+                void writeCountProperty(List<Property> publicIOperationProps)
+                {
+                    Write("internal override int ChildOperationsCount =>");
+                    if (publicIOperationProps.Count == 0)
+                    {
+                        WriteLine(" 0;");
+                    }
+                    else
+                    {
+                        WriteLine("");
+                        Indent();
+                        bool isFirst = true;
+                        foreach (var prop in publicIOperationProps)
+                        {
+                            if (isFirst)
+                            {
+                                isFirst = false;
+                            }
+                            else
+                            {
+                                WriteLine(" +");
+                            }
+
+                            if (IsImmutableArray(prop.Type, out _))
+                            {
+                                Write($"{prop.Name}.Length");
+                            }
+                            else
+                            {
+                                Write($"({prop.Name} is null ? 0 : 1)");
+                            }
+                        }
+
+                        WriteLine(";");
+                        Outdent();
+                    }
+                }
+
                 void writeEnumeratorMethods(AbstractNode type, List<Property> publicIOperationProps, Node node)
                 {
                     if (publicIOperationProps.Count > 0)
@@ -674,7 +713,20 @@ void writeEnumeratorMethods(AbstractNode type, List<Property> publicIOperationPr
                             }
                         }
 
-                        WriteLine("protected override IOperation GetCurrent(int slot, int index)");
+                        writeGetCurrent(orderedProperties);
+                        writeMoveNext(orderedProperties);
+                        writeMoveNextReversed(orderedProperties);
+                    }
+                    else
+                    {
+                        WriteLine("internal override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));");
+                        WriteLine("internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);");
+                        WriteLine("internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);");
+                    }
+
+                    void writeGetCurrent(List<Property> orderedProperties)
+                    {
+                        WriteLine("internal override IOperation GetCurrent(int slot, int index)");
                         Indent();
                         WriteLine("=> slot switch");
                         Brace();
@@ -705,8 +757,11 @@ void writeEnumeratorMethods(AbstractNode type, List<Property> publicIOperationPr
                         Outdent();
                         WriteLine("};");
                         Outdent();
+                    }
 
-                        WriteLine("protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)");
+                    void writeMoveNext(List<Property> orderedProperties)
+                    {
+                        WriteLine("internal override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex)");
                         Brace();
                         WriteLine("switch (previousSlot)");
                         Brace();
@@ -714,7 +769,7 @@ void writeEnumeratorMethods(AbstractNode type, List<Property> publicIOperationPr
                         int slot = 0;
                         for (; slot < orderedProperties.Count; slot++)
                         {
-                            // Operation.Enumerator starts indexes at -1. For a given property, the general psuedocode is:
+                            // Operation.ChildCollection.Enumerator starts indexes at -1. For a given property, the general pseudocode is:
 
                             // case previousSlot:
                             //     if (element i is valid) return (true, i, 0);
@@ -779,10 +834,80 @@ void writeEnumeratorMethods(AbstractNode type, List<Property> publicIOperationPr
                         Unbrace();
                         Unbrace();
                     }
-                    else
+
+                    void writeMoveNextReversed(List<Property> orderedProperties)
                     {
-                        WriteLine("protected override IOperation GetCurrent(int slot, int index) => throw ExceptionUtilities.UnexpectedValue((slot, index));");
-                        WriteLine("protected override (bool hasNext, int nextSlot, int nextIndex) MoveNext(int previousSlot, int previousIndex) => (false, int.MinValue, int.MinValue);");
+                        WriteLine("internal override (bool hasNext, int nextSlot, int nextIndex) MoveNextReversed(int previousSlot, int previousIndex)");
+                        Brace();
+                        WriteLine("switch (previousSlot)");
+                        Brace();
+
+                        int slot = orderedProperties.Count - 1;
+                        for (; slot >= 0; slot--)
+                        {
+                            // Operation.ChildCollection.Reversed.Enumerator starts indexes at int.MaxValue. For a given property, the general pseudocode is:
+
+                            // case previousSlot:
+                            //     if (element i is valid) return (true, i, 0);
+                            //     else goto i;
+
+                            // If i is an IOperation, is valid means not null. If i is an ImmutableArray, it means not empty.
+                            // As IOperation is fully nullable-enabled, and the abstract `Current` method is nullable, we'll
+                            // get a warning if it attempts to return a null IOperation from such an array, so we don't need
+                            // to have explicit Debug.Assert code for this.
+
+                            // Then, if the property is an immutable array:
+                            // case i when previousIndex > 0:
+                            //    return (true, i, previousIndex - 1);
+
+                            // While the next index is still valid, this will hit this case for i, only moving to the next
+                            // element (meaning i - 1) after the array is exhausted.
+
+                            var previousSlot = slot == (orderedProperties.Count - 1) ? "int.MaxValue" : (slot + 1).ToString();
+                            var prop = orderedProperties[slot];
+
+                            WriteLine($"case {previousSlot}:");
+                            Indent();
+
+                            bool isImmutableArray = IsImmutableArray(prop.Type, out _);
+                            if (isImmutableArray)
+                            {
+                                WriteLine($"if (!{prop.Name}.IsEmpty) return (true, {slot}, {prop.Name}.Length - 1);");
+                            }
+                            else
+                            {
+                                WriteLine($"if ({prop.Name} != null) return (true, {slot}, 0);");
+                            }
+
+                            WriteLine($"else goto case {slot};");
+
+                            Outdent();
+
+                            if (isImmutableArray)
+                            {
+                                WriteLine($"case {slot} when previousIndex > 0:");
+                                Indent();
+                                WriteLine($"return (true, {slot}, previousIndex - 1);");
+                                Outdent();
+                            }
+                        }
+
+                        // We introduce an explicit "eof" slot, that indicates the enumerator has moved beyond
+                        // the end of the sequence. This allows us to differentiate between repeated calls to
+                        // MoveNext, which are valid and always return false and the "eof" slot, and invalid
+                        // usage of the API (which may give us a slot that we are not expecting.)
+                        WriteLine("case 0:");
+                        WriteLine("case -1:");
+                        Indent();
+                        WriteLine($"return (false, -1, 0);");
+                        Outdent();
+
+                        WriteLine("default:");
+                        Indent();
+                        WriteLine("throw ExceptionUtilities.UnexpectedValue((previousSlot, previousIndex));");
+                        Outdent();
+                        Unbrace();
+                        Unbrace();
                     }
                 }
             }

From 7f1036014e662895700f26fa0506e2312820ce58 Mon Sep 17 00:00:00 2001
From: Shen Chen <shech@microsoft.com>
Date: Tue, 11 Jan 2022 19:30:07 -0800
Subject: [PATCH 316/444] Change the package feeds and remove the main-vs-deps
 channel

---
 eng/config/PublishData.json | 15 +--------------
 1 file changed, 1 insertion(+), 14 deletions(-)

diff --git a/eng/config/PublishData.json b/eng/config/PublishData.json
index ebf02b67bf5e5..10cb84b7ec43b 100644
--- a/eng/config/PublishData.json
+++ b/eng/config/PublishData.json
@@ -213,26 +213,13 @@
       "insertionCreateDraftPR": true,
       "insertionTitlePrefix": "[d17.1p3]"
     },
-    "main-vs-deps": {
-      "nugetKind": [
-        "Shipping",
-        "NonShipping"
-      ],
-      "version": "4.1.*",
-      "packageFeeds": "default",
-      "channels": [],
-      "vsBranch": "main",
-      "vsMajorVersion": 17,
-      "insertionCreateDraftPR": true,
-      "insertionTitlePrefix": "[d17.2p1]"
-    },
     "main": {
       "nugetKind": [
         "Shipping",
         "NonShipping"
       ],
       "version": "4.1.*",
-      "packageFeeds": "arcade",
+      "packageFeeds": "default",
       "channels": [],
       "vsBranch": "main",
       "vsMajorVersion": 17,

From 76c4bbd542aa55435f839349500b88854fb1c18c Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Tue, 11 Jan 2022 17:02:17 -0800
Subject: [PATCH 317/444] Fix failure to hook up TODO processing in-process

Fixes #58780
---
 .../TodoComments/VisualStudioTodoCommentsService.cs         | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/TodoComments/VisualStudioTodoCommentsService.cs b/src/VisualStudio/Core/Def/Implementation/TodoComments/VisualStudioTodoCommentsService.cs
index 4463117ab20ba..958e8a144ab19 100644
--- a/src/VisualStudio/Core/Def/Implementation/TodoComments/VisualStudioTodoCommentsService.cs
+++ b/src/VisualStudio/Core/Def/Implementation/TodoComments/VisualStudioTodoCommentsService.cs
@@ -111,6 +111,9 @@ private async Task StartWorkerAsync()
                     _asyncListener,
                     cancellationToken));
 
+            // Now that we've started, let the VS todo list know to start listening to us
+            _eventListenerTracker.EnsureEventListener(_workspace, this);
+
             var client = await RemoteHostClient.TryGetClientAsync(_workspace, cancellationToken).ConfigureAwait(false);
             if (client == null)
             {
@@ -122,9 +125,6 @@ private async Task StartWorkerAsync()
             // todo comments it will call back into us to notify VS about it.
             _lazyConnection = client.CreateConnection<IRemoteTodoCommentsDiscoveryService>(callbackTarget: this);
 
-            // Now that we've started, let the VS todo list know to start listening to us
-            _eventListenerTracker.EnsureEventListener(_workspace, this);
-
             // Now kick off scanning in the OOP process.
             // If the call fails an error has already been reported and there is nothing more to do.
             _ = await _lazyConnection.TryInvokeAsync(

From 5b84a8f96e5b115266d7ff08ec71a2209997d1bd Mon Sep 17 00:00:00 2001
From: Manish Vasani <mavasani@microsoft.com>
Date: Wed, 12 Jan 2022 02:32:01 -0800
Subject: [PATCH 318/444] Trigger global operation notification during solution
 close

Fixes [AB#1414916](https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1414916)

We currently trigger a global operation during solution open and build. These global operations pause background analysis, such as solution crawler. Dave found a performance spike in the solution crawler during solution close. We don't see a realistic reason to keep running the solution crawler while the solution is closing, hence we now pause it during solution close.
---
 .../Core/Def/SolutionEventMonitor.cs          | 26 +++++++++++++++----
 1 file changed, 21 insertions(+), 5 deletions(-)

diff --git a/src/VisualStudio/Core/Def/SolutionEventMonitor.cs b/src/VisualStudio/Core/Def/SolutionEventMonitor.cs
index 5d182e108cc66..5aa58effa87ca 100644
--- a/src/VisualStudio/Core/Def/SolutionEventMonitor.cs
+++ b/src/VisualStudio/Core/Def/SolutionEventMonitor.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using Microsoft.CodeAnalysis.Notification;
@@ -12,15 +10,17 @@
 namespace Microsoft.VisualStudio.LanguageServices
 {
     /// <summary>
-    /// Monitors Visual Studio's UIContext for SolutionBuilding and notifies the GlobalOperationService.
-    /// The intent is to suspend analysis of non-essential files for the duration of a build.
+    /// Monitors Visual Studio's UIContext for Solution building/opening/closing and notifies the GlobalOperationService.
+    /// The intent is to suspend analysis of non-essential files for the duration of these solution operations.
     /// </summary>
     internal sealed class SolutionEventMonitor : IDisposable
     {
         private const string SolutionBuilding = "Solution Building";
         private const string SolutionOpening = "Solution Opening";
+        private const string SolutionClosing = "Solution Closing";
 
-        private IGlobalOperationNotificationService _notificationService;
+        private readonly UIContext? _solutionClosingContext;
+        private IGlobalOperationNotificationService? _notificationService;
         private readonly Dictionary<string, GlobalOperationRegistration> _operations = new();
 
         public SolutionEventMonitor(VisualStudioWorkspace workspace)
@@ -45,6 +45,16 @@ public SolutionEventMonitor(VisualStudioWorkspace workspace)
                 }
 
                 KnownUIContexts.SolutionOpeningContext.UIContextChanged += SolutionOpeningContextChanged;
+
+                _solutionClosingContext = UIContext.FromUIContextGuid(VSConstants.UICONTEXT.SolutionClosing_guid);
+
+                // make sure we set initial state correctly. otherwise, we can get into a race where we might miss the very first events
+                if (_solutionClosingContext.IsActive)
+                {
+                    ContextChanged(active: true, operation: SolutionClosing);
+                }
+
+                _solutionClosingContext.UIContextChanged += SolutionClosingContextChanged;
             }
         }
 
@@ -62,6 +72,9 @@ public void Dispose()
                 _notificationService = null;
                 KnownUIContexts.SolutionBuildingContext.UIContextChanged -= SolutionBuildingContextChanged;
                 KnownUIContexts.SolutionOpeningContext.UIContextChanged -= SolutionOpeningContextChanged;
+
+                if (_solutionClosingContext != null)
+                    _solutionClosingContext.UIContextChanged -= SolutionClosingContextChanged;
             }
         }
 
@@ -71,6 +84,9 @@ private void SolutionBuildingContextChanged(object sender, UIContextChangedEvent
         private void SolutionOpeningContextChanged(object sender, UIContextChangedEventArgs e)
             => ContextChanged(e.Activated, SolutionOpening);
 
+        private void SolutionClosingContextChanged(object sender, UIContextChangedEventArgs e)
+            => ContextChanged(e.Activated, SolutionClosing);
+
         private void ContextChanged(bool active, string operation)
         {
             if (_notificationService == null)

From 1b30a3b4d55509f314d967109bb0a042df594ede Mon Sep 17 00:00:00 2001
From: Jared Parsons <jaredpparsons@gmail.com>
Date: Wed, 12 Jan 2022 06:45:12 -0800
Subject: [PATCH 319/444] Null annotate ParameterSymbol and derived (#58700)

* annotate PEParameterSymbol

* More parameters

* PR feedback

* Try verifying ContainingAssembly

* PR feedback
---
 .../FunctionPointerParameterSymbol.cs           |  2 ++
 .../Symbols/Metadata/PE/PEParameterSymbol.cs    | 17 ++++++++---------
 .../Portable/Symbols/NativeIntegerTypeSymbol.cs |  2 ++
 .../CSharp/Portable/Symbols/ParameterSymbol.cs  | 12 +++++-------
 .../Symbols/ReducedExtensionMethodSymbol.cs     |  6 +++++-
 .../Retargeting/RetargetingParameterSymbol.cs   | 13 ++++++++++---
 .../Symbols/SignatureOnlyParameterSymbol.cs     |  4 +---
 .../Symbols/Source/SourceParameterSymbolBase.cs |  5 ++---
 .../Symbols/Source/ThisParameterSymbol.cs       | 16 ++++++++--------
 .../Symbols/SubstitutedParameterSymbol.cs       |  4 +---
 src/Compilers/CSharp/Portable/Symbols/Symbol.cs |  4 +++-
 .../Synthesized/SynthesizedParameterSymbol.cs   |  6 +++---
 .../Symbols/Wrapped/WrappedParameterSymbol.cs   |  8 +++-----
 13 files changed, 53 insertions(+), 46 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerParameterSymbol.cs
index 8f77374f477ce..57d5254964fd4 100644
--- a/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerParameterSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerParameterSymbol.cs
@@ -4,6 +4,7 @@
 
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics;
 using System.Linq;
 using Roslyn.Utilities;
 
@@ -15,6 +16,7 @@ internal sealed class FunctionPointerParameterSymbol : ParameterSymbol
 
         public FunctionPointerParameterSymbol(TypeWithAnnotations typeWithAnnotations, RefKind refKind, int ordinal, FunctionPointerMethodSymbol containingSymbol, ImmutableArray<CustomModifier> refCustomModifiers)
         {
+            Debug.Assert(typeWithAnnotations.HasType);
             TypeWithAnnotations = typeWithAnnotations;
             RefKind = refKind;
             Ordinal = ordinal;
diff --git a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEParameterSymbol.cs
index 7d06f22c26224..1a0280d0473e5 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEParameterSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEParameterSymbol.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
@@ -141,7 +139,7 @@ public bool TryGetFlowAnalysisAnnotations(out FlowAnalysisAnnotations value)
         private readonly PEModuleSymbol _moduleSymbol;
 
         private ImmutableArray<CSharpAttributeData> _lazyCustomAttributes;
-        private ConstantValue _lazyDefaultValue = ConstantValue.Unset;
+        private ConstantValue? _lazyDefaultValue = ConstantValue.Unset;
         private ThreeState _lazyIsParams;
 
         private static readonly ImmutableArray<int> s_defaultStringHandlerAttributeIndexes = ImmutableArray.Create(int.MinValue);
@@ -298,6 +296,7 @@ private PEParameterSymbol(
 
             Debug.Assert(refKind == this.RefKind);
             Debug.Assert(hasNameInMetadata == this.HasNameInMetadata);
+            Debug.Assert(_name is not null);
         }
 
         private bool HasNameInMetadata
@@ -463,14 +462,14 @@ internal override bool HasMetadataConstantValue
         /// <remarks>
         /// Internal for testing.  Non-test code should use <see cref="ExplicitDefaultConstantValue"/>.
         /// </remarks>
-        internal ConstantValue ImportConstantValue(bool ignoreAttributes = false)
+        internal ConstantValue? ImportConstantValue(bool ignoreAttributes = false)
         {
             Debug.Assert(!_handle.IsNil);
 
             // Metadata Spec 22.33: 
             //   6. If Flags.HasDefault = 1 then this row [of Param table] shall own exactly one row in the Constant table [ERROR]
             //   7. If Flags.HasDefault = 0, then there shall be no rows in the Constant table owned by this row [ERROR]
-            ConstantValue value = null;
+            ConstantValue? value = null;
 
             if ((_flags & ParameterAttributes.HasDefault) != 0)
             {
@@ -485,7 +484,7 @@ internal ConstantValue ImportConstantValue(bool ignoreAttributes = false)
             return value;
         }
 
-        internal override ConstantValue ExplicitDefaultConstantValue
+        internal override ConstantValue? ExplicitDefaultConstantValue
         {
             get
             {
@@ -495,7 +494,7 @@ internal override ConstantValue ExplicitDefaultConstantValue
                     // From the C# point of view, there is no need to import a parameter's default value
                     // if the language isn't going to treat it as optional. However, we might need metadata constant value for NoPia.
                     // NOTE: Ignoring attributes for non-Optional parameters disrupts round-tripping, but the trade-off seems acceptable.
-                    ConstantValue value = ImportConstantValue(ignoreAttributes: !IsMetadataOptional);
+                    ConstantValue? value = ImportConstantValue(ignoreAttributes: !IsMetadataOptional);
                     Interlocked.CompareExchange(ref _lazyDefaultValue, value, ConstantValue.Unset);
                 }
 
@@ -503,10 +502,10 @@ internal override ConstantValue ExplicitDefaultConstantValue
             }
         }
 
-        private ConstantValue GetDefaultDecimalOrDateTimeValue()
+        private ConstantValue? GetDefaultDecimalOrDateTimeValue()
         {
             Debug.Assert(!_handle.IsNil);
-            ConstantValue value = null;
+            ConstantValue? value = null;
 
             // It is possible in Visual Basic for a parameter of object type to have a default value of DateTime type.
             // If it's present, use it.  We'll let the call-site figure out whether it can actually be used.
diff --git a/src/Compilers/CSharp/Portable/Symbols/NativeIntegerTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/NativeIntegerTypeSymbol.cs
index 68be107541d06..b42ac4326e3a6 100644
--- a/src/Compilers/CSharp/Portable/Symbols/NativeIntegerTypeSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/NativeIntegerTypeSymbol.cs
@@ -371,6 +371,8 @@ internal sealed class NativeIntegerParameterSymbol : WrappedParameterSymbol
 
         internal NativeIntegerParameterSymbol(NativeIntegerTypeSymbol containingType, NativeIntegerMethodSymbol container, ParameterSymbol underlyingParameter) : base(underlyingParameter)
         {
+            Debug.Assert(container != null);
+
             _containingType = containingType;
             _container = container;
             NativeIntegerTypeSymbol.VerifyEquality(this, underlyingParameter);
diff --git a/src/Compilers/CSharp/Portable/Symbols/ParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/ParameterSymbol.cs
index f1f0dc2642df8..60d51dd0d52af 100644
--- a/src/Compilers/CSharp/Portable/Symbols/ParameterSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/ParameterSymbol.cs
@@ -2,12 +2,11 @@
 // 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.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.InteropServices;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -79,7 +78,7 @@ protected sealed override Symbol OriginalSymbolDefinition
         /// Null if no specific marshalling information is available for the parameter.
         /// </summary>
         /// <remarks>PE symbols don't provide this information and always return null.</remarks>
-        internal abstract MarshalPseudoCustomAttributeData MarshallingInformation { get; }
+        internal abstract MarshalPseudoCustomAttributeData? MarshallingInformation { get; }
 
         /// <summary>
         /// Returns the marshalling type of this parameter, or 0 if marshalling information isn't available.
@@ -195,6 +194,7 @@ public bool IsOptional
         /// 
         /// The default value can be obtained with <see cref="ExplicitDefaultValue"/> property.
         /// </remarks>
+        [MemberNotNullWhen(true, nameof(ExplicitDefaultConstantValue))]
         public bool HasExplicitDefaultValue
         {
             get
@@ -224,7 +224,7 @@ public bool HasExplicitDefaultValue
         /// </remarks>
         /// <exception cref="InvalidOperationException">The parameter has no default value.</exception>
         [DebuggerBrowsable(DebuggerBrowsableState.Never)]
-        public object ExplicitDefaultValue
+        public object? ExplicitDefaultValue
         {
             get
             {
@@ -237,7 +237,6 @@ public object ExplicitDefaultValue
             }
         }
 
-#nullable enable
         /// <summary>
         /// Returns the default value constant of the parameter, 
         /// or null if the parameter doesn't have a default value or 
@@ -250,7 +249,6 @@ public object ExplicitDefaultValue
         /// (i.e. even non-optional parameters can have default values).
         /// </remarks>
         internal abstract ConstantValue? ExplicitDefaultConstantValue { get; }
-#nullable disable
 
         /// <summary>
         /// Gets the kind of this symbol.
@@ -385,7 +383,7 @@ public virtual bool IsThis
         /// Returns data decoded from Obsolete attribute or null if there is no Obsolete attribute.
         /// This property returns ObsoleteAttributeData.Uninitialized if attribute arguments haven't been decoded yet.
         /// </summary>
-        internal sealed override ObsoleteAttributeData ObsoleteAttributeData
+        internal sealed override ObsoleteAttributeData? ObsoleteAttributeData
         {
             get { return null; }
         }
diff --git a/src/Compilers/CSharp/Portable/Symbols/ReducedExtensionMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/ReducedExtensionMethodSymbol.cs
index 079d740aace9e..acaf3d1f1e2d6 100644
--- a/src/Compilers/CSharp/Portable/Symbols/ReducedExtensionMethodSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/ReducedExtensionMethodSymbol.cs
@@ -588,6 +588,8 @@ public override int GetHashCode()
             return _reducedFrom.GetHashCode();
         }
 
+#nullable enable
+
         private sealed class ReducedExtensionMethodParameterSymbol : WrappedParameterSymbol
         {
             private readonly ReducedExtensionMethodSymbol _containingMethod;
@@ -595,6 +597,7 @@ private sealed class ReducedExtensionMethodParameterSymbol : WrappedParameterSym
             public ReducedExtensionMethodParameterSymbol(ReducedExtensionMethodSymbol containingMethod, ParameterSymbol underlyingParameter) :
                 base(underlyingParameter)
             {
+                Debug.Assert(containingMethod != null);
                 Debug.Assert(underlyingParameter.Ordinal > 0);
                 _containingMethod = containingMethod;
             }
@@ -663,7 +666,7 @@ public sealed override bool Equals(Symbol obj, TypeCompareKind compareKind)
                 // ReferenceEquals.
 
                 var other = obj as ReducedExtensionMethodParameterSymbol;
-                return (object)other != null &&
+                return other is not null &&
                     this.Ordinal == other.Ordinal &&
                     this.ContainingSymbol.Equals(other.ContainingSymbol, compareKind);
             }
@@ -673,5 +676,6 @@ public sealed override int GetHashCode()
                 return Hash.Combine(ContainingSymbol, _underlyingParameter.Ordinal);
             }
         }
+#nullable disable
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingParameterSymbol.cs
index 69f36b356e419..dd32f3e7212af 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingParameterSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingParameterSymbol.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
@@ -118,7 +116,16 @@ internal override ImmutableArray<byte> MarshallingDescriptor
             }
         }
 
-        internal sealed override CSharpCompilation DeclaringCompilation // perf, not correctness
+        /// <summary>
+        /// <inheritdoc/>
+        /// </summary>
+        /// <remarks>
+        /// This override is done for performance reasons. Lacking the override this would redirect to 
+        /// <see cref="RetargetingModuleSymbol.DeclaringCompilation"/> which returns null. The override 
+        /// short circuits the overhead in <see cref="Symbol.DeclaringCompilation"/> and the extra virtual
+        /// dispatch and just returns null.
+        /// </remarks>
+        internal sealed override CSharpCompilation? DeclaringCompilation
         {
             get { return null; }
         }
diff --git a/src/Compilers/CSharp/Portable/Symbols/SignatureOnlyParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/SignatureOnlyParameterSymbol.cs
index f2f793ded6c09..d1325b7dd8a3e 100644
--- a/src/Compilers/CSharp/Portable/Symbols/SignatureOnlyParameterSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/SignatureOnlyParameterSymbol.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Linq;
@@ -106,7 +104,7 @@ public override bool Equals(Symbol obj, TypeCompareKind compareKind)
             }
 
             var other = obj as SignatureOnlyParameterSymbol;
-            return (object)other != null &&
+            return other is not null &&
                 TypeSymbol.Equals(_type.Type, other._type.Type, compareKind) &&
                 _type.CustomModifiers.Equals(other._type.CustomModifiers) &&
                 _refCustomModifiers.SequenceEqual(other._refCustomModifiers) &&
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceParameterSymbolBase.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceParameterSymbolBase.cs
index 191d55d0d3c60..bb9838963df88 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceParameterSymbolBase.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceParameterSymbolBase.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System.Collections.Immutable;
 using System.Diagnostics;
 using Microsoft.CodeAnalysis.CSharp.Emit;
@@ -23,6 +21,7 @@ internal abstract class SourceParameterSymbolBase : ParameterSymbol
         public SourceParameterSymbolBase(Symbol containingSymbol, int ordinal)
         {
             Debug.Assert((object)containingSymbol != null);
+            Debug.Assert(containingSymbol.ContainingAssembly != null);
             _ordinal = (ushort)ordinal;
             _containingSymbol = containingSymbol;
         }
@@ -40,7 +39,7 @@ public sealed override bool Equals(Symbol obj, TypeCompareKind compareKind)
             }
 
             var symbol = obj as SourceParameterSymbolBase;
-            return (object)symbol != null
+            return symbol is not null
                 && symbol.Ordinal == this.Ordinal
                 && symbol._containingSymbol.Equals(_containingSymbol, compareKind);
         }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/ThisParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/ThisParameterSymbol.cs
index c4e7e44ae5516..3989bdf987248 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/ThisParameterSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/ThisParameterSymbol.cs
@@ -2,11 +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.
 
-#nullable disable
-
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Immutable;
+using System.Diagnostics;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -18,15 +17,16 @@ internal sealed class ThisParameterSymbol : ParameterSymbol
     {
         internal const string SymbolName = "this";
 
-        private readonly MethodSymbol _containingMethod;
+        private readonly MethodSymbol? _containingMethod;
         private readonly TypeSymbol _containingType;
 
         internal ThisParameterSymbol(MethodSymbol forMethod) : this(forMethod, forMethod.ContainingType)
         {
         }
 
-        internal ThisParameterSymbol(MethodSymbol forMethod, TypeSymbol containingType)
+        internal ThisParameterSymbol(MethodSymbol? forMethod, TypeSymbol containingType)
         {
+            Debug.Assert(containingType is not null);
             _containingMethod = forMethod;
             _containingType = containingType;
         }
@@ -63,7 +63,7 @@ public override RefKind RefKind
 
         public override ImmutableArray<Location> Locations
         {
-            get { return (object)_containingMethod != null ? _containingMethod.Locations : ImmutableArray<Location>.Empty; }
+            get { return _containingMethod is not null ? _containingMethod.Locations : ImmutableArray<Location>.Empty; }
         }
 
         public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences
@@ -73,10 +73,10 @@ public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences
 
         public override Symbol ContainingSymbol
         {
-            get { return (Symbol)_containingMethod ?? _containingType; }
+            get { return (Symbol?)_containingMethod ?? _containingType; }
         }
 
-        internal override ConstantValue ExplicitDefaultConstantValue
+        internal override ConstantValue? ExplicitDefaultConstantValue
         {
             get { return null; }
         }
@@ -163,7 +163,7 @@ internal override bool IsMetadataOut
             get { return false; }
         }
 
-        internal override MarshalPseudoCustomAttributeData MarshallingInformation
+        internal override MarshalPseudoCustomAttributeData? MarshallingInformation
         {
             get { return null; }
         }
diff --git a/src/Compilers/CSharp/Portable/Symbols/SubstitutedParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/SubstitutedParameterSymbol.cs
index ee1c79f6baba9..383aacb6b7583 100644
--- a/src/Compilers/CSharp/Portable/Symbols/SubstitutedParameterSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/SubstitutedParameterSymbol.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System.Collections.Immutable;
 using System.Diagnostics;
 
@@ -113,7 +111,7 @@ public sealed override bool Equals(Symbol obj, TypeCompareKind compareKind)
             // ReferenceEquals.
 
             var other = obj as SubstitutedParameterSymbol;
-            return (object)other != null &&
+            return other is not null &&
                 this.Ordinal == other.Ordinal &&
                 this.ContainingSymbol.Equals(other.ContainingSymbol, compareKind);
         }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Symbol.cs b/src/Compilers/CSharp/Portable/Symbols/Symbol.cs
index 14d0714f477eb..a363ddcb6e729 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Symbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Symbol.cs
@@ -837,6 +837,7 @@ public virtual string GetDocumentationCommentId()
             }
         }
 
+#nullable enable 
         /// <summary>
         /// Fetches the documentation comment for this element with a cancellation token.
         /// </summary>
@@ -845,12 +846,13 @@ public virtual string GetDocumentationCommentId()
         /// <param name="cancellationToken">Optionally, allow cancellation of documentation comment retrieval.</param>
         /// <returns>The XML that would be written to the documentation file for the symbol.</returns>
         public virtual string GetDocumentationCommentXml(
-            CultureInfo preferredCulture = null,
+            CultureInfo? preferredCulture = null,
             bool expandIncludes = false,
             CancellationToken cancellationToken = default(CancellationToken))
         {
             return "";
         }
+#nullable disable
 
         private static readonly SymbolDisplayFormat s_debuggerDisplayFormat =
             SymbolDisplayFormat.TestFormat
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedParameterSymbol.cs
index e9112667d293c..883dc136b4cfc 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedParameterSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedParameterSymbol.cs
@@ -29,9 +29,9 @@ public SynthesizedParameterSymbolBase(
             string name,
             bool isNullChecked)
         {
-            RoslynDebug.Assert(type.HasType);
-            RoslynDebug.Assert(name != null);
-            RoslynDebug.Assert(ordinal >= 0);
+            Debug.Assert(type.HasType);
+            Debug.Assert(name != null);
+            Debug.Assert(ordinal >= 0);
 
             _container = container;
             _type = type;
diff --git a/src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedParameterSymbol.cs
index 0d112e6ddfcea..c18c9b8683344 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedParameterSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedParameterSymbol.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Globalization;
@@ -78,7 +76,7 @@ internal override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, r
             _underlyingParameter.AddSynthesizedAttributes(moduleBuilder, ref attributes);
         }
 
-        internal sealed override ConstantValue ExplicitDefaultConstantValue
+        internal sealed override ConstantValue? ExplicitDefaultConstantValue
         {
             get { return _underlyingParameter.ExplicitDefaultConstantValue; }
         }
@@ -118,7 +116,7 @@ public override ImmutableArray<CustomModifier> RefCustomModifiers
             get { return _underlyingParameter.RefCustomModifiers; }
         }
 
-        internal override MarshalPseudoCustomAttributeData MarshallingInformation
+        internal override MarshalPseudoCustomAttributeData? MarshallingInformation
         {
             get { return _underlyingParameter.MarshallingInformation; }
         }
@@ -149,7 +147,7 @@ internal override ImmutableHashSet<string> NotNullIfParameterNotNull
             get { return _underlyingParameter.NotNullIfParameterNotNull; }
         }
 
-        public override string GetDocumentationCommentXml(CultureInfo preferredCulture = null, bool expandIncludes = false, CancellationToken cancellationToken = default)
+        public override string GetDocumentationCommentXml(CultureInfo? preferredCulture = null, bool expandIncludes = false, CancellationToken cancellationToken = default)
         {
             return _underlyingParameter.GetDocumentationCommentXml(preferredCulture, expandIncludes, cancellationToken);
         }

From 2fd9f81fa821fb761e35d6c170a1703ea2df1d21 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, 12 Jan 2022 09:36:42 -0800
Subject: [PATCH 320/444] Remove RecoverableTreeLengthThreshold option (#58786)

---
 .../Portable/Workspace/ProjectCacheService.cs   |  6 ++++++
 .../Workspace/Host/Caching/CacheOptions.cs      | 16 ----------------
 .../Host/Caching/IProjectCacheService.cs        |  6 ++++++
 .../AbstractSyntaxTreeFactoryService.cs         | 17 ++++++++---------
 .../TestProjectCacheService.cs                  |  3 +++
 .../SolutionTests/SolutionTestHelpers.cs        |  8 +-------
 src/Workspaces/CoreTest/SyntaxReferenceTests.cs |  9 +--------
 .../Remote/ServiceHub/Host/RemoteWorkspace.cs   |  2 --
 .../ServiceHub/Host/TemporaryWorkspace.cs       |  2 --
 9 files changed, 25 insertions(+), 44 deletions(-)
 delete mode 100644 src/Workspaces/Core/Portable/Workspace/Host/Caching/CacheOptions.cs

diff --git a/src/Features/Core/Portable/Workspace/ProjectCacheService.cs b/src/Features/Core/Portable/Workspace/ProjectCacheService.cs
index 9015998461a1a..3205a7817bf62 100644
--- a/src/Features/Core/Portable/Workspace/ProjectCacheService.cs
+++ b/src/Features/Core/Portable/Workspace/ProjectCacheService.cs
@@ -42,6 +42,12 @@ public ProjectCacheService(Workspace? workspace, TimeSpan implicitCacheTimeout)
             _implicitCacheMonitor = new ImplicitCacheMonitor(this, implicitCacheTimeout);
         }
 
+        /// <summary>
+        /// Recoverable trees only save significant memory for larger trees.
+        /// </summary>
+        public int MinimumLengthForRecoverableTree
+            => 4 * 1024;
+
         public bool IsImplicitCacheEmpty
         {
             get
diff --git a/src/Workspaces/Core/Portable/Workspace/Host/Caching/CacheOptions.cs b/src/Workspaces/Core/Portable/Workspace/Host/Caching/CacheOptions.cs
deleted file mode 100644
index 98a95dec38650..0000000000000
--- a/src/Workspaces/Core/Portable/Workspace/Host/Caching/CacheOptions.cs
+++ /dev/null
@@ -1,16 +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.
-
-#nullable disable
-
-using Microsoft.CodeAnalysis.Options;
-
-namespace Microsoft.CodeAnalysis.Host
-{
-    internal static class CacheOptions
-    {
-        internal static readonly Option2<int> RecoverableTreeLengthThreshold = new(nameof(CacheOptions), "RecoverableTreeLengthThreshold", defaultValue: 4096,
-            storageLocation: new LocalUserProfileStorageLocation(@"Roslyn\Internal\Performance\Cache\RecoverableTreeLengthThreshold"));
-    }
-}
diff --git a/src/Workspaces/Core/Portable/Workspace/Host/Caching/IProjectCacheService.cs b/src/Workspaces/Core/Portable/Workspace/Host/Caching/IProjectCacheService.cs
index a355420c46463..e272e09b226f6 100644
--- a/src/Workspaces/Core/Portable/Workspace/Host/Caching/IProjectCacheService.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Host/Caching/IProjectCacheService.cs
@@ -26,6 +26,12 @@ internal interface IProjectCacheService : IWorkspaceService
     /// </summary>
     internal interface IProjectCacheHostService : IProjectCacheService
     {
+        /// <summary>
+        /// The length of the source file above which a recoverable tree is created.
+        /// Overridable for testing purposes.
+        /// </summary>
+        int MinimumLengthForRecoverableTree { get; }
+
         /// <summary>
         /// If caching is enabled for <see cref="ProjectId"/> key, the instance is added to 
         /// a conditional weak table.  
diff --git a/src/Workspaces/Core/Portable/Workspace/Host/SyntaxTreeFactory/AbstractSyntaxTreeFactoryService.cs b/src/Workspaces/Core/Portable/Workspace/Host/SyntaxTreeFactory/AbstractSyntaxTreeFactoryService.cs
index ca3b49a9f3e6e..ad83a1da7dcea 100644
--- a/src/Workspaces/Core/Portable/Workspace/Host/SyntaxTreeFactory/AbstractSyntaxTreeFactoryService.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Host/SyntaxTreeFactory/AbstractSyntaxTreeFactoryService.cs
@@ -16,9 +16,7 @@ namespace Microsoft.CodeAnalysis.Host
 {
     internal abstract partial class AbstractSyntaxTreeFactoryService : ISyntaxTreeFactoryService
     {
-        // Recoverable trees only save significant memory for larger trees
-        internal readonly int MinimumLengthForRecoverableTree;
-        private readonly bool _canCreateRecoverableTrees;
+        private readonly int _minimumLengthForRecoverableTree;
 
         internal HostLanguageServices LanguageServices { get; }
 
@@ -26,11 +24,12 @@ public AbstractSyntaxTreeFactoryService(
             IGlobalOptionService optionService,
             HostLanguageServices languageServices)
         {
-            this.LanguageServices = languageServices;
-            this.MinimumLengthForRecoverableTree = languageServices.WorkspaceServices.Workspace.Options.GetOption(CacheOptions.RecoverableTreeLengthThreshold);
-            _canCreateRecoverableTrees =
-                languageServices.WorkspaceServices.GetService<IProjectCacheHostService>() != null &&
-                !optionService.GetOption(WorkspaceConfigurationOptions.DisableRecoverableTrees);
+            LanguageServices = languageServices;
+
+            var cacheService = languageServices.WorkspaceServices.GetService<IProjectCacheHostService>();
+
+            _minimumLengthForRecoverableTree = (cacheService != null && !optionService.GetOption(WorkspaceConfigurationOptions.DisableRecoverableTrees)) ?
+                cacheService.MinimumLengthForRecoverableTree : int.MaxValue;
         }
 
         public abstract ParseOptions GetDefaultParseOptions();
@@ -42,7 +41,7 @@ public AbstractSyntaxTreeFactoryService(
         public abstract ParseOptions TryParsePdbParseOptions(IReadOnlyDictionary<string, string> metadata);
 
         public virtual bool CanCreateRecoverableTree(SyntaxNode root)
-            => _canCreateRecoverableTrees && root.FullSpan.Length >= this.MinimumLengthForRecoverableTree;
+            => root.FullSpan.Length > _minimumLengthForRecoverableTree;
 
         protected static SyntaxNode RecoverNode(SyntaxTree tree, TextSpan textSpan, int kind)
         {
diff --git a/src/Workspaces/CoreTest/Host/WorkspaceServices/TestProjectCacheService.cs b/src/Workspaces/CoreTest/Host/WorkspaceServices/TestProjectCacheService.cs
index 2db4ff35c95df..011cea40f1210 100644
--- a/src/Workspaces/CoreTest/Host/WorkspaceServices/TestProjectCacheService.cs
+++ b/src/Workspaces/CoreTest/Host/WorkspaceServices/TestProjectCacheService.cs
@@ -20,6 +20,9 @@ public TestProjectCacheService()
         {
         }
 
+        public int MinimumLengthForRecoverableTree
+            => 0;
+
         T IProjectCacheHostService.CacheObjectIfCachingEnabledForKey<T>(ProjectId key, ICachedObjectOwner owner, T instance)
             => instance;
 
diff --git a/src/Workspaces/CoreTest/SolutionTests/SolutionTestHelpers.cs b/src/Workspaces/CoreTest/SolutionTests/SolutionTestHelpers.cs
index 77921bd37bce3..1ed825c8d80ac 100644
--- a/src/Workspaces/CoreTest/SolutionTests/SolutionTestHelpers.cs
+++ b/src/Workspaces/CoreTest/SolutionTests/SolutionTestHelpers.cs
@@ -20,18 +20,12 @@ public static Workspace CreateWorkspace(Type[]? additionalParts = null)
             => new AdhocWorkspace(FeaturesTestCompositions.Features.AddParts(additionalParts).GetHostServices());
 
         public static Workspace CreateWorkspaceWithRecoverableSyntaxTreesAndWeakCompilations()
-        {
-            var workspace = CreateWorkspace(new[]
+            => CreateWorkspace(new[]
             {
                 typeof(TestProjectCacheService),
                 typeof(TestTemporaryStorageService)
             });
 
-            workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options
-                .WithChangedOption(CacheOptions.RecoverableTreeLengthThreshold, 0)));
-            return workspace;
-        }
-
         public static Workspace CreateWorkspaceWithPartialSemanticsAndWeakCompilations()
             => WorkspaceTestUtilities.CreateWorkspaceWithPartialSemantics(new[] { typeof(TestProjectCacheService), typeof(TestTemporaryStorageService) });
 
diff --git a/src/Workspaces/CoreTest/SyntaxReferenceTests.cs b/src/Workspaces/CoreTest/SyntaxReferenceTests.cs
index fa282fcca6c22..962578e2cf8c5 100644
--- a/src/Workspaces/CoreTest/SyntaxReferenceTests.cs
+++ b/src/Workspaces/CoreTest/SyntaxReferenceTests.cs
@@ -25,19 +25,12 @@ private static Workspace CreateWorkspace(Type[] additionalParts = null)
             => new AdhocWorkspace(FeaturesTestCompositions.Features.AddParts(additionalParts).GetHostServices());
 
         private static Workspace CreateWorkspaceWithRecoverableSyntaxTrees()
-        {
-            var workspace = CreateWorkspace(new[]
+            => CreateWorkspace(new[]
             {
                 typeof(TestProjectCacheService),
                 typeof(TestTemporaryStorageService)
             });
 
-            workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options
-                .WithChangedOption(CacheOptions.RecoverableTreeLengthThreshold, 0)));
-
-            return workspace;
-        }
-
         private static Solution AddSingleFileCSharpProject(Solution solution, string source)
         {
             var pid = ProjectId.CreateNewId();
diff --git a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs
index 33edf49d25049..2b52116a5f3cc 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs
@@ -65,8 +65,6 @@ internal RemoteWorkspace(HostServices hostServices, string? workspaceKind)
             var exportProvider = (IMefHostExportProvider)Services.HostServices;
             RegisterDocumentOptionProviders(exportProvider.GetExports<IDocumentOptionsProviderFactory, OrderableMetadata>());
 
-            SetOptions(Options.WithChangedOption(CacheOptions.RecoverableTreeLengthThreshold, 0));
-
             _registrationService = Services.GetService<ISolutionCrawlerRegistrationService>();
             _registrationService?.Register(this);
         }
diff --git a/src/Workspaces/Remote/ServiceHub/Host/TemporaryWorkspace.cs b/src/Workspaces/Remote/ServiceHub/Host/TemporaryWorkspace.cs
index f9663347b1a38..276ff5a0d7d3b 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/TemporaryWorkspace.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/TemporaryWorkspace.cs
@@ -18,8 +18,6 @@ internal class TemporaryWorkspace : Workspace
         public TemporaryWorkspace(HostServices hostServices, string? workspaceKind, SolutionInfo solutionInfo, SerializableOptionSet options)
             : base(hostServices, workspaceKind)
         {
-            SetOptions(Options.WithChangedOption(CacheOptions.RecoverableTreeLengthThreshold, 0));
-
             var documentOptionsProviderFactories = ((IMefHostExportProvider)Services.HostServices).GetExports<IDocumentOptionsProviderFactory, OrderableMetadata>();
 
             RegisterDocumentOptionProviders(documentOptionsProviderFactories);

From 8e3d62a30b833631baaa4e84c5892298f16a8c9e 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, 12 Jan 2022 10:21:52 -0800
Subject: [PATCH 321/444] Rename and share CompilerAnalyzerConfigOptions
 (#58579)

* Rename and share CompilerAnalyzerConfigOptions

* Move CachingAnalyzerConfigSet under ProjectState

* Fix EditorConfigStorageLocationExtensions
---
 .../Core/Analyzers/AnalyzerConfigOptions.cs   | 24 -----
 .../Analyzers/Formatting/FormatterHelper.cs   |  5 +-
 .../Diagnostics/DiagnosticAnalyzerTests.cs    | 10 +--
 .../Diagnostics/GetDiagnosticsTests.cs        |  8 +-
 .../SourceGeneration/GeneratorDriverTests.cs  |  6 +-
 .../Portable/CommandLine/AnalyzerConfigSet.cs |  2 +-
 .../Portable/CommandLine/CommonCompiler.cs    | 10 +--
 .../AnalyzerConfigOptions.cs                  | 17 ----
 .../CompilerAnalyzerConfigOptionsProvider.cs  |  6 +-
 .../DictionaryAnalyzerConfigOptions.cs        | 24 +++++
 .../DataProvider/SettingsProviderBase.cs      |  2 +-
 .../Solution/CachingAnalyzerConfigSet.cs      | 29 ------
 .../Portable/Workspace/Solution/Document.cs   |  3 +-
 .../Workspace/Solution/ProjectState.cs        | 89 ++++++++++---------
 .../Core/CompilerExtensions.projitems         |  5 +-
 .../AnalyzerConfigOptionsExtensions.cs        |  2 +-
 .../EditorConfigStorageLocationExtensions.cs  | 20 +++--
 17 files changed, 116 insertions(+), 146 deletions(-)
 delete mode 100644 src/CodeStyle/Core/Analyzers/AnalyzerConfigOptions.cs
 create mode 100644 src/Compilers/Core/Portable/DiagnosticAnalyzer/DictionaryAnalyzerConfigOptions.cs
 delete mode 100644 src/Workspaces/Core/Portable/Workspace/Solution/CachingAnalyzerConfigSet.cs

diff --git a/src/CodeStyle/Core/Analyzers/AnalyzerConfigOptions.cs b/src/CodeStyle/Core/Analyzers/AnalyzerConfigOptions.cs
deleted file mode 100644
index dff882163f087..0000000000000
--- a/src/CodeStyle/Core/Analyzers/AnalyzerConfigOptions.cs
+++ /dev/null
@@ -1,24 +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.Diagnostics.CodeAnalysis;
-using Microsoft.CodeAnalysis.Diagnostics;
-
-namespace Microsoft.CodeAnalysis
-{
-    internal sealed class CompilerAnalyzerConfigOptions : AnalyzerConfigOptions
-    {
-        public static CompilerAnalyzerConfigOptions Empty { get; } = new CompilerAnalyzerConfigOptions();
-
-        private CompilerAnalyzerConfigOptions()
-        {
-        }
-
-        public override bool TryGetValue(string key, [NotNullWhen(true)] out string? value)
-        {
-            value = null;
-            return false;
-        }
-    }
-}
diff --git a/src/CodeStyle/Core/Analyzers/Formatting/FormatterHelper.cs b/src/CodeStyle/Core/Analyzers/Formatting/FormatterHelper.cs
index 070b4d752f0e1..7485698d79ac6 100644
--- a/src/CodeStyle/Core/Analyzers/Formatting/FormatterHelper.cs
+++ b/src/CodeStyle/Core/Analyzers/Formatting/FormatterHelper.cs
@@ -10,6 +10,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Formatting.Rules;
 using Microsoft.CodeAnalysis.Text;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Roslyn.Utilities;
 using OptionSet = Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions;
 using static Microsoft.CodeAnalysis.Formatting.FormattingExtensions;
@@ -66,7 +67,7 @@ internal static async Task<SyntaxTree> FormatAsync(SyntaxTree syntaxTree, ISynta
             }
 
             var root = await syntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
-            var documentOptions = options ?? CompilerAnalyzerConfigOptions.Empty;
+            var documentOptions = options ?? DictionaryAnalyzerConfigOptions.Empty;
             return syntaxTree.WithRootAndOptions(Format(root, syntaxFormattingService, spans, documentOptions, rules, cancellationToken), syntaxTree.Options);
         }
 
@@ -123,7 +124,7 @@ internal static IFormattingResult GetFormattingResult(SyntaxNode node, ISyntaxFo
                 return null;
             }
 
-            options ??= CompilerAnalyzerConfigOptions.Empty;
+            options ??= DictionaryAnalyzerConfigOptions.Empty;
             rules ??= GetDefaultFormattingRules(syntaxFormattingService);
             spans ??= SpecializedCollections.SingletonEnumerable(node.FullSpan);
             return syntaxFormattingService.Format(node, spans, shouldUseFormattingSpanCollapse: false, options, rules, cancellationToken);
diff --git a/src/Compilers/CSharp/Test/Semantic/Diagnostics/DiagnosticAnalyzerTests.cs b/src/Compilers/CSharp/Test/Semantic/Diagnostics/DiagnosticAnalyzerTests.cs
index 89d8d0d468037..2d8f814c0a653 100644
--- a/src/Compilers/CSharp/Test/Semantic/Diagnostics/DiagnosticAnalyzerTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Diagnostics/DiagnosticAnalyzerTests.cs
@@ -1502,7 +1502,7 @@ private class NestedGeneratedCode{0} {{ }}
             generatedFileNames.Add(myGeneratedFileTrueName);
             tree = CSharpSyntaxTree.ParseText(string.Format(source, treeNum++), path: myGeneratedFileTrueName);
             builder.Add(tree);
-            var analyzerConfigOptions = new CompilerAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty.Add("generated_code", "true"));
+            var analyzerConfigOptions = new DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty.Add("generated_code", "true"));
             analyzerConfigOptionsPerTreeBuilder.Add(tree, analyzerConfigOptions);
 
             // (2) "generated_code = TRUE" (case insensitive)
@@ -1510,22 +1510,22 @@ private class NestedGeneratedCode{0} {{ }}
             generatedFileNames.Add(myGeneratedFileCaseInsensitiveTrueName);
             tree = CSharpSyntaxTree.ParseText(string.Format(source, treeNum++), path: myGeneratedFileCaseInsensitiveTrueName);
             builder.Add(tree);
-            analyzerConfigOptions = new CompilerAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty.Add("generated_code", "TRUE"));
+            analyzerConfigOptions = new DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty.Add("generated_code", "TRUE"));
             analyzerConfigOptionsPerTreeBuilder.Add(tree, analyzerConfigOptions);
 
             // (3) "generated_code = false"
             tree = CSharpSyntaxTree.ParseText(string.Format(source, treeNum++), path: "MyGeneratedFileFalse.cs");
             builder.Add(tree);
-            analyzerConfigOptions = new CompilerAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty.Add("generated_code", "false"));
+            analyzerConfigOptions = new DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty.Add("generated_code", "false"));
             analyzerConfigOptionsPerTreeBuilder.Add(tree, analyzerConfigOptions);
 
             // (4) "generated_code = auto"
             tree = CSharpSyntaxTree.ParseText(string.Format(source, treeNum++), path: "MyGeneratedFileAuto.cs");
             builder.Add(tree);
-            analyzerConfigOptions = new CompilerAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty.Add("generated_code", "auto"));
+            analyzerConfigOptions = new DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty.Add("generated_code", "auto"));
             analyzerConfigOptionsPerTreeBuilder.Add(tree, analyzerConfigOptions);
 
-            var analyzerConfigOptionsProvider = new CompilerAnalyzerConfigOptionsProvider(analyzerConfigOptionsPerTreeBuilder.ToImmutable(), CompilerAnalyzerConfigOptions.Empty);
+            var analyzerConfigOptionsProvider = new CompilerAnalyzerConfigOptionsProvider(analyzerConfigOptionsPerTreeBuilder.ToImmutable(), DictionaryAnalyzerConfigOptions.Empty);
             var analyzerOptions = new AnalyzerOptions(additionalFiles: ImmutableArray<AdditionalText>.Empty, analyzerConfigOptionsProvider);
 
             // Verify no compiler diagnostics.
diff --git a/src/Compilers/CSharp/Test/Semantic/Diagnostics/GetDiagnosticsTests.cs b/src/Compilers/CSharp/Test/Semantic/Diagnostics/GetDiagnosticsTests.cs
index 3f5ef60224856..e9cf8527c29de 100644
--- a/src/Compilers/CSharp/Test/Semantic/Diagnostics/GetDiagnosticsTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Diagnostics/GetDiagnosticsTests.cs
@@ -493,10 +493,10 @@ void M()
             verifyDiagnostics(analyzerDiagnostics);
 
             // Verify CS0168 reported by CSharpCompilerDiagnosticAnalyzer is not affected by "dotnet_analyzer_diagnostic = none"
-            var analyzerConfigOptions = new CompilerAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty.Add("dotnet_analyzer_diagnostic.severity", "none"));
+            var analyzerConfigOptions = new DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty.Add("dotnet_analyzer_diagnostic.severity", "none"));
             var analyzerConfigOptionsProvider = new CompilerAnalyzerConfigOptionsProvider(
                 ImmutableDictionary<object, AnalyzerConfigOptions>.Empty.Add(compilation.SyntaxTrees.Single(), analyzerConfigOptions),
-                CompilerAnalyzerConfigOptions.Empty);
+                DictionaryAnalyzerConfigOptions.Empty);
             var analyzerOptions = new AnalyzerOptions(ImmutableArray<AdditionalText>.Empty, analyzerConfigOptionsProvider);
             compilationWithAnalyzers = compilation.WithAnalyzers(analyzers, analyzerOptions);
             analyzerDiagnostics = await compilationWithAnalyzers.GetAnalyzerDiagnosticsAsync();
@@ -539,10 +539,10 @@ static async Task verifyDiagnosticsAsync(Compilation compilation, DiagnosticAnal
                 AnalyzerOptions analyzerOptions;
                 if (options.HasValue)
                 {
-                    var analyzerConfigOptions = new CompilerAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty.Add(options.Value.key, options.Value.value));
+                    var analyzerConfigOptions = new DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty.Add(options.Value.key, options.Value.value));
                     var analyzerConfigOptionsProvider = new CompilerAnalyzerConfigOptionsProvider(
                         ImmutableDictionary<object, AnalyzerConfigOptions>.Empty.Add(compilation.SyntaxTrees.Single(), analyzerConfigOptions),
-                        CompilerAnalyzerConfigOptions.Empty);
+                        DictionaryAnalyzerConfigOptions.Empty);
                     analyzerOptions = new AnalyzerOptions(ImmutableArray<AdditionalText>.Empty, analyzerConfigOptionsProvider);
                 }
                 else
diff --git a/src/Compilers/CSharp/Test/Semantic/SourceGeneration/GeneratorDriverTests.cs b/src/Compilers/CSharp/Test/Semantic/SourceGeneration/GeneratorDriverTests.cs
index 083731a461eb5..52a594701e739 100644
--- a/src/Compilers/CSharp/Test/Semantic/SourceGeneration/GeneratorDriverTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/SourceGeneration/GeneratorDriverTests.cs
@@ -847,7 +847,7 @@ class C
             compilation.VerifyDiagnostics();
             Assert.Single(compilation.SyntaxTrees);
 
-            var options = new CompilerAnalyzerConfigOptionsProvider(ImmutableDictionary<object, AnalyzerConfigOptions>.Empty, new CompilerAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty.Add("a", "abc").Add("b", "def")));
+            var options = new CompilerAnalyzerConfigOptionsProvider(ImmutableDictionary<object, AnalyzerConfigOptions>.Empty, new DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty.Add("a", "abc").Add("b", "def")));
 
             AnalyzerConfigOptionsProvider? passedIn = null;
             var testGenerator = new CallbackGenerator(
@@ -2190,7 +2190,7 @@ class C { }
 
             var builder = ImmutableDictionary<string, string>.Empty.ToBuilder();
             builder.Add("test", "value1");
-            var optionsProvider = new CompilerAnalyzerConfigOptionsProvider(ImmutableDictionary<object, AnalyzerConfigOptions>.Empty, new CompilerAnalyzerConfigOptions(builder.ToImmutable()));
+            var optionsProvider = new CompilerAnalyzerConfigOptionsProvider(ImmutableDictionary<object, AnalyzerConfigOptions>.Empty, new DictionaryAnalyzerConfigOptions(builder.ToImmutable()));
 
             // run the generator once, and check it was passed the configs
             GeneratorDriver driver = CSharpGeneratorDriver.Create(new ISourceGenerator[] { generator }, parseOptions: parseOptions, optionsProvider: optionsProvider, driverOptions: new GeneratorDriverOptions(IncrementalGeneratorOutputKind.None, trackIncrementalGeneratorSteps: true));
@@ -2227,7 +2227,7 @@ class C { }
             // now update the config
             builder.Clear();
             builder.Add("test", "value2");
-            var newOptionsProvider = optionsProvider.WithGlobalOptions(new CompilerAnalyzerConfigOptions(builder.ToImmutable()));
+            var newOptionsProvider = optionsProvider.WithGlobalOptions(new DictionaryAnalyzerConfigOptions(builder.ToImmutable()));
             driver = driver.WithUpdatedAnalyzerConfigOptions(newOptionsProvider);
 
             // check we ran
diff --git a/src/Compilers/Core/Portable/CommandLine/AnalyzerConfigSet.cs b/src/Compilers/Core/Portable/CommandLine/AnalyzerConfigSet.cs
index db234604c7b39..d74d11e4b8a47 100644
--- a/src/Compilers/Core/Portable/CommandLine/AnalyzerConfigSet.cs
+++ b/src/Compilers/Core/Portable/CommandLine/AnalyzerConfigSet.cs
@@ -305,7 +305,7 @@ public AnalyzerConfigOptionsResult GetOptionsForSourcePath(string sourcePath)
 
                 result = new AnalyzerConfigOptionsResult(
                     treeOptionsBuilder.Count > 0 ? treeOptionsBuilder.ToImmutable() : SyntaxTree.EmptyDiagnosticOptions,
-                    analyzerOptionsBuilder.Count > 0 ? analyzerOptionsBuilder.ToImmutable() : AnalyzerConfigOptions.EmptyDictionary,
+                    analyzerOptionsBuilder.Count > 0 ? analyzerOptionsBuilder.ToImmutable() : DictionaryAnalyzerConfigOptions.EmptyDictionary,
                     diagnosticBuilder.ToImmutableAndFree());
 
                 if (_optionsCache.TryAdd(sectionKey, result))
diff --git a/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs b/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs
index 9e61cff4ef2f5..2245042f57874 100644
--- a/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs
+++ b/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs
@@ -933,8 +933,8 @@ private static CompilerAnalyzerConfigOptionsProvider UpdateAnalyzerConfigOptions
                 // Optimization: don't create a bunch of entries pointing to a no-op
                 if (options.Count > 0)
                 {
-                    Debug.Assert(existing.GetOptions(syntaxTree) == CompilerAnalyzerConfigOptions.Empty);
-                    builder.Add(syntaxTree, new CompilerAnalyzerConfigOptions(options));
+                    Debug.Assert(existing.GetOptions(syntaxTree) == DictionaryAnalyzerConfigOptions.Empty);
+                    builder.Add(syntaxTree, new DictionaryAnalyzerConfigOptions(options));
                 }
                 i++;
             }
@@ -948,8 +948,8 @@ private static CompilerAnalyzerConfigOptionsProvider UpdateAnalyzerConfigOptions
                     // Optimization: don't create a bunch of entries pointing to a no-op
                     if (options.Count > 0)
                     {
-                        Debug.Assert(existing.GetOptions(additionalFiles[i]) == CompilerAnalyzerConfigOptions.Empty);
-                        builder.Add(additionalFiles[i], new CompilerAnalyzerConfigOptions(options));
+                        Debug.Assert(existing.GetOptions(additionalFiles[i]) == DictionaryAnalyzerConfigOptions.Empty);
+                        builder.Add(additionalFiles[i], new DictionaryAnalyzerConfigOptions(options));
                     }
                 }
             }
@@ -995,7 +995,7 @@ private void CompileAndEmit(
                 if (Arguments.AnalyzerConfigPaths.Length > 0)
                 {
                     Debug.Assert(analyzerConfigSet is object);
-                    analyzerConfigProvider = analyzerConfigProvider.WithGlobalOptions(new CompilerAnalyzerConfigOptions(analyzerConfigSet.GetOptionsForSourcePath(string.Empty).AnalyzerOptions));
+                    analyzerConfigProvider = analyzerConfigProvider.WithGlobalOptions(new DictionaryAnalyzerConfigOptions(analyzerConfigSet.GetOptionsForSourcePath(string.Empty).AnalyzerOptions));
 
                     // TODO(https://github.com/dotnet/roslyn/issues/31916): The compiler currently doesn't support
                     // configuring diagnostic reporting on additional text files individually.
diff --git a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerConfigOptions.cs b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerConfigOptions.cs
index c9f9e0c539289..1e98c9cccb6ee 100644
--- a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerConfigOptions.cs
+++ b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerConfigOptions.cs
@@ -3,7 +3,6 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
-using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
 
 namespace Microsoft.CodeAnalysis.Diagnostics
@@ -16,25 +15,9 @@ public abstract class AnalyzerConfigOptions
         /// </summary>
         public static StringComparer KeyComparer { get; } = AnalyzerConfig.Section.PropertiesKeyComparer;
 
-        internal static ImmutableDictionary<string, string> EmptyDictionary = ImmutableDictionary.Create<string, string>(KeyComparer);
-
         /// <summary>
         /// Get an analyzer config value for the given key, using the <see cref="KeyComparer"/>.
         /// </summary>
         public abstract bool TryGetValue(string key, [NotNullWhen(true)] out string? value);
     }
-
-    internal sealed class CompilerAnalyzerConfigOptions : AnalyzerConfigOptions
-    {
-        public static CompilerAnalyzerConfigOptions Empty { get; } = new CompilerAnalyzerConfigOptions(EmptyDictionary);
-
-        private readonly ImmutableDictionary<string, string> _backing;
-
-        public CompilerAnalyzerConfigOptions(ImmutableDictionary<string, string> properties)
-        {
-            _backing = properties;
-        }
-
-        public override bool TryGetValue(string key, [NotNullWhen(true)] out string? value) => _backing.TryGetValue(key, out value);
-    }
 }
diff --git a/src/Compilers/Core/Portable/DiagnosticAnalyzer/CompilerAnalyzerConfigOptionsProvider.cs b/src/Compilers/Core/Portable/DiagnosticAnalyzer/CompilerAnalyzerConfigOptionsProvider.cs
index 3f095718378d3..373a04e94484e 100644
--- a/src/Compilers/Core/Portable/DiagnosticAnalyzer/CompilerAnalyzerConfigOptionsProvider.cs
+++ b/src/Compilers/Core/Portable/DiagnosticAnalyzer/CompilerAnalyzerConfigOptionsProvider.cs
@@ -13,7 +13,7 @@ internal sealed class CompilerAnalyzerConfigOptionsProvider : AnalyzerConfigOpti
         public static CompilerAnalyzerConfigOptionsProvider Empty { get; }
             = new CompilerAnalyzerConfigOptionsProvider(
                 ImmutableDictionary<object, AnalyzerConfigOptions>.Empty,
-                CompilerAnalyzerConfigOptions.Empty);
+                DictionaryAnalyzerConfigOptions.Empty);
 
         internal CompilerAnalyzerConfigOptionsProvider(
             ImmutableDictionary<object, AnalyzerConfigOptions> treeDict,
@@ -26,10 +26,10 @@ internal CompilerAnalyzerConfigOptionsProvider(
         public override AnalyzerConfigOptions GlobalOptions { get; }
 
         public override AnalyzerConfigOptions GetOptions(SyntaxTree tree)
-            => _treeDict.TryGetValue(tree, out var options) ? options : CompilerAnalyzerConfigOptions.Empty;
+            => _treeDict.TryGetValue(tree, out var options) ? options : DictionaryAnalyzerConfigOptions.Empty;
 
         public override AnalyzerConfigOptions GetOptions(AdditionalText textFile)
-            => _treeDict.TryGetValue(textFile, out var options) ? options : CompilerAnalyzerConfigOptions.Empty;
+            => _treeDict.TryGetValue(textFile, out var options) ? options : DictionaryAnalyzerConfigOptions.Empty;
 
         internal CompilerAnalyzerConfigOptionsProvider WithAdditionalTreeOptions(ImmutableDictionary<object, AnalyzerConfigOptions> treeDict)
             => new CompilerAnalyzerConfigOptionsProvider(_treeDict.AddRange(treeDict), GlobalOptions);
diff --git a/src/Compilers/Core/Portable/DiagnosticAnalyzer/DictionaryAnalyzerConfigOptions.cs b/src/Compilers/Core/Portable/DiagnosticAnalyzer/DictionaryAnalyzerConfigOptions.cs
new file mode 100644
index 0000000000000..368b6c4176976
--- /dev/null
+++ b/src/Compilers/Core/Portable/DiagnosticAnalyzer/DictionaryAnalyzerConfigOptions.cs
@@ -0,0 +1,24 @@
+// 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.Diagnostics.CodeAnalysis;
+
+namespace Microsoft.CodeAnalysis.Diagnostics
+{
+    internal sealed class DictionaryAnalyzerConfigOptions : AnalyzerConfigOptions
+    {
+        internal static readonly ImmutableDictionary<string, string> EmptyDictionary = ImmutableDictionary.Create<string, string>(KeyComparer);
+
+        public static DictionaryAnalyzerConfigOptions Empty { get; } = new DictionaryAnalyzerConfigOptions(EmptyDictionary);
+
+        internal readonly ImmutableDictionary<string, string> Options;
+
+        public DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string> options)
+            => Options = options;
+
+        public override bool TryGetValue(string key, [NotNullWhen(true)] out string? value)
+            => Options.TryGetValue(key, out value);
+    }
+}
diff --git a/src/EditorFeatures/Core/EditorConfigSettings/DataProvider/SettingsProviderBase.cs b/src/EditorFeatures/Core/EditorConfigSettings/DataProvider/SettingsProviderBase.cs
index 05e73e2a8bcdd..1f137a0d8c170 100644
--- a/src/EditorFeatures/Core/EditorConfigSettings/DataProvider/SettingsProviderBase.cs
+++ b/src/EditorFeatures/Core/EditorConfigSettings/DataProvider/SettingsProviderBase.cs
@@ -51,7 +51,7 @@ protected void Update()
                 return;
             }
 
-            var configOptionsProvider = new WorkspaceAnalyzerConfigOptionsProvider(project.State);
+            var configOptionsProvider = new ProjectAnalyzerConfigOptionsProvider(project.State);
             var workspaceOptions = configOptionsProvider.GetOptionsForSourcePath(givenFolder.FullName);
             var result = project.GetAnalyzerConfigOptions();
             var options = new CombinedAnalyzerConfigOptions(workspaceOptions, result);
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/CachingAnalyzerConfigSet.cs b/src/Workspaces/Core/Portable/Workspace/Solution/CachingAnalyzerConfigSet.cs
deleted file mode 100644
index 3d4aa21eeeba0..0000000000000
--- a/src/Workspaces/Core/Portable/Workspace/Solution/CachingAnalyzerConfigSet.cs
+++ /dev/null
@@ -1,29 +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.Concurrent;
-
-namespace Microsoft.CodeAnalysis
-{
-    internal sealed class CachingAnalyzerConfigSet
-    {
-        private readonly ConcurrentDictionary<string, AnalyzerConfigOptionsResult> _sourcePathToResult = new();
-        private readonly Func<string, AnalyzerConfigOptionsResult> _computeFunction;
-        private readonly AnalyzerConfigSet _underlyingSet;
-
-        public AnalyzerConfigOptionsResult GlobalConfigOptions => _underlyingSet.GlobalConfigOptions;
-
-        public CachingAnalyzerConfigSet(AnalyzerConfigSet underlyingSet)
-        {
-            _underlyingSet = underlyingSet;
-            _computeFunction = _underlyingSet.GetOptionsForSourcePath;
-        }
-
-        public AnalyzerConfigOptionsResult GetOptionsForSourcePath(string sourcePath)
-        {
-            return _sourcePathToResult.GetOrAdd(sourcePath, _computeFunction);
-        }
-    }
-}
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs b/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs
index d6e00ff23f2e8..a9c751dd05d65 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs
@@ -535,8 +535,7 @@ internal Task<ImmutableDictionary<string, string>> GetAnalyzerOptionsAsync(Cance
             else
             {
                 // Really no idea where this is going, so bail
-                // TODO: use AnalyzerConfigOptions.EmptyDictionary, since we don't have a public dictionary
-                return Task.FromResult(ImmutableDictionary.Create<string, string>(AnalyzerConfigOptions.KeyComparer));
+                return Task.FromResult(DictionaryAnalyzerConfigOptions.EmptyDictionary);
             }
         }
     }
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/ProjectState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/ProjectState.cs
index b6947a1036576..c2015dfa3cdfe 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/ProjectState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/ProjectState.cs
@@ -50,9 +50,9 @@ internal partial class ProjectState
         private readonly ValueSource<ProjectStateChecksums> _lazyChecksums;
 
         /// <summary>
-        /// The <see cref="AnalyzerConfigSet"/> to be used for analyzer options for specific trees.
+        /// Analyzer config options to be used for specific trees.
         /// </summary>
-        private readonly ValueSource<CachingAnalyzerConfigSet> _lazyAnalyzerConfigSet;
+        private readonly ValueSource<AnalyzerConfigOptionsCache> _lazyAnalyzerConfigOptions;
 
         private AnalyzerOptions? _lazyAnalyzerOptions;
 
@@ -70,7 +70,7 @@ private ProjectState(
             TextDocumentStates<AnalyzerConfigDocumentState> analyzerConfigDocumentStates,
             AsyncLazy<VersionStamp> lazyLatestDocumentVersion,
             AsyncLazy<VersionStamp> lazyLatestDocumentTopLevelChangeVersion,
-            ValueSource<CachingAnalyzerConfigSet> lazyAnalyzerConfigSet)
+            ValueSource<AnalyzerConfigOptionsCache> lazyAnalyzerConfigSet)
         {
             _solutionServices = solutionServices;
             _languageServices = languageServices;
@@ -79,7 +79,7 @@ private ProjectState(
             AnalyzerConfigDocumentStates = analyzerConfigDocumentStates;
             _lazyLatestDocumentVersion = lazyLatestDocumentVersion;
             _lazyLatestDocumentTopLevelChangeVersion = lazyLatestDocumentTopLevelChangeVersion;
-            _lazyAnalyzerConfigSet = lazyAnalyzerConfigSet;
+            _lazyAnalyzerConfigOptions = lazyAnalyzerConfigSet;
 
             // ownership of information on document has moved to project state. clear out documentInfo the state is
             // holding on. otherwise, these information will be held onto unnecessarily by projectInfo even after
@@ -103,14 +103,14 @@ public ProjectState(ProjectInfo projectInfo, HostLanguageServices languageServic
             // We need to compute our AnalyerConfigDocumentStates first, since we use those to produce our DocumentStates
             AnalyzerConfigDocumentStates = new TextDocumentStates<AnalyzerConfigDocumentState>(projectInfoFixed.AnalyzerConfigDocuments, info => new AnalyzerConfigDocumentState(info, solutionServices));
 
-            _lazyAnalyzerConfigSet = ComputeAnalyzerConfigSetValueSource(AnalyzerConfigDocumentStates);
+            _lazyAnalyzerConfigOptions = ComputeAnalyzerConfigOptionsValueSource(AnalyzerConfigDocumentStates);
 
             // Add analyzer config information to the compilation options
             if (projectInfoFixed.CompilationOptions != null)
             {
                 projectInfoFixed = projectInfoFixed.WithCompilationOptions(
                     projectInfoFixed.CompilationOptions.WithSyntaxTreeOptionsProvider(
-                        new WorkspaceSyntaxTreeOptionsProvider(_lazyAnalyzerConfigSet)));
+                        new ProjectSyntaxTreeOptionsProvider(_lazyAnalyzerConfigOptions)));
             }
 
             var parseOptions = projectInfoFixed.ParseOptions;
@@ -246,13 +246,13 @@ internal DocumentState CreateDocument(DocumentInfo documentInfo, ParseOptions? p
         public AnalyzerOptions AnalyzerOptions
             => _lazyAnalyzerOptions ??= new AnalyzerOptions(
                 additionalFiles: AdditionalDocumentStates.SelectAsArray(static documentState => documentState.AdditionalText),
-                optionsProvider: new WorkspaceAnalyzerConfigOptionsProvider(this));
+                optionsProvider: new ProjectAnalyzerConfigOptionsProvider(this));
 
         public async Task<ImmutableDictionary<string, string>> GetAnalyzerOptionsForPathAsync(
             string path,
             CancellationToken cancellationToken)
         {
-            var configSet = await _lazyAnalyzerConfigSet.GetValueAsync(cancellationToken).ConfigureAwait(false);
+            var configSet = await _lazyAnalyzerConfigOptions.GetValueAsync(cancellationToken).ConfigureAwait(false);
             return configSet.GetOptionsForSourcePath(path).AnalyzerOptions;
         }
 
@@ -286,47 +286,37 @@ public async Task<ImmutableDictionary<string, string>> GetAnalyzerOptionsForPath
                     return null;
             }
 
-            return _lazyAnalyzerConfigSet.GetValue(CancellationToken.None).GetOptionsForSourcePath(sourceFilePath);
+            return _lazyAnalyzerConfigOptions.GetValue(CancellationToken.None).GetOptionsForSourcePath(sourceFilePath);
         }
 
-        internal sealed class WorkspaceAnalyzerConfigOptionsProvider : AnalyzerConfigOptionsProvider
+        internal sealed class ProjectAnalyzerConfigOptionsProvider : AnalyzerConfigOptionsProvider
         {
             private readonly ProjectState _projectState;
 
-            public WorkspaceAnalyzerConfigOptionsProvider(ProjectState projectState)
+            public ProjectAnalyzerConfigOptionsProvider(ProjectState projectState)
                 => _projectState = projectState;
 
             public override AnalyzerConfigOptions GlobalOptions
-                => new WorkspaceAnalyzerConfigOptions(_projectState._lazyAnalyzerConfigSet.GetValue(CancellationToken.None).GetOptionsForSourcePath(string.Empty));
+                => GetOptionsForSourcePath(string.Empty);
 
             public override AnalyzerConfigOptions GetOptions(SyntaxTree tree)
-                => new WorkspaceAnalyzerConfigOptions(_projectState._lazyAnalyzerConfigSet.GetValue(CancellationToken.None).GetOptionsForSourcePath(tree.FilePath));
+                => GetOptionsForSourcePath(tree.FilePath);
 
             public override AnalyzerConfigOptions GetOptions(AdditionalText textFile)
             {
                 // TODO: correctly find the file path, since it looks like we give this the document's .Name under the covers if we don't have one
-                return new WorkspaceAnalyzerConfigOptions(_projectState._lazyAnalyzerConfigSet.GetValue(CancellationToken.None).GetOptionsForSourcePath(textFile.Path));
+                return GetOptionsForSourcePath(textFile.Path);
             }
 
             public AnalyzerConfigOptions GetOptionsForSourcePath(string path)
-                => new WorkspaceAnalyzerConfigOptions(_projectState._lazyAnalyzerConfigSet.GetValue(CancellationToken.None).GetOptionsForSourcePath(path));
-
-            private sealed class WorkspaceAnalyzerConfigOptions : AnalyzerConfigOptions
-            {
-                private readonly ImmutableDictionary<string, string> _backing;
-
-                public WorkspaceAnalyzerConfigOptions(AnalyzerConfigOptionsResult analyzerConfigOptions)
-                    => _backing = analyzerConfigOptions.AnalyzerOptions;
-
-                public override bool TryGetValue(string key, [NotNullWhen(true)] out string? value) => _backing.TryGetValue(key, out value);
-            }
+                => new DictionaryAnalyzerConfigOptions(_projectState._lazyAnalyzerConfigOptions.GetValue(CancellationToken.None).GetOptionsForSourcePath(path).AnalyzerOptions);
         }
 
-        private sealed class WorkspaceSyntaxTreeOptionsProvider : SyntaxTreeOptionsProvider
+        private sealed class ProjectSyntaxTreeOptionsProvider : SyntaxTreeOptionsProvider
         {
-            private readonly ValueSource<CachingAnalyzerConfigSet> _lazyAnalyzerConfigSet;
+            private readonly ValueSource<AnalyzerConfigOptionsCache> _lazyAnalyzerConfigSet;
 
-            public WorkspaceSyntaxTreeOptionsProvider(ValueSource<CachingAnalyzerConfigSet> lazyAnalyzerConfigSet)
+            public ProjectSyntaxTreeOptionsProvider(ValueSource<AnalyzerConfigOptionsCache> lazyAnalyzerConfigSet)
                 => _lazyAnalyzerConfigSet = lazyAnalyzerConfigSet;
 
             public override GeneratedKind IsGenerated(SyntaxTree tree, CancellationToken cancellationToken)
@@ -352,16 +342,16 @@ public override bool TryGetGlobalDiagnosticValue(string diagnosticId, Cancellati
 
             public override bool Equals(object? obj)
             {
-                return obj is WorkspaceSyntaxTreeOptionsProvider other
+                return obj is ProjectSyntaxTreeOptionsProvider other
                     && _lazyAnalyzerConfigSet == other._lazyAnalyzerConfigSet;
             }
 
             public override int GetHashCode() => _lazyAnalyzerConfigSet.GetHashCode();
         }
 
-        private static ValueSource<CachingAnalyzerConfigSet> ComputeAnalyzerConfigSetValueSource(TextDocumentStates<AnalyzerConfigDocumentState> analyzerConfigDocumentStates)
+        private static ValueSource<AnalyzerConfigOptionsCache> ComputeAnalyzerConfigOptionsValueSource(TextDocumentStates<AnalyzerConfigDocumentState> analyzerConfigDocumentStates)
         {
-            return new AsyncLazy<CachingAnalyzerConfigSet>(
+            return new AsyncLazy<AnalyzerConfigOptionsCache>(
                 asynchronousComputeFunction: async cancellationToken =>
                 {
                     var tasks = analyzerConfigDocumentStates.States.Values.Select(a => a.GetAnalyzerConfigAsync(cancellationToken));
@@ -369,16 +359,35 @@ private static ValueSource<CachingAnalyzerConfigSet> ComputeAnalyzerConfigSetVal
 
                     cancellationToken.ThrowIfCancellationRequested();
 
-                    return new CachingAnalyzerConfigSet(AnalyzerConfigSet.Create(analyzerConfigs));
+                    return new AnalyzerConfigOptionsCache(AnalyzerConfigSet.Create(analyzerConfigs));
                 },
                 synchronousComputeFunction: cancellationToken =>
                 {
                     var analyzerConfigs = analyzerConfigDocumentStates.SelectAsArray(a => a.GetAnalyzerConfig(cancellationToken));
-                    return new CachingAnalyzerConfigSet(AnalyzerConfigSet.Create(analyzerConfigs));
+                    return new AnalyzerConfigOptionsCache(AnalyzerConfigSet.Create(analyzerConfigs));
                 },
                 cacheResult: true);
         }
 
+        private readonly struct AnalyzerConfigOptionsCache
+        {
+            private readonly ConcurrentDictionary<string, AnalyzerConfigOptionsResult> _sourcePathToResult = new();
+            private readonly Func<string, AnalyzerConfigOptionsResult> _computeFunction;
+            private readonly AnalyzerConfigSet _configSet;
+
+            public AnalyzerConfigOptionsCache(AnalyzerConfigSet configSet)
+            {
+                _configSet = configSet;
+                _computeFunction = _configSet.GetOptionsForSourcePath;
+            }
+
+            public AnalyzerConfigOptionsResult GlobalConfigOptions
+                => _configSet.GlobalConfigOptions;
+
+            public AnalyzerConfigOptionsResult GetOptionsForSourcePath(string sourcePath)
+                => _sourcePathToResult.GetOrAdd(sourcePath, _computeFunction);
+        }
+
         public Task<VersionStamp> GetLatestDocumentVersionAsync(CancellationToken cancellationToken)
             => _lazyLatestDocumentVersion.GetValueAsync(cancellationToken);
 
@@ -471,7 +480,7 @@ private ProjectState With(
             TextDocumentStates<AnalyzerConfigDocumentState>? analyzerConfigDocumentStates = null,
             AsyncLazy<VersionStamp>? latestDocumentVersion = null,
             AsyncLazy<VersionStamp>? latestDocumentTopLevelChangeVersion = null,
-            ValueSource<CachingAnalyzerConfigSet>? analyzerConfigSet = null)
+            ValueSource<AnalyzerConfigOptionsCache>? analyzerConfigSet = null)
         {
             return new ProjectState(
                 projectInfo ?? _projectInfo,
@@ -482,7 +491,7 @@ private ProjectState With(
                 analyzerConfigDocumentStates ?? AnalyzerConfigDocumentStates,
                 latestDocumentVersion ?? _lazyLatestDocumentVersion,
                 latestDocumentTopLevelChangeVersion ?? _lazyLatestDocumentTopLevelChangeVersion,
-                analyzerConfigSet ?? _lazyAnalyzerConfigSet);
+                analyzerConfigSet ?? _lazyAnalyzerConfigOptions);
         }
 
         private ProjectInfo.ProjectAttributes Attributes
@@ -525,7 +534,7 @@ public ProjectState WithCompilationOptions(CompilationOptions options)
                 return this;
             }
 
-            var newProvider = new WorkspaceSyntaxTreeOptionsProvider(_lazyAnalyzerConfigSet);
+            var newProvider = new ProjectSyntaxTreeOptionsProvider(_lazyAnalyzerConfigOptions);
 
             return With(projectInfo: ProjectInfo.WithCompilationOptions(options.WithSyntaxTreeOptionsProvider(newProvider))
                        .WithVersion(Version.GetNewerVersion()));
@@ -635,13 +644,13 @@ public ProjectState AddAnalyzerConfigDocuments(ImmutableArray<AnalyzerConfigDocu
 
         private ProjectState CreateNewStateForChangedAnalyzerConfigDocuments(TextDocumentStates<AnalyzerConfigDocumentState> newAnalyzerConfigDocumentStates)
         {
-            var newAnalyzerConfigSet = ComputeAnalyzerConfigSetValueSource(newAnalyzerConfigDocumentStates);
+            var newAnalyzerConfigSet = ComputeAnalyzerConfigOptionsValueSource(newAnalyzerConfigDocumentStates);
             var projectInfo = ProjectInfo.WithVersion(Version.GetNewerVersion());
 
             // Changing analyzer configs changes compilation options
             if (CompilationOptions != null)
             {
-                var newProvider = new WorkspaceSyntaxTreeOptionsProvider(newAnalyzerConfigSet);
+                var newProvider = new ProjectSyntaxTreeOptionsProvider(newAnalyzerConfigSet);
                 projectInfo = projectInfo
                     .WithCompilationOptions(CompilationOptions.WithSyntaxTreeOptionsProvider(newProvider));
             }
@@ -659,7 +668,7 @@ public ProjectState RemoveDocuments(ImmutableArray<DocumentId> documentIds)
             return With(
                 projectInfo: ProjectInfo.WithVersion(Version.GetNewerVersion()),
                 documentStates: DocumentStates.RemoveRange(documentIds),
-                analyzerConfigSet: ComputeAnalyzerConfigSetValueSource(AnalyzerConfigDocumentStates));
+                analyzerConfigSet: ComputeAnalyzerConfigOptionsValueSource(AnalyzerConfigDocumentStates));
         }
 
         public ProjectState RemoveAdditionalDocuments(ImmutableArray<DocumentId> documentIds)
@@ -683,7 +692,7 @@ public ProjectState RemoveAllDocuments()
             return With(
                 projectInfo: ProjectInfo.WithVersion(Version.GetNewerVersion()),
                 documentStates: TextDocumentStates<DocumentState>.Empty,
-                analyzerConfigSet: ComputeAnalyzerConfigSetValueSource(AnalyzerConfigDocumentStates));
+                analyzerConfigSet: ComputeAnalyzerConfigOptionsValueSource(AnalyzerConfigDocumentStates));
         }
 
         public ProjectState UpdateDocument(DocumentState newDocument, bool textChanged, bool recalculateDependentVersions)
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems
index 06370cfdf8427..04e76c746cb65 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems
@@ -190,7 +190,6 @@
     <Compile Include="$(MSBuildThisFileDirectory)CodeStyle\ParenthesesPreference.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Collections\TemporaryArrayExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Collections\TemporaryArray`1.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Diagnostics\IPragmaSuppressionsAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)EditorConfig\Language.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)EditorConfig\LanguageConstants.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)EditorConfig\LanguageExtensions.cs" />
@@ -556,6 +555,10 @@
     <Compile Include="$(MSBuildThisFileDirectory)Diagnostics\DiagnosticAnalyzerCategory.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Diagnostics\DiagnosticCategory.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Diagnostics\IBuiltInAnalyzer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Diagnostics\IPragmaSuppressionsAnalyzer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)..\..\..\..\Compilers\Core\Portable\DiagnosticAnalyzer\DictionaryAnalyzerConfigOptions.cs">
+      <Link>Diagnostics\AnalyzerConfigOptionsDictionary.cs</Link>
+    </Compile>
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="$(MSBuildThisFileDirectory)CompilerExtensionsResources.resx" GenerateSource="true" Link="CompilerExtensionsResources.resx" />
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/AnalyzerConfigOptionsExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/AnalyzerConfigOptionsExtensions.cs
index 48469a64a0720..483bc0fce1a49 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/AnalyzerConfigOptionsExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/AnalyzerConfigOptionsExtensions.cs
@@ -82,7 +82,7 @@ private static bool TryGetEditorConfigOption<T>(this AnalyzerConfigOptions analy
                 hasEditorConfigStorage = true;
                 if (configStorageLocation.TryGetOption(analyzerConfigOptions, option.Type, out var objectValue))
                 {
-                    value = (T)objectValue;
+                    value = (T?)objectValue;
                     return true;
                 }
             }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Options/EditorConfig/EditorConfigStorageLocationExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Options/EditorConfig/EditorConfigStorageLocationExtensions.cs
index f87590e048d6d..a850af2038898 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Options/EditorConfig/EditorConfigStorageLocationExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Options/EditorConfig/EditorConfigStorageLocationExtensions.cs
@@ -2,25 +2,29 @@
 // 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.Reflection;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Options
 {
     internal static class EditorConfigStorageLocationExtensions
     {
-        public static bool TryGetOption(this IEditorConfigStorageLocation editorConfigStorageLocation, AnalyzerConfigOptions analyzerConfigOptions, Type type, out object value)
+        public static bool TryGetOption(this IEditorConfigStorageLocation editorConfigStorageLocation, AnalyzerConfigOptions analyzerConfigOptions, Type type, out object? value)
         {
             // This is a workaround until we have an API for enumeratings AnalyzerConfigOptions. See https://github.com/dotnet/roslyn/issues/41840
-            var backingField = analyzerConfigOptions.GetType().GetField("_backing", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
-            var backing = backingField?.GetValue(analyzerConfigOptions);
-
-            if (backing is IReadOnlyDictionary<string, string> backingDictionary)
+            if (analyzerConfigOptions.GetType().FullName == typeof(DictionaryAnalyzerConfigOptions).FullName)
             {
-                return editorConfigStorageLocation.TryGetOption(backingDictionary, type, out value);
+                var optionsField = analyzerConfigOptions.GetType().GetField(nameof(DictionaryAnalyzerConfigOptions.Options), BindingFlags.NonPublic | BindingFlags.Instance);
+                Contract.ThrowIfNull(optionsField);
+
+                var options = optionsField.GetValue(analyzerConfigOptions);
+                Contract.ThrowIfNull(options);
+
+                return editorConfigStorageLocation.TryGetOption((ImmutableDictionary<string, string?>)options, type, out value);
             }
 
             value = null;

From 74934d258a5396094ee158891323e08397430661 Mon Sep 17 00:00:00 2001
From: Chris Sienkiewicz <chsienki@microsoft.com>
Date: Wed, 12 Jan 2022 11:13:36 -0800
Subject: [PATCH 322/444] Fix metadata references declaration (#58059)

* Fix metadata references declaration
---
 src/Compilers/Core/Portable/PublicAPI.Unshipped.txt             | 2 +-
 .../Core/Portable/SourceGeneration/IncrementalContexts.cs       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
index 36028b4e8053c..aaa20ce501924 100644
--- a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
+++ b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
@@ -67,7 +67,7 @@ Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.AdditionalTexts
 Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.AnalyzerConfigOptionsProvider.get -> Microsoft.CodeAnalysis.IncrementalValueProvider<Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider!>
 Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.CompilationProvider.get -> Microsoft.CodeAnalysis.IncrementalValueProvider<Microsoft.CodeAnalysis.Compilation!>
 Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.IncrementalGeneratorInitializationContext() -> void
-Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.MetadataReferencesProvider.get -> Microsoft.CodeAnalysis.IncrementalValueProvider<Microsoft.CodeAnalysis.MetadataReference!>
+Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.MetadataReferencesProvider.get -> Microsoft.CodeAnalysis.IncrementalValuesProvider<Microsoft.CodeAnalysis.MetadataReference!>
 Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.ParseOptionsProvider.get -> Microsoft.CodeAnalysis.IncrementalValueProvider<Microsoft.CodeAnalysis.ParseOptions!>
 Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.RegisterImplementationSourceOutput<TSource>(Microsoft.CodeAnalysis.IncrementalValueProvider<TSource> source, System.Action<Microsoft.CodeAnalysis.SourceProductionContext, TSource>! action) -> void
 Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext.RegisterImplementationSourceOutput<TSource>(Microsoft.CodeAnalysis.IncrementalValuesProvider<TSource> source, System.Action<Microsoft.CodeAnalysis.SourceProductionContext, TSource>! action) -> void
diff --git a/src/Compilers/Core/Portable/SourceGeneration/IncrementalContexts.cs b/src/Compilers/Core/Portable/SourceGeneration/IncrementalContexts.cs
index db4a3acb0b814..a7978b68a651f 100644
--- a/src/Compilers/Core/Portable/SourceGeneration/IncrementalContexts.cs
+++ b/src/Compilers/Core/Portable/SourceGeneration/IncrementalContexts.cs
@@ -38,7 +38,7 @@ internal IncrementalGeneratorInitializationContext(ArrayBuilder<ISyntaxInputNode
 
         public IncrementalValueProvider<AnalyzerConfigOptionsProvider> AnalyzerConfigOptionsProvider => new IncrementalValueProvider<AnalyzerConfigOptionsProvider>(SharedInputNodes.AnalyzerConfigOptions.WithRegisterOutput(RegisterOutput).WithTrackingName(WellKnownGeneratorInputs.AnalyzerConfigOptions));
 
-        public IncrementalValueProvider<MetadataReference> MetadataReferencesProvider => new IncrementalValueProvider<MetadataReference>(SharedInputNodes.MetadataReferences.WithRegisterOutput(RegisterOutput).WithTrackingName(WellKnownGeneratorInputs.MetadataReferences));
+        public IncrementalValuesProvider<MetadataReference> MetadataReferencesProvider => new IncrementalValuesProvider<MetadataReference>(SharedInputNodes.MetadataReferences.WithRegisterOutput(RegisterOutput).WithTrackingName(WellKnownGeneratorInputs.MetadataReferences));
 
         public void RegisterSourceOutput<TSource>(IncrementalValueProvider<TSource> source, Action<SourceProductionContext, TSource> action) => RegisterSourceOutput(source.Node, action, IncrementalGeneratorOutputKind.Source, _sourceExtension);
 

From 88b3ca5fe4842ef7fc3b359e29c3ded691ce2b70 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Wed, 12 Jan 2022 11:46:05 -0800
Subject: [PATCH 323/444] Add additional test case

---
 .../RemoveUnnecessaryCastTests.cs             | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/src/Analyzers/CSharp/Tests/RemoveUnnecessaryCast/RemoveUnnecessaryCastTests.cs b/src/Analyzers/CSharp/Tests/RemoveUnnecessaryCast/RemoveUnnecessaryCastTests.cs
index baa5d6e253b4a..e456b93afccbe 100644
--- a/src/Analyzers/CSharp/Tests/RemoveUnnecessaryCast/RemoveUnnecessaryCastTests.cs
+++ b/src/Analyzers/CSharp/Tests/RemoveUnnecessaryCast/RemoveUnnecessaryCastTests.cs
@@ -12443,5 +12443,26 @@ public unsafe static implicit operator PointerDelegate<T, TResult>(delegate*<T,
                 LanguageVersion = LanguageVersion.CSharp10,
             }.RunAsync();
         }
+
+        [WorkItem(58709, "https://github.com/dotnet/roslyn/issues/58709")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryCast)]
+        public async Task NotOnNarrowingIntCastInTernary()
+        {
+            var source = @"
+class C
+{
+    protected sbyte ExtractInt8(object data)
+    {
+	    return (data is sbyte value) ? value : (sbyte)0;
+    }
+}
+";
+            await new VerifyCS.Test
+            {
+                TestCode = source,
+                FixedCode = source,
+                LanguageVersion = LanguageVersion.CSharp10,
+            }.RunAsync();
+        }
     }
 }

From 9e0e9a2f3063ea495acebda7a1f91ad26081ee1d Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Wed, 12 Jan 2022 12:07:35 -0800
Subject: [PATCH 324/444] Add tests for #37309 and #58472 (#58752)

---
 .../Semantic/Semantics/DeconstructionTests.cs | 86 +++++++++++++++++++
 .../Semantics/NullableReferenceTypesTests.cs  | 36 +++++---
 2 files changed, 109 insertions(+), 13 deletions(-)

diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/DeconstructionTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/DeconstructionTests.cs
index 9b395c870f7be..40ee9a8a34913 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/DeconstructionTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/DeconstructionTests.cs
@@ -6445,5 +6445,91 @@ class C2
                 Diagnostic(ErrorCode.ERR_DeprecatedSymbolStr, "(i, c) = new C2()").WithArguments("C.implicit operator bool(C)", "Obsolete error").WithLocation(6, 1)
                 );
         }
+
+        [Fact, WorkItem(58472, "https://github.com/dotnet/roslyn/issues/58472")]
+        public void DeconstructionIntoImplicitIndexers()
+        {
+            var source = @"
+var x = new int[1];
+C.M(x);
+
+var y = new int[1];
+C.M2(y);
+
+System.Console.Write((x[^1], y[^1]));
+
+class C
+{
+    public static void M<T>(T[] a)
+    {
+        (a[0], a[^1]) = (default, default);
+    }
+
+    public static void M2(int[] a)
+    {
+        (a[0], a[^1]) = (default, default);
+    }
+}
+";
+
+            var comp = CreateCompilationWithIndex(source);
+            // No IndexOutOfRangeException thrown
+            var verifier = CompileAndVerify(comp, expectedOutput: "(0, 0)");
+            verifier.VerifyDiagnostics();
+            verifier.VerifyIL("C.M<T>(T[])", @"
+{
+  // Code size       41 (0x29)
+  .maxstack  3
+  .locals init (T[] V_0,
+                int V_1,
+                T V_2)
+  IL_0000:  ldarg.0
+  IL_0001:  ldarg.0
+  IL_0002:  dup
+  IL_0003:  stloc.0
+  IL_0004:  ldlen
+  IL_0005:  conv.i4
+  IL_0006:  ldc.i4.1
+  IL_0007:  sub
+  IL_0008:  stloc.1
+  IL_0009:  ldc.i4.0
+  IL_000a:  ldloca.s   V_2
+  IL_000c:  initobj    ""T""
+  IL_0012:  ldloc.2
+  IL_0013:  stelem     ""T""
+  IL_0018:  ldloc.0
+  IL_0019:  ldloc.1
+  IL_001a:  ldloca.s   V_2
+  IL_001c:  initobj    ""T""
+  IL_0022:  ldloc.2
+  IL_0023:  stelem     ""T""
+  IL_0028:  ret
+}
+");
+            verifier.VerifyIL("C.M2", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  3
+  .locals init (int& V_0)
+  IL_0000:  ldarg.0
+  IL_0001:  ldc.i4.0
+  IL_0002:  ldelema    ""int""
+  IL_0007:  stloc.0
+  IL_0008:  ldarg.0
+  IL_0009:  dup
+  IL_000a:  ldlen
+  IL_000b:  conv.i4
+  IL_000c:  ldc.i4.1
+  IL_000d:  sub
+  IL_000e:  ldelema    ""int""
+  IL_0013:  ldloc.0
+  IL_0014:  ldc.i4.0
+  IL_0015:  stind.i4
+  IL_0016:  ldc.i4.0
+  IL_0017:  stind.i4
+  IL_0018:  ret
+}
+");
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
index eb347595b103e..db0cf4d79fbdc 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
@@ -10390,12 +10390,10 @@ void M()
             compilation.VerifyDiagnostics();
         }
 
-        [Fact]
+        [Fact, WorkItem(37309, "https://github.com/dotnet/roslyn/issues/37309")]
         public void NonNullTypesTrue_Foreach()
         {
             var source = @"
-
-
 class C
 {
 #nullable enable
@@ -10459,22 +10457,34 @@ public void M2()
 
             compilation.VerifyTypes();
             compilation.VerifyDiagnostics(
-                // (60,11): warning CS8632: The annotation for nullable reference types should only be used in code within a '#nullable' context.
+                // (58,11): warning CS8632: The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
                 //     string?[] FalseNCollection() => throw null!; // 5
-                Diagnostic(ErrorCode.WRN_MissingNonNullTypesContextForAnnotation, "?").WithLocation(60, 11),
-                // (16,13): warning CS8602: Dereference of a possibly null reference.
+                Diagnostic(ErrorCode.WRN_MissingNonNullTypesContextForAnnotation, "?").WithLocation(58, 11),
+                // (14,13): warning CS8602: Dereference of a possibly null reference.
                 //             ns /*T:string?*/ .ToString(); // 1
-                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "ns").WithLocation(16, 13),
-                // (26,13): warning CS8602: Dereference of a possibly null reference.
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "ns").WithLocation(14, 13),
+                // (24,13): warning CS8602: Dereference of a possibly null reference.
                 //             ns1 /*T:string?*/ .ToString(); // 2
-                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "ns1").WithLocation(26, 13),
-                // (36,13): warning CS8602: Dereference of a possibly null reference.
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "ns1").WithLocation(24, 13),
+                // (34,13): warning CS8602: Dereference of a possibly null reference.
                 //             ns /*T:string?*/ .ToString(); // 3
-                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "ns").WithLocation(36, 13),
-                // (46,13): warning CS8602: Dereference of a possibly null reference.
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "ns").WithLocation(34, 13),
+                // (44,13): warning CS8602: Dereference of a possibly null reference.
                 //             ns1 /*T:string?*/ .ToString(); // 4
-                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "ns1").WithLocation(46, 13)
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "ns1").WithLocation(44, 13)
                 );
+
+            var tree = compilation.SyntaxTrees.Single();
+            var model = compilation.GetSemanticModel(tree);
+            var foreachSyntax = tree.GetRoot().DescendantNodes().OfType<ForEachStatementSyntax>().ToArray();
+
+            var type1 = foreachSyntax[0].Type;
+            Assert.Equal("string", type1.ToString());
+            Assert.Equal("System.String!", model.GetTypeInfo(type1).Type.ToTestDisplayString(includeNonNullable: true));
+
+            var type2 = foreachSyntax[1].Type;
+            Assert.Equal("string?", type2.ToString());
+            Assert.Equal("System.String?", model.GetTypeInfo(type2).Type.ToTestDisplayString(includeNonNullable: true));
         }
 
         [WorkItem(30840, "https://github.com/dotnet/roslyn/issues/30840")]

From 0260c2487903a41184f3e6d102c5b353f7b7d961 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, 12 Jan 2022 13:25:35 -0800
Subject: [PATCH 325/444] Remove contract check to avoid crash (#58675)

* Remove contract check to avoid crash

* Feedback

* Report NFW
---
 .../Options/LanguageSettingsPersister.cs      | 50 +++++++++++++------
 1 file changed, 34 insertions(+), 16 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/Options/LanguageSettingsPersister.cs b/src/VisualStudio/Core/Def/Implementation/Options/LanguageSettingsPersister.cs
index 0563c5621c7ce..79d4f7658486b 100644
--- a/src/VisualStudio/Core/Def/Implementation/Options/LanguageSettingsPersister.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Options/LanguageSettingsPersister.cs
@@ -12,6 +12,7 @@
 using Microsoft.CodeAnalysis.Completion;
 using Microsoft.CodeAnalysis.Editor.Options;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.VisualStudio.LanguageServices.Setup;
@@ -56,25 +57,32 @@ public LanguageSettingsPersister(
             _textManager = textManager;
             _optionService = optionService;
 
-            // TODO: make this configurable
-            _languageMap = BidirectionalMap<string, Tuple<Guid>>.Empty.Add(LanguageNames.CSharp, Tuple.Create(Guids.CSharpLanguageServiceId))
-                                                               .Add(LanguageNames.VisualBasic, Tuple.Create(Guids.VisualBasicLanguageServiceId))
-                                                               .Add(InternalLanguageNames.TypeScript, Tuple.Create(new Guid("4a0dddb5-7a95-4fbf-97cc-616d07737a77")))
-                                                               .Add("F#", Tuple.Create(new Guid("BC6DD5A5-D4D6-4dab-A00D-A51242DBAF1B")))
-                                                               .Add("Xaml", Tuple.Create(new Guid("CD53C9A1-6BC2-412B-BE36-CC715ED8DD41")));
+            var languageMap = BidirectionalMap<string, Tuple<Guid>>.Empty;
 
-            foreach (var languageGuid in _languageMap.Values)
+            InitializeSettingsForLanguage(LanguageNames.CSharp, Guids.CSharpLanguageServiceId);
+            InitializeSettingsForLanguage(LanguageNames.VisualBasic, Guids.VisualBasicLanguageServiceId);
+            InitializeSettingsForLanguage(InternalLanguageNames.TypeScript, new Guid("4a0dddb5-7a95-4fbf-97cc-616d07737a77"));
+            InitializeSettingsForLanguage("F#", new Guid("BC6DD5A5-D4D6-4dab-A00D-A51242DBAF1B"));
+            InitializeSettingsForLanguage("Xaml", new Guid("CD53C9A1-6BC2-412B-BE36-CC715ED8DD41"));
+
+            void InitializeSettingsForLanguage(string languageName, Guid languageGuid)
             {
                 var languagePreferences = new LANGPREFERENCES3[1];
-                languagePreferences[0].guidLang = languageGuid.Item1;
+                languagePreferences[0].guidLang = languageGuid;
 
                 // The function can potentially fail if that language service isn't installed
                 if (ErrorHandler.Succeeded(_textManager.GetUserPreferences4(pViewPrefs: null, pLangPrefs: languagePreferences, pColorPrefs: null)))
                 {
-                    RefreshLanguageSettings(languagePreferences);
+                    RefreshLanguageSettings(languagePreferences, languageName);
+                    languageMap = languageMap.Add(languageName, Tuple.Create(languageGuid));
+                }
+                else
+                {
+                    FatalError.ReportWithDumpAndCatch(new InvalidOperationException("GetUserPreferences4 failed"), ErrorSeverity.Diagnostic);
                 }
             }
 
+            _languageMap = languageMap;
             _textManagerEvents2Sink = ComEventSink.Advise<IVsTextManagerEvents4>(_textManager, this);
         }
 
@@ -108,13 +116,20 @@ private void RefreshLanguageSettings(LANGPREFERENCES3[] langPrefs)
             this.AssertIsForeground();
             if (_languageMap.TryGetKey(Tuple.Create(langPrefs[0].guidLang), out var languageName))
             {
-                foreach (var option in _supportedOptions)
-                {
-                    var keyWithLanguage = new OptionKey(option, languageName);
-                    var newValue = GetValueForOption(option, langPrefs[0]);
+                RefreshLanguageSettings(langPrefs, languageName);
+            }
+        }
 
-                    _optionService.RefreshOption(keyWithLanguage, newValue);
-                }
+        private void RefreshLanguageSettings(LANGPREFERENCES3[] langPrefs, string languageName)
+        {
+            this.AssertIsForeground();
+
+            foreach (var option in _supportedOptions)
+            {
+                var keyWithLanguage = new OptionKey(option, languageName);
+                var newValue = GetValueForOption(option, langPrefs[0]);
+
+                _optionService.RefreshOption(keyWithLanguage, newValue);
             }
         }
 
@@ -222,7 +237,10 @@ public bool TryFetch(OptionKey optionKey, out object value)
             // This particular serializer is a bit strange, since we have to initially read things out on the UI thread.
             // Therefore, we refresh the values in the constructor, meaning that this should never get called for our values.
 
-            Contract.ThrowIfTrue(_supportedOptions.Contains(optionKey.Option) && _languageMap.ContainsKey(optionKey.Language));
+            if (_supportedOptions.Contains(optionKey.Option) && _languageMap.ContainsKey(optionKey.Language))
+            {
+                FatalError.ReportWithDumpAndCatch(new InvalidOperationException("Unexpected call to " + nameof(LanguageSettingsPersister) + "." + nameof(TryFetch)), ErrorSeverity.Diagnostic);
+            }
 
             value = null;
             return false;

From 61e507e94403c53f59269d9cc107f9301479785b Mon Sep 17 00:00:00 2001
From: Andrew Hall <andrha@microsoft.com>
Date: Wed, 12 Jan 2022 16:16:31 -0800
Subject: [PATCH 326/444] Handle more stack frames (#58769)

This adds support for local functions and generated main in the parser.

Symbol resolution now is broken up into resolvers and has special logic for local functions, getters/setters, and ordinary functions.
---
 .../AbstractStackTraceSymbolResolver.cs       | 119 ++++++++++++++
 .../StackFrameLocalMethodResolver.cs          |  46 ++++++
 .../StackFrameMethodSymbolResolver.cs         |  34 ++++
 .../StackTraceExplorerUtilities.cs            | 128 +++------------
 .../StackFrameParserTests.Utilities.cs        |   6 +
 .../StackFrame/StackFrameParserTests.cs       |  26 +++
 .../StackFrame/StackFrameSyntaxFactory.cs     |  13 ++
 .../StackTraceExplorerTests.cs                | 155 +++++++++++++++++-
 .../StackFrame/IStackFrameNodeVisitor.cs      |   2 +
 .../StackFrame/StackFrameKind.cs              |   6 +
 .../StackFrame/StackFrameLexer.cs             |  66 +++++++-
 .../StackFrame/StackFrameNodeDefinitions.cs   | 101 +++++++++++-
 .../StackFrame/StackFrameParser.cs            | 108 +++++++++++-
 .../SemanticFacts/CSharpSemanticFacts.cs      |  22 +++
 .../Common/EmbeddedSyntaxToken.cs             |   4 +-
 .../Core/Extensions/ITypeSymbolExtensions.cs  |   3 +
 .../Services/SemanticFacts/ISemanticFacts.cs  |   5 +
 .../SemanticFacts/VisualBasicSemanticFacts.vb |   4 +
 .../AbstractSemanticFactsService.cs           |   3 +
 19 files changed, 733 insertions(+), 118 deletions(-)
 create mode 100644 src/EditorFeatures/Core/StackTraceExplorer/AbstractStackTraceSymbolResolver.cs
 create mode 100644 src/EditorFeatures/Core/StackTraceExplorer/StackFrameLocalMethodResolver.cs
 create mode 100644 src/EditorFeatures/Core/StackTraceExplorer/StackFrameMethodSymbolResolver.cs

diff --git a/src/EditorFeatures/Core/StackTraceExplorer/AbstractStackTraceSymbolResolver.cs b/src/EditorFeatures/Core/StackTraceExplorer/AbstractStackTraceSymbolResolver.cs
new file mode 100644
index 0000000000000..f6559bbc1ff5b
--- /dev/null
+++ b/src/EditorFeatures/Core/StackTraceExplorer/AbstractStackTraceSymbolResolver.cs
@@ -0,0 +1,119 @@
+// 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.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Editor.StackTraceExplorer;
+using Microsoft.CodeAnalysis.EmbeddedLanguages.StackFrame;
+using Microsoft.CodeAnalysis.LanguageServices;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+
+namespace Microsoft.CodeAnalysis.Editor.StackTraceExplorer
+{
+    internal abstract class AbstractStackTraceSymbolResolver
+    {
+        public abstract Task<IMethodSymbol?> TryGetBestMatchAsync(
+            Project project,
+            INamedTypeSymbol type,
+            StackFrameSimpleNameNode methodNode,
+            StackFrameParameterList methodArguments,
+            StackFrameTypeArgumentList? methodTypeArguments,
+            CancellationToken cancellationToken);
+
+        protected static bool MatchTypeArguments(ImmutableArray<ITypeSymbol> typeArguments, StackFrameTypeArgumentList? stackFrameTypeArgumentList)
+        {
+            if (stackFrameTypeArgumentList is null)
+            {
+                return typeArguments.IsEmpty;
+            }
+
+            if (typeArguments.IsEmpty)
+            {
+                return false;
+            }
+
+            var stackFrameTypeArguments = stackFrameTypeArgumentList.TypeArguments;
+            return typeArguments.Length == stackFrameTypeArguments.Length;
+        }
+
+        protected static bool MatchType(ITypeSymbol type, StackFrameTypeNode stackFrameType)
+        {
+            if (type is IArrayTypeSymbol arrayType)
+            {
+                if (stackFrameType is not StackFrameArrayTypeNode arrayTypeNode)
+                {
+                    return false;
+                }
+
+                ITypeSymbol currentType = arrayType;
+
+                // Iterate through each array expression and make sure the dimensions
+                // match the element types in an array.
+                // Ex: string[,][] 
+                // [,] is a 2 dimension array with element type string[]
+                // [] is a 1 dimension array with element type string
+                foreach (var arrayExpression in arrayTypeNode.ArrayRankSpecifiers)
+                {
+                    if (currentType is not IArrayTypeSymbol currentArrayType)
+                    {
+                        return false;
+                    }
+
+                    if (currentArrayType.Rank != arrayExpression.CommaTokens.Length + 1)
+                    {
+                        return false;
+                    }
+
+                    currentType = currentArrayType.ElementType;
+                }
+
+                // All array types have been exchausted from the
+                // stackframe identifier and the type is still an array
+                if (currentType is IArrayTypeSymbol)
+                {
+                    return false;
+                }
+
+                return MatchType(currentType, arrayTypeNode.TypeIdentifier);
+            }
+
+            return type.Name == stackFrameType.ToString();
+        }
+
+        protected static bool MatchParameters(ImmutableArray<IParameterSymbol> parameters, StackFrameParameterList stackFrameParameters)
+        {
+            if (parameters.Length != stackFrameParameters.Parameters.Length)
+            {
+                return false;
+            }
+
+            for (var i = 0; i < stackFrameParameters.Parameters.Length; i++)
+            {
+                var stackFrameParameter = stackFrameParameters.Parameters[i];
+                var paramSymbol = parameters[i];
+
+                if (paramSymbol.Name != stackFrameParameter.Identifier.ToString())
+                {
+                    return false;
+                }
+
+                if (!MatchType(paramSymbol.Type, stackFrameParameter.Type))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        protected static IMethodSymbol? TryGetBestMatch(ImmutableArray<IMethodSymbol> candidateFunctions,
+            StackFrameTypeArgumentList? methodTypeArguments,
+            StackFrameParameterList methodArguments)
+            => candidateFunctions
+                .Where(m => MatchTypeArguments(m.TypeArguments, methodTypeArguments))
+                .FirstOrDefault(m => MatchParameters(m.Parameters, methodArguments));
+    }
+}
diff --git a/src/EditorFeatures/Core/StackTraceExplorer/StackFrameLocalMethodResolver.cs b/src/EditorFeatures/Core/StackTraceExplorer/StackFrameLocalMethodResolver.cs
new file mode 100644
index 0000000000000..324939154040b
--- /dev/null
+++ b/src/EditorFeatures/Core/StackTraceExplorer/StackFrameLocalMethodResolver.cs
@@ -0,0 +1,46 @@
+// 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.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.EmbeddedLanguages.StackFrame;
+using Microsoft.CodeAnalysis.LanguageServices;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+
+namespace Microsoft.CodeAnalysis.Editor.StackTraceExplorer
+{
+    internal class StackFrameLocalMethodResolver : AbstractStackTraceSymbolResolver
+    {
+        public override async Task<IMethodSymbol?> TryGetBestMatchAsync(
+            Project project,
+            INamedTypeSymbol type,
+            StackFrameSimpleNameNode methodNode,
+            StackFrameParameterList methodArguments,
+            StackFrameTypeArgumentList? methodTypeArguments,
+            CancellationToken cancellationToken)
+        {
+            if (methodNode is not StackFrameLocalMethodNameNode localMethodNameNode)
+            {
+                return null;
+            }
+
+            var compilation = await project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
+            if (compilation is null)
+            {
+                return null;
+            }
+
+            var containingMethodName = localMethodNameNode.EncapsulatingMethod.Identifier.ToString();
+            var semanticFacts = project.GetRequiredLanguageService<ISemanticFactsService>();
+            var candidateFunctions = type.GetMembers()
+                .Where(member => member.Name == containingMethodName)
+                .SelectMany(member => semanticFacts.GetLocalFunctionSymbols(compilation, member, cancellationToken))
+                .ToImmutableArray();
+
+            return TryGetBestMatch(candidateFunctions, methodTypeArguments, methodArguments);
+        }
+    }
+}
diff --git a/src/EditorFeatures/Core/StackTraceExplorer/StackFrameMethodSymbolResolver.cs b/src/EditorFeatures/Core/StackTraceExplorer/StackFrameMethodSymbolResolver.cs
new file mode 100644
index 0000000000000..e21230f404fde
--- /dev/null
+++ b/src/EditorFeatures/Core/StackTraceExplorer/StackFrameMethodSymbolResolver.cs
@@ -0,0 +1,34 @@
+// 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.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.EmbeddedLanguages.StackFrame;
+
+namespace Microsoft.CodeAnalysis.Editor.StackTraceExplorer
+{
+    internal class StackFrameMethodSymbolResolver : AbstractStackTraceSymbolResolver
+    {
+        public override Task<IMethodSymbol?> TryGetBestMatchAsync(Project project,
+            INamedTypeSymbol type,
+            StackFrameSimpleNameNode methodNode,
+            StackFrameParameterList methodArguments,
+            StackFrameTypeArgumentList? methodTypeArguments,
+            CancellationToken cancellationToken)
+        {
+            var methodName = methodNode.ToString();
+
+            var candidateMethods = type
+                .GetMembers()
+                .OfType<IMethodSymbol>()
+                .Where(m => m.Name == methodName)
+                .ToImmutableArray();
+
+            var match = TryGetBestMatch(candidateMethods, methodTypeArguments, methodArguments);
+            return Task.FromResult(match);
+        }
+    }
+}
diff --git a/src/EditorFeatures/Core/StackTraceExplorer/StackTraceExplorerUtilities.cs b/src/EditorFeatures/Core/StackTraceExplorer/StackTraceExplorerUtilities.cs
index 935901ca01365..1c37bc50159ff 100644
--- a/src/EditorFeatures/Core/StackTraceExplorer/StackTraceExplorerUtilities.cs
+++ b/src/EditorFeatures/Core/StackTraceExplorer/StackTraceExplorerUtilities.cs
@@ -2,8 +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.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor.FindUsages;
@@ -17,6 +15,13 @@ namespace Microsoft.CodeAnalysis.Editor.StackTraceExplorer
 {
     internal static class StackTraceExplorerUtilities
     {
+        // Order is important here. Resolution should happen from most specific to least specific. 
+        private static readonly AbstractStackTraceSymbolResolver[] _resolvers = new AbstractStackTraceSymbolResolver[]
+            {
+                new StackFrameLocalMethodResolver(),
+                new StackFrameMethodSymbolResolver(),
+            };
+
         public static async Task<DefinitionItem?> GetDefinitionAsync(Solution solution, StackFrameCompilationUnit compilationUnit, StackFrameSymbolPart symbolPart, CancellationToken cancellationToken)
         {
             // MemberAccessExpression is [Expression].[Identifier], and Identifier is the 
@@ -33,12 +38,10 @@ internal static class StackTraceExplorerUtilities
 
             RoslynDebug.AssertNotNull(fullyQualifiedTypeName);
 
-            var methodIdentifier = compilationUnit.MethodDeclaration.MemberAccessExpression.Right;
+            var methodNode = compilationUnit.MethodDeclaration.MemberAccessExpression.Right;
             var methodTypeArguments = compilationUnit.MethodDeclaration.TypeArguments;
             var methodArguments = compilationUnit.MethodDeclaration.ArgumentList;
 
-            var methodName = methodIdentifier.ToString();
-
             //
             // Do a first pass to find projects with the type name to check first 
             //
@@ -57,10 +60,10 @@ internal static class StackTraceExplorerUtilities
 
                 if (containsSymbol)
                 {
-                    var matchingMethods = await GetMatchingMembersFromCompilationAsync(project).ConfigureAwait(false);
-                    if (matchingMethods.Any())
+                    var method = await TryGetBestMatchAsync(project, fullyQualifiedTypeName, methodNode, methodArguments, methodTypeArguments, cancellationToken).ConfigureAwait(false);
+                    if (method is not null)
                     {
-                        return await GetDefinitionAsync(matchingMethods[0]).ConfigureAwait(false);
+                        return await GetDefinitionAsync(method).ConfigureAwait(false);
                     }
                 }
                 else
@@ -75,10 +78,10 @@ internal static class StackTraceExplorerUtilities
             //
             foreach (var project in candidateProjects)
             {
-                var matchingMethods = await GetMatchingMembersFromCompilationAsync(project).ConfigureAwait(false);
-                if (matchingMethods.Any())
+                var method = await TryGetBestMatchAsync(project, fullyQualifiedTypeName, methodNode, methodArguments, methodTypeArguments, cancellationToken).ConfigureAwait(false);
+                if (method is not null)
                 {
-                    return await GetDefinitionAsync(matchingMethods[0]).ConfigureAwait(false);
+                    return await GetDefinitionAsync(method).ConfigureAwait(false);
                 }
             }
 
@@ -88,24 +91,6 @@ internal static class StackTraceExplorerUtilities
             // Local Functions
             //
 
-            async Task<ImmutableArray<IMethodSymbol>> GetMatchingMembersFromCompilationAsync(Project project)
-            {
-                var compilation = await project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);
-                var type = compilation.GetTypeByMetadataName(fullyQualifiedTypeName);
-                if (type is null)
-                {
-                    return ImmutableArray<IMethodSymbol>.Empty;
-                }
-
-                var members = type.GetMembers();
-                return members
-                    .OfType<IMethodSymbol>()
-                    .Where(m => m.Name == methodName)
-                    .Where(m => MatchTypeArguments(m.TypeArguments, methodTypeArguments))
-                    .Where(m => MatchParameters(m.Parameters, methodArguments))
-                    .ToImmutableArrayOrEmpty();
-            }
-
             Task<DefinitionItem> GetDefinitionAsync(IMethodSymbol method)
             {
                 ISymbol symbol = method;
@@ -118,90 +103,25 @@ Task<DefinitionItem> GetDefinitionAsync(IMethodSymbol method)
             }
         }
 
-        private static bool MatchParameters(ImmutableArray<IParameterSymbol> parameters, StackFrameParameterList stackFrameParameters)
+        private static async Task<IMethodSymbol?> TryGetBestMatchAsync(Project project, string fullyQualifiedTypeName, StackFrameSimpleNameNode methodNode, StackFrameParameterList methodArguments, StackFrameTypeArgumentList? methodTypeArguments, CancellationToken cancellationToken)
         {
-            if (parameters.Length != stackFrameParameters.Parameters.Length)
+            var compilation = await project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);
+            var type = compilation.GetTypeByMetadataName(fullyQualifiedTypeName);
+            if (type is null)
             {
-                return false;
+                return null;
             }
 
-            for (var i = 0; i < stackFrameParameters.Parameters.Length; i++)
+            foreach (var resolver in _resolvers)
             {
-                var stackFrameParameter = stackFrameParameters.Parameters[i];
-                var paramSymbol = parameters[i];
-
-                if (paramSymbol.Name != stackFrameParameter.Identifier.ToString())
+                var matchingMethod = await resolver.TryGetBestMatchAsync(project, type, methodNode, methodArguments, methodTypeArguments, cancellationToken).ConfigureAwait(false);
+                if (matchingMethod is not null)
                 {
-                    return false;
-                }
-
-                if (!MatchType(paramSymbol.Type, stackFrameParameter.Type))
-                {
-                    return false;
+                    return matchingMethod;
                 }
             }
 
-            return true;
-        }
-
-        private static bool MatchTypeArguments(ImmutableArray<ITypeSymbol> typeArguments, StackFrameTypeArgumentList? stackFrameTypeArgumentList)
-        {
-            if (stackFrameTypeArgumentList is null)
-            {
-                return typeArguments.IsEmpty;
-            }
-
-            if (typeArguments.IsEmpty)
-            {
-                return false;
-            }
-
-            var stackFrameTypeArguments = stackFrameTypeArgumentList.TypeArguments;
-            return typeArguments.Length == stackFrameTypeArguments.Length;
-        }
-
-        private static bool MatchType(ITypeSymbol type, StackFrameTypeNode stackFrameType)
-        {
-            if (type is IArrayTypeSymbol arrayType)
-            {
-                if (stackFrameType is not StackFrameArrayTypeNode arrayTypeNode)
-                {
-                    return false;
-                }
-
-                ITypeSymbol currentType = arrayType;
-
-                // Iterate through each array expression and make sure the dimensions
-                // match the element types in an array.
-                // Ex: string[,][] 
-                // [,] is a 2 dimension array with element type string[]
-                // [] is a 1 dimension array with element type string
-                foreach (var arrayExpression in arrayTypeNode.ArrayRankSpecifiers)
-                {
-                    if (currentType is not IArrayTypeSymbol currentArrayType)
-                    {
-                        return false;
-                    }
-
-                    if (currentArrayType.Rank != arrayExpression.CommaTokens.Length + 1)
-                    {
-                        return false;
-                    }
-
-                    currentType = currentArrayType.ElementType;
-                }
-
-                // All array types have been exchausted from the
-                // stackframe identifier and the type is still an array
-                if (currentType is IArrayTypeSymbol)
-                {
-                    return false;
-                }
-
-                return MatchType(currentType, arrayTypeNode.TypeIdentifier);
-            }
-
-            return type.Name == stackFrameType.ToString();
+            return null;
         }
     }
 }
diff --git a/src/EditorFeatures/Test/EmbeddedLanguages/StackFrame/StackFrameParserTests.Utilities.cs b/src/EditorFeatures/Test/EmbeddedLanguages/StackFrame/StackFrameParserTests.Utilities.cs
index a632795add9dc..bfcab7c530a2e 100644
--- a/src/EditorFeatures/Test/EmbeddedLanguages/StackFrame/StackFrameParserTests.Utilities.cs
+++ b/src/EditorFeatures/Test/EmbeddedLanguages/StackFrame/StackFrameParserTests.Utilities.cs
@@ -86,6 +86,12 @@ private static void FuzzyTest(string input)
 
         private static void VerifyCharacterSpans(string originalText, StackFrameTree tree)
         {
+            AssertEx.EqualOrDiff(originalText, tree.Root.ToFullString());
+
+            // Manually enumerate to verify that it works as expected and the spans align.
+            // This should be the same as ToFullString, but this tests that enumeration of the 
+            // tokens yields the correct order (which we can't guarantee with ToFullString depending
+            // on implementation). 
             var textSeq = VirtualCharSequence.Create(0, originalText);
             var index = 0;
             List<VirtualChar> enumeratedParsedCharacters = new();
diff --git a/src/EditorFeatures/Test/EmbeddedLanguages/StackFrame/StackFrameParserTests.cs b/src/EditorFeatures/Test/EmbeddedLanguages/StackFrame/StackFrameParserTests.cs
index 666f56a11c4b0..fe234fa4bfa12 100644
--- a/src/EditorFeatures/Test/EmbeddedLanguages/StackFrame/StackFrameParserTests.cs
+++ b/src/EditorFeatures/Test/EmbeddedLanguages/StackFrame/StackFrameParserTests.cs
@@ -439,5 +439,31 @@ public void TestKeywordsAsIdentifiers(string keyword)
                             Identifier(keyword.Trim()),
                             IdentifierToken(keyword.Trim(), leadingTrivia: SpaceTrivia(2), trailingTrivia: SpaceTrivia()))))
                 );
+
+        [Fact]
+        public void TestGeneratedMain()
+            => Verify(@"Program.<Main>$(String[] args)",
+                methodDeclaration: MethodDeclaration(
+                    QualifiedName(
+                        Identifier("Program"),
+                        GeneratedName("Main")),
+                    argumentList: ParameterList(
+                            Parameter(ArrayType(Identifier("String"), ArrayRankSpecifier(trailingTrivia: SpaceTrivia())),
+                            IdentifierToken("args")))
+                    )
+                );
+
+        [Fact]
+        public void TestLocalMethod()
+            => Verify(@"C.<M>g__Local|0_0()",
+                methodDeclaration: MethodDeclaration(
+                    QualifiedName(
+                        Identifier("C"),
+                        LocalMethod(
+                            GeneratedName("M", endWithDollar: false),
+                            "Local",
+                            "0_0"))
+                    )
+                );
     }
 }
diff --git a/src/EditorFeatures/Test/EmbeddedLanguages/StackFrame/StackFrameSyntaxFactory.cs b/src/EditorFeatures/Test/EmbeddedLanguages/StackFrame/StackFrameSyntaxFactory.cs
index 8830e4ae412b4..58418c82bd2bd 100644
--- a/src/EditorFeatures/Test/EmbeddedLanguages/StackFrame/StackFrameSyntaxFactory.cs
+++ b/src/EditorFeatures/Test/EmbeddedLanguages/StackFrame/StackFrameSyntaxFactory.cs
@@ -44,6 +44,8 @@ public static ImmutableArray<StackFrameTrivia> CreateTriviaArray(params string[]
         public static readonly StackFrameToken GraveAccentToken = CreateToken(StackFrameKind.GraveAccentToken, "`");
         public static readonly StackFrameToken EOLToken = CreateToken(StackFrameKind.EndOfFrame, "");
         public static readonly StackFrameToken ColonToken = CreateToken(StackFrameKind.ColonToken, ":");
+        public static readonly StackFrameToken DollarToken = CreateToken(StackFrameKind.DollarToken, "$");
+        public static readonly StackFrameToken PipeToken = CreateToken(StackFrameKind.PipeToken, "|");
 
         public static readonly StackFrameTrivia AtTrivia = CreateTrivia(StackFrameKind.AtTrivia, "at ");
         public static readonly StackFrameTrivia LineTrivia = CreateTrivia(StackFrameKind.LineTrivia, "line ");
@@ -88,6 +90,9 @@ public static StackFrameMethodDeclarationNode MethodDeclaration(
             return new StackFrameMethodDeclarationNode(memberAccessExpression, typeArguments, argumentList ?? ParameterList(OpenParenToken, CloseParenToken));
         }
 
+        public static StackFrameGeneratedMethodNameNode GeneratedName(string name, bool endWithDollar = true)
+            => new(LessThanToken, IdentifierToken(name), GreaterThanToken, endWithDollar ? DollarToken : null);
+
         public static StackFrameQualifiedNameNode QualifiedName(string s, StackFrameTrivia? leadingTrivia = null, StackFrameTrivia? trailingTrivia = null)
             => QualifiedName(s, leadingTrivia.ToImmutableArray(), trailingTrivia.ToImmutableArray());
 
@@ -199,5 +204,13 @@ public static StackFrameToken Path(string path)
 
         public static StackFrameToken Line(int lineNumber)
             => CreateToken(StackFrameKind.NumberToken, lineNumber.ToString(), leadingTrivia: ImmutableArray.Create(LineTrivia));
+
+        public static StackFrameLocalMethodNameNode LocalMethod(StackFrameGeneratedMethodNameNode encapsulatingMethod, string identifier, string suffix)
+            => new(
+                encapsulatingMethod,
+                CreateToken(StackFrameKind.GeneratedNameSeparatorToken, "g__"),
+                IdentifierToken(identifier),
+                PipeToken,
+                CreateToken(StackFrameKind.GeneratedNameSuffixToken, suffix));
     }
 }
diff --git a/src/EditorFeatures/Test/StackTraceExplorer/StackTraceExplorerTests.cs b/src/EditorFeatures/Test/StackTraceExplorer/StackTraceExplorerTests.cs
index ec43226c9a684..b34d85366d5c1 100644
--- a/src/EditorFeatures/Test/StackTraceExplorer/StackTraceExplorerTests.cs
+++ b/src/EditorFeatures/Test/StackTraceExplorer/StackTraceExplorerTests.cs
@@ -508,7 +508,7 @@ async Task DoThingAsync()
 }");
         }
 
-        [Fact(Skip = "Generated types/methods are not supported")]
+        [Fact]
         public Task TestSymbolFound_ExceptionLine_PropertySet()
         {
             return TestSymbolFoundAsync(
@@ -528,11 +528,11 @@ public int I
 }");
         }
 
-        [Fact(Skip = "Generated types/methods are not supported")]
+        [Fact]
         public Task TestSymbolFound_ExceptionLine_PropertyGet()
         {
             return TestSymbolFoundAsync(
-                @"at ConsoleApp4.MyClass.get_I(Int32 value)",
+                @"at ConsoleApp4.MyClass.get_I()",
                 @"using System;
 
 namespace ConsoleApp4
@@ -548,7 +548,7 @@ public int I
 }");
         }
 
-        [Fact(Skip = "Generated types/methods are not supported")]
+        [Fact]
         public Task TestSymbolFound_ExceptionLine_IndexerSet()
         {
             return TestSymbolFoundAsync(
@@ -568,7 +568,7 @@ public int this[int i]
 }");
         }
 
-        [Fact(Skip = "Generated types/methods are not supported")]
+        [Fact]
         public Task TestSymbolFound_ExceptionLine_IndexerGet()
         {
             return TestSymbolFoundAsync(
@@ -588,7 +588,7 @@ public int this[int i]
 }");
         }
 
-        [Fact(Skip = "Generated types/methods are not supported")]
+        [Fact]
         public Task TestSymbolFound_ExceptionLine_LocalFunction()
         {
             return TestSymbolFoundAsync(
@@ -603,6 +603,44 @@ public void M()
         {
             LocalFunction();
 
+            void [|LocalFunction|]()
+            {
+                throw new Exception();
+            }
+        }
+
+        public void LocalFunction()
+        {
+        }
+    }
+}");
+        }
+
+        [Fact]
+        public Task TestSymbolFound_ExceptionLine_MultipleLocalFunctions()
+        {
+            return TestSymbolFoundAsync(
+                @"at ConsoleApp4.MyClass.<M>g__LocalFunction|0_0()",
+                @"using System;
+
+namespace ConsoleApp4
+{
+    class MyClass
+    {
+        public void M()
+        {
+            LocalFunction();
+
+            void [|LocalFunction|]()
+            {
+                throw new Exception();
+            }
+        }
+
+        public void M2()
+        {
+            LocalFunction();
+
             void LocalFunction()
             {
                 throw new Exception();
@@ -612,14 +650,113 @@ void LocalFunction()
 }");
         }
 
-        [Fact(Skip = "Generated types/methods are not supported")]
+        [Fact]
+        public Task TestSymbolFound_ExceptionLine_MultipleLocalFunctions2()
+        {
+            return TestSymbolFoundAsync(
+                @"at ConsoleApp4.MyClass.<M2>g__LocalFunction|0_0()",
+                @"using System;
+
+namespace ConsoleApp4
+{
+    class MyClass
+    {
+        public void M()
+        {
+            LocalFunction();
+
+            void LocalFunction()
+            {
+                throw new Exception();
+            }
+        }
+
+        public void M2()
+        {
+            LocalFunction();
+
+            void [|LocalFunction()|]
+            {
+                throw new Exception();
+            }
+        }
+    }
+}");
+        }
+
+        [Fact]
+        public Task TestSymbolFound_ExceptionLine_MemberFunctionSameNameAsFunction()
+        {
+            return TestSymbolFoundAsync(
+                @"at ConsoleApp4.MyClass.LocalFunction()",
+                @"using System;
+
+namespace ConsoleApp4
+{
+    class MyClass
+    {
+        public void M()
+        {
+            LocalFunction();
+
+            void LocalFunction()
+            {
+                throw new Exception();
+            }
+        }
+
+        public void [|LocalFunction|]()
+        {
+        }
+    }
+}");
+        }
+
+        /// <summary>
+        /// Behavior for this test needs some explanation. Note that if there are multiple
+        /// local functions within a container, they will be uniquely identified by the 
+        /// suffix. In this case we have g__Local|0_0 and g__Local|0_1 as the two local functions.
+        /// Resolution doesn't try to reverse engineer how these suffixes get produced, which means
+        /// that the first applicable symbol with the name "Local" inside the method "M" will be found.
+        /// Since local function resolution is done by searching the descendents of the method "M", the top
+        /// most local function matching the name will be the first the resolver sees and considers applicable.
+        /// This should get the user close to what they want, and hopefully is rare enough that it won't
+        /// be frequently encountered. 
+        /// </summary>
+        [Fact]
+        public Task TestSymbolFound_ExceptionLine_NestedLocalFunctions()
+        {
+            return TestSymbolFoundAsync(
+                @"at C.<M>g__Local|0_1()",
+                @"using System;
+
+class C 
+{
+    public void M()
+    {
+        Local();
+        
+        void [|Local|]()
+        {
+            Local();
+            
+            void Local()
+            {
+                throw new Exception();
+            }
+        }
+    }
+}");
+        }
+
+        [Fact(Skip = "Top level local functions are not supported")]
         public Task TestSymbolFound_ExceptionLine_LocalInTopLevelStatement()
         {
             return TestSymbolFoundAsync(
-                @"at ConsoleApp4.MyClass.<M>g__LocalFunction|0_0()",
+                @"at ConsoleApp4.Program.<Main$>g__LocalInTopLevelStatement|0_0()",
                 @"using System;
 
-LoaclInTopLevelStatement();
+LocalInTopLevelStatement();
 
 void [|LocalInTopLevelStatement|]()
 {
diff --git a/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/IStackFrameNodeVisitor.cs b/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/IStackFrameNodeVisitor.cs
index fa948cc6e9bae..7ecfe93be1726 100644
--- a/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/IStackFrameNodeVisitor.cs
+++ b/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/IStackFrameNodeVisitor.cs
@@ -17,5 +17,7 @@ internal interface IStackFrameNodeVisitor
         void Visit(StackFrameFileInformationNode node);
         void Visit(StackFrameArrayTypeNode node);
         void Visit(StackFrameParameterDeclarationNode node);
+        void Visit(StackFrameGeneratedMethodNameNode stackFrameGeneratedNameNode);
+        void Visit(StackFrameLocalMethodNameNode stackFrameLocalMethodNameNode);
     }
 }
diff --git a/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/StackFrameKind.cs b/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/StackFrameKind.cs
index 262a4425e9962..434d4bd13ce00 100644
--- a/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/StackFrameKind.cs
+++ b/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/StackFrameKind.cs
@@ -14,6 +14,8 @@ internal enum StackFrameKind
         MemberAccess,
         ArrayTypeExpression,
         GenericTypeIdentifier,
+        GeneratedIdentifier,
+        LocalMethodIdentifier,
         TypeArgument,
         TypeIdentifier,
         Parameter,
@@ -43,6 +45,10 @@ internal enum StackFrameKind
         IdentifierToken,
         PathToken,
         NumberToken,
+        DollarToken,
+        PipeToken,
+        GeneratedNameSeparatorToken, // {character}__{identifier}
+        GeneratedNameSuffixToken, // {numeric}_{numeric}
 
         // Trivia
         WhitespaceTrivia,
diff --git a/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/StackFrameLexer.cs b/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/StackFrameLexer.cs
index 5d329d25cff24..fd27752e295ab 100644
--- a/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/StackFrameLexer.cs
+++ b/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/StackFrameLexer.cs
@@ -247,7 +247,7 @@ public Result<StackFrameToken> TryScanPath()
         }
 
         /// <summary>
-        /// Returns a number token with the <see cref="StackFrameKind.LineTrivia"/> and remainging <see cref="StackFrameKind.SkippedTextTrivia"/>
+        /// Returns a number token with the <see cref="StackFrameKind.LineTrivia"/> and remaining <see cref="StackFrameKind.SkippedTextTrivia"/>
         /// attached to it. 
         /// </summary>
         /// <returns></returns>
@@ -288,6 +288,65 @@ public Result<StackFrameToken> TryScanPath()
             return CreateToken(StackFrameKind.NumberToken, GetSubSequenceToCurrentPos(start));
         }
 
+        /// <summary>
+        /// Scans a form similar to g__, where g is a GeneratedNameKind (a single character)
+        /// and identifier is valid identifier characters as with <see cref="TryScanIdentifier()"/>
+        /// </summary>
+        public Result<StackFrameToken> TryScanRequiredGeneratedNameSeparator()
+        {
+            var start = Position;
+            if (IsAsciiAlphaCharacter(CurrentChar))
+            {
+                Position++;
+            }
+            else
+            {
+                return Result<StackFrameToken>.Abort;
+            }
+
+            if (IsStringAtPosition("__"))
+            {
+                Position += 2;
+            }
+            else
+            {
+                return Result<StackFrameToken>.Abort;
+            }
+
+            return CreateToken(StackFrameKind.GeneratedNameSeparatorToken, GetSubSequenceToCurrentPos(start));
+        }
+
+        /// <summary>
+        /// In a generated name for local functions the final portion is {numeric}_{numeric}
+        /// </summary>
+        public Result<StackFrameToken> TryScanRequiredGeneratedNameSuffix()
+        {
+            var start = Position;
+
+            var n1 = TryScanNumbers();
+            if (!n1.HasValue)
+            {
+                return Result<StackFrameToken>.Abort;
+            }
+
+            if (IsStringAtPosition("_"))
+            {
+                Position++;
+            }
+            else
+            {
+                return Result<StackFrameToken>.Abort;
+            }
+
+            var n2 = TryScanNumbers();
+            if (!n2.HasValue)
+            {
+                return Result<StackFrameToken>.Abort;
+            }
+
+            return CreateToken(StackFrameKind.GeneratedNameSuffixToken, GetSubSequenceToCurrentPos(start));
+        }
+
         public static bool IsBlank(VirtualChar ch)
         {
             // List taken from the native regex parser.
@@ -304,6 +363,9 @@ public static bool IsBlank(VirtualChar ch)
             }
         }
 
+        private static bool IsAsciiAlphaCharacter(VirtualChar ch)
+            => ch.Value is (>= 'a' and <= 'z') or (>= 'A' and <= 'Z');
+
         public static StackFrameToken CreateToken(StackFrameKind kind, VirtualCharSequence virtualChars)
             => CreateToken(kind, ImmutableArray<StackFrameTrivia>.Empty, virtualChars);
 
@@ -406,6 +468,8 @@ private static StackFrameKind GetKind(VirtualChar ch)
                 '`' => StackFrameKind.GraveAccentToken,
                 '\\' => StackFrameKind.BackslashToken,
                 '/' => StackFrameKind.ForwardSlashToken,
+                '$' => StackFrameKind.DollarToken,
+                '|' => StackFrameKind.PipeToken,
                 _ => IsBlank(ch)
                     ? StackFrameKind.WhitespaceTrivia
                     : IsNumber(ch)
diff --git a/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/StackFrameNodeDefinitions.cs b/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/StackFrameNodeDefinitions.cs
index 752fb4c5c632f..1a203c35f8c62 100644
--- a/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/StackFrameNodeDefinitions.cs
+++ b/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/StackFrameNodeDefinitions.cs
@@ -194,6 +194,105 @@ internal override StackFrameNodeOrToken ChildAt(int index)
             };
     }
 
+    internal abstract class StackFrameGeneratedNameNode : StackFrameSimpleNameNode
+    {
+        protected StackFrameGeneratedNameNode(StackFrameToken identifier, StackFrameKind kind) : base(identifier, kind)
+        {
+        }
+    }
+
+    /// <summary>
+    /// Generated methods follow the pattern Namespace.ClassName.&gt;MethodName$&lt;(), where 
+    /// the "$" is optional.
+    /// </summary>
+    internal sealed class StackFrameGeneratedMethodNameNode : StackFrameGeneratedNameNode
+    {
+        public readonly StackFrameToken LessThanToken;
+        public readonly StackFrameToken GreaterThanToken;
+        public readonly StackFrameToken? DollarToken;
+
+        internal override int ChildCount => 4;
+
+        public StackFrameGeneratedMethodNameNode(StackFrameToken lessThanToken, StackFrameToken identifier, StackFrameToken greaterThanToken, StackFrameToken? dollarToken)
+            : base(identifier, StackFrameKind.GeneratedIdentifier)
+        {
+            Debug.Assert(lessThanToken.Kind == StackFrameKind.LessThanToken);
+            Debug.Assert(greaterThanToken.Kind == StackFrameKind.GreaterThanToken);
+            Debug.Assert(!dollarToken.HasValue || dollarToken.Value.Kind == StackFrameKind.DollarToken);
+
+            LessThanToken = lessThanToken;
+            GreaterThanToken = greaterThanToken;
+            DollarToken = dollarToken;
+        }
+
+        public override void Accept(IStackFrameNodeVisitor visitor)
+            => visitor.Visit(this);
+
+        internal override StackFrameNodeOrToken ChildAt(int index)
+            => index switch
+            {
+                0 => LessThanToken,
+                1 => Identifier,
+                2 => GreaterThanToken,
+                3 => DollarToken.HasValue ? DollarToken.Value : null,
+                _ => throw new InvalidOperationException()
+            };
+    }
+
+    /// <summary>
+    /// Local method names are identifiers for local functions. They follow the pattern
+    /// <code>
+    /// Namespace.ClassName.&gt;ContainingMember&lt;g__LocalMethodName|0_0()
+    ///                     ^----------------------^-------------------------- EncapsulatingMethod
+    ///                                             ^-^----------------------- GeneratedNameSeparator
+    ///                                                ^--------------^------- Identifier 
+    ///                                                                ^------ PipeToken
+    ///                                                                 ^--^-- Suffix
+    /// </code>                                                               
+    /// </summary>
+    internal sealed class StackFrameLocalMethodNameNode : StackFrameGeneratedNameNode
+    {
+        internal readonly StackFrameGeneratedMethodNameNode EncapsulatingMethod;
+        internal readonly StackFrameToken GeneratedNameSeparator;
+        internal readonly StackFrameToken PipeToken;
+        internal readonly StackFrameToken Suffix;
+
+        internal override int ChildCount => 5;
+
+        public StackFrameLocalMethodNameNode(
+            StackFrameGeneratedMethodNameNode encapsulatngMethod,
+            StackFrameToken generatedNameSeparator,
+            StackFrameToken identifier,
+            StackFrameToken pipeToken,
+            StackFrameToken suffix)
+            : base(identifier, StackFrameKind.LocalMethodIdentifier)
+        {
+            Debug.Assert(generatedNameSeparator.Kind == StackFrameKind.GeneratedNameSeparatorToken);
+            Debug.Assert(identifier.Kind == StackFrameKind.IdentifierToken);
+            Debug.Assert(pipeToken.Kind == StackFrameKind.PipeToken);
+            Debug.Assert(suffix.Kind == StackFrameKind.GeneratedNameSuffixToken);
+
+            EncapsulatingMethod = encapsulatngMethod;
+            GeneratedNameSeparator = generatedNameSeparator;
+            PipeToken = pipeToken;
+            Suffix = suffix;
+        }
+
+        public override void Accept(IStackFrameNodeVisitor visitor)
+            => visitor.Visit(this);
+
+        internal override StackFrameNodeOrToken ChildAt(int index)
+        => index switch
+        {
+            0 => EncapsulatingMethod,
+            1 => GeneratedNameSeparator,
+            2 => Identifier,
+            3 => PipeToken,
+            4 => Suffix,
+            _ => throw new InvalidOperationException()
+        };
+    }
+
     /// <summary>
     /// Represents an array type declaration, such as string[,][]
     /// </summary>
@@ -439,4 +538,4 @@ internal override StackFrameNodeOrToken ChildAt(int index)
                 _ => throw new InvalidOperationException()
             };
     }
-}
\ No newline at end of file
+}
diff --git a/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/StackFrameParser.cs b/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/StackFrameParser.cs
index 5ce37d2e5e994..9d0d1ccb37db6 100644
--- a/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/StackFrameParser.cs
+++ b/src/Features/Core/Portable/EmbeddedLanguages/StackFrame/StackFrameParser.cs
@@ -191,13 +191,27 @@ private Result<StackFrameQualifiedNameNode> TryParseQualifiedName(StackFrameName
                 return Result<StackFrameQualifiedNameNode>.Empty;
             }
 
+            // Check if this is a generated identifier
+            (var success, StackFrameSimpleNameNode? rhs) = TryScanGeneratedName();
+            if (!success)
+            {
+                return Result<StackFrameQualifiedNameNode>.Abort;
+            }
+
+            if (rhs is not null)
+            {
+                return new StackFrameQualifiedNameNode(lhs, dotToken, rhs);
+            }
+
+            // The identifier is not a generated name, parse as a normal identifier and check for generics
             var identifier = _lexer.TryScanIdentifier();
             if (!identifier.HasValue)
             {
                 return Result<StackFrameQualifiedNameNode>.Abort;
             }
 
-            var (success, rhs) = TryScanGenericTypeIdentifier(identifier.Value);
+            (success, rhs) = TryScanGenericTypeIdentifier(identifier.Value);
+
             if (!success)
             {
                 return Result<StackFrameQualifiedNameNode>.Abort;
@@ -207,6 +221,98 @@ private Result<StackFrameQualifiedNameNode> TryParseQualifiedName(StackFrameName
             return new StackFrameQualifiedNameNode(lhs, dotToken, rhs);
         }
 
+        /// <summary>
+        /// Generated names are unutterables made by the compiler. This can include async code, top level statement main, local
+        /// functions, anonymous types, etc. 
+        /// 
+        /// <code>
+        /// 
+        ///     examples:
+        ///     
+        ///     1. GeneratedMethodName
+        ///            Program.&lt;Main&gt;$
+        ///                    ^-------------- Beginning of generated name
+        ///                        ^---^------ Identifier "Main"
+        ///                             ^--^-- End of generated name with "&lt;$" 
+        ///     2. LocalMethodName
+        ///            C.&lt;MyMethod&gt;g__Local|0_0(String s)
+        ///              ^--------------------------------------- Beginning of generated name
+        ///                  ^------^---------------------------- Encapsulating method name
+        ///                              ^----------------------- "g__" identifies this as a local function. 
+        ///                                 ^----^--------------- "Local" is the name of the local function
+        ///                                      ^---^----------- "|0_0" is suffix information such as slot 
+        ///                                           ^--------^- "(String s)" identifiers the method paramters
+        /// </code>
+        /// </summary>
+        private Result<StackFrameGeneratedNameNode> TryScanGeneratedName()
+        {
+            if (!_lexer.ScanCurrentCharAsTokenIfMatch(StackFrameKind.LessThanToken, out var lessThanToken))
+            {
+                return Result<StackFrameGeneratedNameNode>.Empty;
+            }
+
+            if (_lexer.CurrentCharAsToken().Kind == StackFrameKind.LessThanToken)
+            {
+                // Nested generated names? Abort for now
+                // TODO: Actually handle this
+                return Result<StackFrameGeneratedNameNode>.Abort;
+            }
+
+            var identifier = _lexer.TryScanIdentifier();
+            if (!identifier.HasValue)
+            {
+                return Result<StackFrameGeneratedNameNode>.Abort;
+            }
+
+            if (!_lexer.ScanCurrentCharAsTokenIfMatch(StackFrameKind.GreaterThanToken, out var greaterThanToken))
+            {
+                return Result<StackFrameGeneratedNameNode>.Abort;
+            }
+
+            if (_lexer.ScanCurrentCharAsTokenIfMatch(StackFrameKind.DollarToken, out var dollarToken))
+            {
+                return new StackFrameGeneratedMethodNameNode(lessThanToken, identifier.Value, greaterThanToken, dollarToken);
+            }
+
+            var currentChar = _lexer.CurrentChar.Value;
+
+            // Check for generated name kinds we can handle
+            // See https://github.com/dotnet/roslyn/blob/main/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNameKind.cs 
+            if (currentChar == 'g')
+            {
+                // Local function
+                var encapsulatingMethod = new StackFrameGeneratedMethodNameNode(lessThanToken, identifier.Value, greaterThanToken, dollarToken: null);
+                var (success, generatedNameSeparator) = _lexer.TryScanRequiredGeneratedNameSeparator();
+                if (!success)
+                {
+                    return Result<StackFrameGeneratedNameNode>.Abort;
+                }
+
+                var generatedIdentifier = _lexer.TryScanIdentifier();
+                if (!generatedIdentifier.HasValue)
+                {
+                    return Result<StackFrameGeneratedNameNode>.Abort;
+                }
+
+                if (!_lexer.ScanCurrentCharAsTokenIfMatch(StackFrameKind.PipeToken, out var suffixSeparator))
+                {
+                    return Result<StackFrameGeneratedNameNode>.Abort;
+                }
+
+                (success, var suffix) = _lexer.TryScanRequiredGeneratedNameSuffix();
+                if (!success)
+                {
+                    return Result<StackFrameGeneratedNameNode>.Abort;
+                }
+
+                return new StackFrameLocalMethodNameNode(encapsulatingMethod, generatedNameSeparator, generatedIdentifier.Value, suffixSeparator, suffix);
+            }
+            else
+            {
+                return Result<StackFrameGeneratedNameNode>.Abort;
+            }
+        }
+
         /// <summary>
         /// Given an identifier, attempts to parse the type identifier arity for it.
         ///
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SemanticFacts/CSharpSemanticFacts.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SemanticFacts/CSharpSemanticFacts.cs
index 742cf4b90ce2b..3391a170fdc94 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SemanticFacts/CSharpSemanticFacts.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SemanticFacts/CSharpSemanticFacts.cs
@@ -15,6 +15,7 @@
 using Microsoft.CodeAnalysis.CSharp.LanguageServices;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.LanguageServices;
+using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Collections;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;
@@ -333,5 +334,26 @@ private static SymbolInfo GetSymbolInfo(SemanticModel semanticModel, SyntaxNode
 
         public bool IsInsideNameOfExpression(SemanticModel semanticModel, SyntaxNode node, CancellationToken cancellationToken)
             => (node as ExpressionSyntax).IsInsideNameOfExpression(semanticModel, cancellationToken);
+
+        public ImmutableArray<IMethodSymbol> GetLocalFunctionSymbols(Compilation compilation, ISymbol symbol, CancellationToken cancellationToken)
+        {
+            using var _ = ArrayBuilder<IMethodSymbol>.GetInstance(out var builder);
+            foreach (var syntaxReference in symbol.DeclaringSyntaxReferences)
+            {
+                var semanticModel = compilation.GetSemanticModel(syntaxReference.SyntaxTree);
+                var node = syntaxReference.GetSyntax(cancellationToken);
+
+                foreach (var localFunction in node.DescendantNodes().Where(CSharpSyntaxFacts.Instance.IsLocalFunctionStatement))
+                {
+                    var localFunctionSymbol = semanticModel.GetDeclaredSymbol(localFunction, cancellationToken);
+                    if (localFunctionSymbol is IMethodSymbol methodSymbol)
+                    {
+                        builder.Add(methodSymbol);
+                    }
+                }
+            }
+
+            return builder.ToImmutable();
+        }
     }
 }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/EmbeddedLanguages/Common/EmbeddedSyntaxToken.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/EmbeddedLanguages/Common/EmbeddedSyntaxToken.cs
index 71718d20083fc..4c93bed8823e3 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/EmbeddedLanguages/Common/EmbeddedSyntaxToken.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/EmbeddedLanguages/Common/EmbeddedSyntaxToken.cs
@@ -93,7 +93,7 @@ public string ToFullString()
         /// <param name="trailing">If false, trailing trivia will not be added</param>
         public void WriteTo(StringBuilder sb, bool leading, bool trailing)
         {
-            if (leading)
+            if (leading && !LeadingTrivia.IsDefault)
             {
                 foreach (var trivia in LeadingTrivia)
                 {
@@ -103,7 +103,7 @@ public void WriteTo(StringBuilder sb, bool leading, bool trailing)
 
             sb.Append(VirtualChars.CreateString());
 
-            if (trailing)
+            if (trailing && !TrailingTrivia.IsDefault)
             {
                 foreach (var trivia in TrailingTrivia)
                 {
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeSymbolExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeSymbolExtensions.cs
index a085c200d8b1a..ebfd0891ff13a 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeSymbolExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeSymbolExtensions.cs
@@ -9,7 +9,10 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using System.Threading;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.LanguageServices;
+using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Utilities;
 using Roslyn.Utilities;
 
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SemanticFacts/ISemanticFacts.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SemanticFacts/ISemanticFacts.cs
index 3252496d19714..68e7015031163 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SemanticFacts/ISemanticFacts.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SemanticFacts/ISemanticFacts.cs
@@ -94,5 +94,10 @@ internal partial interface ISemanticFacts
 #nullable disable
 
         bool IsInsideNameOfExpression(SemanticModel semanticModel, SyntaxNode node, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Finds all local function definitions within the syntax references for a given <paramref name="symbol"/>
+        /// </summary>
+        ImmutableArray<IMethodSymbol> GetLocalFunctionSymbols(Compilation compilation, ISymbol symbol, CancellationToken cancellationToken);
     }
 }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SemanticFacts/VisualBasicSemanticFacts.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SemanticFacts/VisualBasicSemanticFacts.vb
index 536b10a5fff46..ddc82bff9c78e 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SemanticFacts/VisualBasicSemanticFacts.vb
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SemanticFacts/VisualBasicSemanticFacts.vb
@@ -238,5 +238,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         Public Function IsInsideNameOfExpression(semanticModel As SemanticModel, node As SyntaxNode, cancellationToken As CancellationToken) As Boolean Implements ISemanticFacts.IsInsideNameOfExpression
             Return node.FirstAncestorOrSelf(Of NameOfExpressionSyntax) IsNot Nothing
         End Function
+
+        Public Function GetLocalFunctionSymbols(compilation As Compilation, symbol As ISymbol, cancellationToken As CancellationToken) As ImmutableArray(Of IMethodSymbol) Implements ISemanticFacts.GetLocalFunctionSymbols
+            Return ImmutableArray(Of IMethodSymbol).Empty
+        End Function
     End Class
 End Namespace
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SemanticsFactsService/AbstractSemanticFactsService.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SemanticsFactsService/AbstractSemanticFactsService.cs
index 2592e4dc04bf5..d827973246a5b 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SemanticsFactsService/AbstractSemanticFactsService.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SemanticsFactsService/AbstractSemanticFactsService.cs
@@ -159,6 +159,9 @@ public ImmutableArray<ISymbol> GetBestOrAllSymbols(SemanticModel semanticModel,
 
         public bool IsInsideNameOfExpression(SemanticModel semanticModel, SyntaxNode node, CancellationToken cancellationToken)
             => SemanticFacts.IsInsideNameOfExpression(semanticModel, node, cancellationToken);
+
+        public ImmutableArray<IMethodSymbol> GetLocalFunctionSymbols(Compilation compilation, ISymbol symbol, CancellationToken cancellationToken)
+            => SemanticFacts.GetLocalFunctionSymbols(compilation, symbol, cancellationToken);
         #endregion
     }
 }

From ef76bcfcaf14ac5e22a9a03fd271171d16c9a8b0 Mon Sep 17 00:00:00 2001
From: Paul Chen <lancevdance@gmail.com>
Date: Thu, 13 Jan 2022 08:35:49 +0800
Subject: [PATCH 327/444] Cache the delegate for static method group
 conversions. (#58288)

Considering the complexities currently we have in this PR, we leave the following interesting ideas/improvements for future considerations:
* Improve handling for scenarios where the enclosing method is generic and the target method is a local function
* Adding type scoped generic containers grouped by the arity
* Take the branching op out of loops
* Use fields instead of containers
* Adding type scoped generic containers grouped by the arity
* Pulling the cache into the containing type
* Module scoped cache
---
 .../Portable/Compiler/TypeCompilationState.cs |    2 +
 .../CSharp/Portable/Errors/MessageID.cs       |    3 +
 .../LocalRewriter/DelegateCacheContainer.cs   |   99 +
 .../LocalRewriter/DelegateCacheRewriter.cs    |  221 +
 .../Lowering/LocalRewriter/LocalRewriter.cs   |    3 +
 .../LocalRewriter/LocalRewriter_Conversion.cs |   21 +-
 .../Symbols/Synthesized/GeneratedNameKind.cs  |    7 +-
 .../Symbols/Synthesized/GeneratedNames.cs     |   34 +
 .../CodeGenConditionalOperatorTests.cs        |    2 +-
 .../Test/Emit/CodeGen/CodeGenLockTests.cs     |    2 +-
 .../CodeGenNullCoalescingAssignmentTests.cs   |    2 +-
 .../EditAndContinueDelegateCacheTests.cs      |  344 +
 .../EditAndContinueTestBase.cs                |    3 +-
 .../EditAndContinue/EditAndContinueTests.cs   |    2 +-
 ...odeGenMethodGroupConversionCachingTests.cs | 6376 +++++++++++++++++
 .../Semantic/Semantics/DelegateTypeTests.cs   |   10 +-
 .../Symbol/Symbols/ExtensionMethodTests.cs    |    2 +-
 .../StaticAbstractMembersInInterfacesTests.cs |   42 +-
 .../Test/WinRT/CodeGen/WinMdEventTests.cs     |    4 +-
 .../ExpressionCompilerTests.cs                |   32 +-
 src/Scripting/CSharpTest/ScriptTests.cs       |   25 +
 21 files changed, 7196 insertions(+), 40 deletions(-)
 create mode 100644 src/Compilers/CSharp/Portable/Lowering/LocalRewriter/DelegateCacheContainer.cs
 create mode 100644 src/Compilers/CSharp/Portable/Lowering/LocalRewriter/DelegateCacheRewriter.cs
 create mode 100644 src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueDelegateCacheTests.cs
 create mode 100644 src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenMethodGroupConversionCachingTests.cs

diff --git a/src/Compilers/CSharp/Portable/Compiler/TypeCompilationState.cs b/src/Compilers/CSharp/Portable/Compiler/TypeCompilationState.cs
index 9ed8097b9bfca..ac4d6ddcde519 100644
--- a/src/Compilers/CSharp/Portable/Compiler/TypeCompilationState.cs
+++ b/src/Compilers/CSharp/Portable/Compiler/TypeCompilationState.cs
@@ -71,6 +71,8 @@ internal MethodWithBody(MethodSymbol method, BoundStatement body, ImportChain? i
 
         public SynthesizedClosureEnvironment? StaticLambdaFrame;
 
+        public DelegateCacheContainer? ConcreteDelegateCacheContainer;
+
         /// <summary>
         /// A graph of method->method references for this(...) constructor initializers.
         /// Used to detect and report initializer cycles.
diff --git a/src/Compilers/CSharp/Portable/Errors/MessageID.cs b/src/Compilers/CSharp/Portable/Errors/MessageID.cs
index d4869973012a7..73accd97ff336 100644
--- a/src/Compilers/CSharp/Portable/Errors/MessageID.cs
+++ b/src/Compilers/CSharp/Portable/Errors/MessageID.cs
@@ -241,6 +241,8 @@ internal enum MessageID
         IDS_FeatureNewLinesInInterpolations = MessageBase + 12813,
         IDS_FeatureListPattern = MessageBase + 12814,
         IDS_ParameterNullChecking = MessageBase + 12815,
+
+        IDS_FeatureCacheStaticMethodGroupConversion = MessageBase + 12816,
     }
 
     // Message IDs may refer to strings that need to be localized.
@@ -354,6 +356,7 @@ internal static LanguageVersion RequiredVersion(this MessageID feature)
                 case MessageID.IDS_FeatureGenericAttributes: // semantic check
                 case MessageID.IDS_FeatureNewLinesInInterpolations: // semantic check
                 case MessageID.IDS_FeatureListPattern: // semantic check
+                case MessageID.IDS_FeatureCacheStaticMethodGroupConversion: // lowering check
                 case MessageID.IDS_ParameterNullChecking: // syntax check
                     return LanguageVersion.Preview;
 
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/DelegateCacheContainer.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/DelegateCacheContainer.cs
new file mode 100644
index 0000000000000..21d49a0ec2fdc
--- /dev/null
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/DelegateCacheContainer.cs
@@ -0,0 +1,99 @@
+// 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 System.Diagnostics;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.CSharp.Symbols;
+
+/// <summary>
+/// This type is synthesized to hold the cached delegates that target static method groups.
+/// </summary>
+internal sealed class DelegateCacheContainer : SynthesizedContainer
+{
+    private readonly Symbol _containingSymbol;
+    private readonly NamedTypeSymbol? _constructedContainer;
+    private readonly Dictionary<(TypeSymbol, MethodSymbol), FieldSymbol> _delegateFields = new(CLRSignatureComparer.Instance);
+
+    /// <summary>Creates a type-scope concrete delegate cache container.</summary>
+    internal DelegateCacheContainer(TypeSymbol containingType, int generationOrdinal)
+        : base(GeneratedNames.DelegateCacheContainerType(generationOrdinal), containingMethod: null)
+    {
+        Debug.Assert(containingType.IsDefinition);
+
+        _containingSymbol = containingType;
+    }
+
+    /// <summary>Creates a method-scope generic delegate cache container.</summary>
+    internal DelegateCacheContainer(MethodSymbol ownerMethod, int topLevelMethodOrdinal, int ownerUniqueId, int generationOrdinal)
+        : base(GeneratedNames.DelegateCacheContainerType(generationOrdinal, ownerMethod.Name, topLevelMethodOrdinal, ownerUniqueId), ownerMethod)
+    {
+        Debug.Assert(ownerMethod.IsDefinition);
+        Debug.Assert(ownerMethod.Arity > 0);
+
+        _containingSymbol = ownerMethod.ContainingType;
+        _constructedContainer = Construct(ConstructedFromTypeParameters);
+    }
+
+    public override Symbol ContainingSymbol => _containingSymbol;
+
+    public override bool AreLocalsZeroed => throw ExceptionUtilities.Unreachable;
+
+    public override TypeKind TypeKind => TypeKind.Class;
+
+    public override bool IsStatic => true;
+
+    internal override bool IsRecord => false;
+
+    internal override bool IsRecordStruct => false;
+
+    internal override bool HasPossibleWellKnownCloneMethod() => false;
+
+    internal FieldSymbol GetOrAddCacheField(SyntheticBoundNodeFactory factory, TypeSymbol delegateType, MethodSymbol targetMethod)
+    {
+        Debug.Assert(delegateType.IsDelegateType());
+
+        if (_delegateFields.TryGetValue((delegateType, targetMethod), out var field))
+        {
+            return field;
+        }
+
+        var fieldType = TypeParameters.IsEmpty ? delegateType : TypeMap.SubstituteType(delegateType).Type;
+        var fieldName = GeneratedNames.DelegateCacheContainerFieldName(_delegateFields.Count, targetMethod.Name);
+
+        field = new SynthesizedFieldSymbol(this, fieldType, fieldName, isPublic: true, isStatic: true);
+        factory.AddField(this, field);
+
+        if (!TypeParameters.IsEmpty)
+        {
+            Debug.Assert(_constructedContainer is { });
+
+            field = field.AsMember(_constructedContainer);
+        }
+
+        _delegateFields.Add((delegateType, targetMethod), field);
+
+        return field;
+    }
+
+    private sealed class CLRSignatureComparer : IEqualityComparer<(TypeSymbol delegateType, MethodSymbol targetMethod)>
+    {
+        public static readonly CLRSignatureComparer Instance = new();
+
+        public bool Equals((TypeSymbol delegateType, MethodSymbol targetMethod) x, (TypeSymbol delegateType, MethodSymbol targetMethod) y)
+        {
+            var symbolComparer = SymbolEqualityComparer.CLRSignature;
+
+            return symbolComparer.Equals(x.delegateType, y.delegateType) && symbolComparer.Equals(x.targetMethod, y.targetMethod);
+        }
+
+        public int GetHashCode((TypeSymbol delegateType, MethodSymbol targetMethod) conversion)
+        {
+            var symbolComparer = SymbolEqualityComparer.CLRSignature;
+
+            return Hash.Combine(symbolComparer.GetHashCode(conversion.delegateType), symbolComparer.GetHashCode(conversion.targetMethod));
+        }
+    }
+}
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/DelegateCacheRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/DelegateCacheRewriter.cs
new file mode 100644
index 0000000000000..a4c8eb97dad58
--- /dev/null
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/DelegateCacheRewriter.cs
@@ -0,0 +1,221 @@
+// 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.Collections.Immutable;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Symbols;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.CSharp;
+
+/// <summary>
+/// This type helps rewrite the delegate creations that target static method groups to use a cached instance of delegate.
+/// </summary>
+internal sealed class DelegateCacheRewriter
+{
+    private readonly SyntheticBoundNodeFactory _factory;
+    private readonly int _topLevelMethodOrdinal;
+
+    private Dictionary<MethodSymbol, DelegateCacheContainer>? _genericCacheContainers;
+
+    internal DelegateCacheRewriter(SyntheticBoundNodeFactory factory, int topLevelMethodOrdinal)
+    {
+        Debug.Assert(factory.TopLevelMethod is { });
+
+        _factory = factory;
+        _topLevelMethodOrdinal = topLevelMethodOrdinal;
+    }
+
+    internal static bool CanRewrite(BoundDelegateCreationExpression boundDelegateCreation)
+    {
+        var targetMethod = boundDelegateCreation.MethodOpt;
+
+        Debug.Assert(targetMethod is { });
+
+        return targetMethod.IsStatic && !boundDelegateCreation.IsExtensionMethod;
+    }
+
+    internal BoundExpression Rewrite(BoundDelegateCreationExpression boundDelegateCreation)
+    {
+        var targetMethod = boundDelegateCreation.MethodOpt;
+        var delegateType = boundDelegateCreation.Type;
+
+        Debug.Assert(targetMethod is { });
+
+        var oldSyntax = _factory.Syntax;
+        _factory.Syntax = boundDelegateCreation.Syntax;
+
+        var cacheContainer = GetOrAddCacheContainer(delegateType, targetMethod);
+        var cacheField = cacheContainer.GetOrAddCacheField(_factory, delegateType, targetMethod);
+
+        var boundCacheField = _factory.Field(receiver: null, cacheField);
+        var rewrittenNode = _factory.Coalesce(boundCacheField, _factory.AssignmentExpression(boundCacheField, boundDelegateCreation));
+
+        _factory.Syntax = oldSyntax;
+
+        return rewrittenNode;
+    }
+
+    private DelegateCacheContainer GetOrAddCacheContainer(TypeSymbol delegateType, MethodSymbol targetMethod)
+    {
+        Debug.Assert(_factory.ModuleBuilderOpt is { });
+        Debug.Assert(_factory.CurrentFunction is { });
+
+        var generation = _factory.ModuleBuilderOpt.CurrentGenerationOrdinal;
+
+        DelegateCacheContainer? container;
+
+        // We don't need to synthesize a container for each and every function.
+        //
+        // For example:
+        //   void LF1<T>()
+        //   {
+        //       void LF2<G>()
+        //       {
+        //           void LF3()
+        //           {
+        //               Func<T> d = SomeMethod<T>;
+        //               static void LF4 () { Func<T> d = SomeMethod<T>; }
+        //           }
+        //           
+        //           void LF5()
+        //           {
+        //               Func<T> d = SomeMethod<T>;
+        //           }
+        //       }
+        //   }
+        //
+        // In the above case, only one cached delegate is necessary, and it could be assigned to the container 'owned' by LF1.
+
+        if (!TryGetOwnerFunction(_factory.CurrentFunction, delegateType, targetMethod, out var ownerFunction))
+        {
+            var typeCompilationState = _factory.CompilationState;
+            container = typeCompilationState.ConcreteDelegateCacheContainer;
+
+            if (container is { })
+            {
+                return container;
+            }
+
+            container = new DelegateCacheContainer(typeCompilationState.Type, generation);
+            typeCompilationState.ConcreteDelegateCacheContainer = container;
+        }
+        else
+        {
+            var containers = _genericCacheContainers ??= new Dictionary<MethodSymbol, DelegateCacheContainer>(ReferenceEqualityComparer.Instance);
+
+            if (containers.TryGetValue(ownerFunction, out container))
+            {
+                return container;
+            }
+
+            container = new DelegateCacheContainer(ownerFunction, _topLevelMethodOrdinal, containers.Count, generation);
+            containers.Add(ownerFunction, container);
+        }
+
+        _factory.AddNestedType(container);
+
+        return container;
+    }
+
+    private static bool TryGetOwnerFunction(MethodSymbol currentFunction, TypeSymbol delegateType, MethodSymbol targetMethod, [NotNullWhen(true)] out MethodSymbol? ownerFunction)
+    {
+        if (targetMethod.MethodKind == MethodKind.LocalFunction)
+        {
+            // Local functions can use type parameters from their enclosing methods!
+            //
+            // For example:
+            //   void Test<T>()
+            //   {
+            //       var t = Target<int>;
+            //       static object Target<V>() => default(T);
+            //   }
+            //
+            // Therefore, without too much analysis, we select the closest generic enclosing function as the cache container owner.
+
+            for (Symbol? enclosingSymbol = currentFunction; enclosingSymbol is MethodSymbol enclosingMethod; enclosingSymbol = enclosingSymbol.ContainingSymbol)
+            {
+                if (enclosingMethod.Arity > 0)
+                {
+                    ownerFunction = enclosingMethod;
+                    return true;
+                }
+            }
+
+            ownerFunction = null;
+            return false;
+        }
+
+        // @AlekseyTs: It is Ok to create delegates for other method kinds as well.
+        // @jcouv: We'd likely want to pay attention to this code if this happens.
+        // What we really cared above was,
+        // - "Are there any type parameters from the target method that we cannot discover simply from it's signature?"
+        // As of C# 10, we only observe local functions could potentially answer yes, so we used that.
+        // If this is hit, feel free to change but please also add tests.
+        Debug.Assert(targetMethod.MethodKind == MethodKind.Ordinary);
+
+        var usedTypeParameters = PooledHashSet<TypeParameterSymbol>.GetInstance();
+        try
+        {
+            FindTypeParameters(delegateType, usedTypeParameters);
+            FindTypeParameters(targetMethod, usedTypeParameters);
+
+            for (Symbol? enclosingSymbol = currentFunction; enclosingSymbol is MethodSymbol enclosingMethod; enclosingSymbol = enclosingSymbol.ContainingSymbol)
+            {
+                if (usedTypeParametersContains(usedTypeParameters, enclosingMethod.TypeParameters))
+                {
+                    ownerFunction = enclosingMethod;
+                    return true;
+                }
+            }
+
+            ownerFunction = null;
+            return false;
+        }
+        finally
+        {
+            usedTypeParameters.Free();
+        }
+
+        static bool usedTypeParametersContains(HashSet<TypeParameterSymbol> used, ImmutableArray<TypeParameterSymbol> typeParameters)
+        {
+            foreach (var typeParameter in typeParameters)
+            {
+                if (used.Contains(typeParameter))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+
+    private static void FindTypeParameters(TypeSymbol type, HashSet<TypeParameterSymbol> result)
+        => type.VisitType(s_typeParameterSymbolCollector, result, visitCustomModifiers: true);
+
+    private static void FindTypeParameters(MethodSymbol method, HashSet<TypeParameterSymbol> result)
+    {
+        FindTypeParameters(method.ContainingType, result);
+
+        foreach (var typeArgument in method.TypeArgumentsWithAnnotations)
+        {
+            typeArgument.VisitType(type: null, typeWithAnnotationsPredicate: null, s_typeParameterSymbolCollector, result, visitCustomModifiers: true);
+        }
+    }
+
+    private static readonly Func<TypeSymbol, HashSet<TypeParameterSymbol>, bool, bool> s_typeParameterSymbolCollector = (typeSymbol, result, _) =>
+    {
+        if (typeSymbol is TypeParameterSymbol typeParameter)
+        {
+            result.Add(typeParameter);
+        }
+
+        return false;
+    };
+}
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
index c8c175ea65d0d..d39ee387058da 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
@@ -27,6 +27,8 @@ internal sealed partial class LocalRewriter : BoundTreeRewriterWithStackGuard
         private LoweredDynamicOperationFactory _dynamicFactory;
         private bool _sawLambdas;
         private int _availableLocalFunctionOrdinal;
+        private readonly int _topLevelMethodOrdinal;
+        private DelegateCacheRewriter? _lazyDelegateCacheRewriter;
         private bool _inExpressionLambda;
 
         private bool _sawAwait;
@@ -57,6 +59,7 @@ private LocalRewriter(
             _dynamicFactory = new LoweredDynamicOperationFactory(factory, containingMethodOrdinal);
             _previousSubmissionFields = previousSubmissionFields;
             _allowOmissionOfConditionalCalls = allowOmissionOfConditionalCalls;
+            _topLevelMethodOrdinal = containingMethodOrdinal;
             _diagnostics = diagnostics;
 
             Debug.Assert(instrumenter != null);
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
index e1d2ce2eb3d0d..e088ad6227c04 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
@@ -425,9 +425,26 @@ private BoundExpression MakeConversionNodeCore(
                         var receiver = (!method.RequiresInstanceReceiver && !oldNodeOpt.IsExtensionMethod && !method.IsAbstract) ? _factory.Type(method.ContainingType) : mg.ReceiverOpt;
                         Debug.Assert(receiver is { });
                         _factory.Syntax = oldSyntax;
-                        return new BoundDelegateCreationExpression(syntax, argument: receiver, methodOpt: method,
-                                                                   isExtensionMethod: oldNodeOpt.IsExtensionMethod, wasTargetTyped: false, type: rewrittenType);
+
+                        var boundDelegateCreation = new BoundDelegateCreationExpression(syntax, argument: receiver, methodOpt: method,
+                                                                                        isExtensionMethod: oldNodeOpt.IsExtensionMethod, wasTargetTyped: false, type: rewrittenType);
+
+                        Debug.Assert(_factory.TopLevelMethod is { });
+
+                        if (_factory.Compilation.LanguageVersion >= MessageID.IDS_FeatureCacheStaticMethodGroupConversion.RequiredVersion()
+                            && !_inExpressionLambda // The tree structure / meaning for expression trees should remain untouched.
+                            && _factory.TopLevelMethod.MethodKind != MethodKind.StaticConstructor // Avoid caching twice if people do it manually.
+                            && DelegateCacheRewriter.CanRewrite(boundDelegateCreation))
+                        {
+                            var rewriter = _lazyDelegateCacheRewriter ??= new DelegateCacheRewriter(_factory, _topLevelMethodOrdinal);
+                            return rewriter.Rewrite(boundDelegateCreation);
+                        }
+                        else
+                        {
+                            return boundDelegateCreation;
+                        }
                     }
+
                 default:
                     break;
             }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNameKind.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNameKind.cs
index f8e208cffe980..66a294e654bad 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNameKind.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNameKind.cs
@@ -39,6 +39,7 @@ internal enum GeneratedNameKind
         IteratorFinallyMethod = 'm',
         BaseMethodWrapper = 'n',
         AsyncBuilderField = 't',
+        DelegateCacheContainerType = 'O',
         DynamicCallSiteContainerType = 'o',
         DynamicCallSiteField = 'p',
         AsyncIteratorPromiseOfValueOrEndBackingField = 'v',
@@ -62,6 +63,10 @@ internal enum GeneratedNameKind
     internal static class GeneratedNameKindExtensions
     {
         internal static bool IsTypeName(this GeneratedNameKind kind)
-            => kind is GeneratedNameKind.LambdaDisplayClass or GeneratedNameKind.StateMachineType or GeneratedNameKind.DynamicCallSiteContainerType;
+            => kind is GeneratedNameKind.LambdaDisplayClass
+                    or GeneratedNameKind.StateMachineType
+                    or GeneratedNameKind.DynamicCallSiteContainerType
+                    or GeneratedNameKind.DelegateCacheContainerType
+                    ;
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNames.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNames.cs
index f931a3d46cb7b..a50b9ccb9b9f6 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNames.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNames.cs
@@ -439,6 +439,40 @@ internal static string AsyncBuilderFieldName()
             return "<>t__builder";
         }
 
+        internal static string DelegateCacheContainerType(int generation, string? methodName = null, int methodOrdinal = -1, int ownerUniqueId = -1)
+        {
+            const char NameKind = (char)GeneratedNameKind.DelegateCacheContainerType;
+
+            var result = PooledStringBuilder.GetInstance();
+            var builder = result.Builder;
+
+            builder.Append('<').Append(methodName).Append('>').Append(NameKind);
+
+            if (methodOrdinal > -1)
+            {
+                builder.Append(GeneratedNameConstants.SuffixSeparator).Append(methodOrdinal);
+            }
+
+            if (ownerUniqueId > -1)
+            {
+                builder.Append(IdSeparator).Append(ownerUniqueId);
+            }
+
+            AppendOptionalGeneration(builder, generation);
+
+            return result.ToStringAndFree();
+        }
+
+        internal static string DelegateCacheContainerFieldName(int id, string targetMethod)
+        {
+            var result = PooledStringBuilder.GetInstance();
+            var builder = result.Builder;
+
+            builder.Append('<').Append(id).Append(">__").Append(targetMethod);
+
+            return result.ToStringAndFree();
+        }
+
         internal static string ReusableHoistedLocalFieldName(int number)
         {
             Debug.Assert((char)GeneratedNameKind.ReusableHoistedLocalField == '7');
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenConditionalOperatorTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenConditionalOperatorTests.cs
index 2df99e3bcab0f..3daeccaa04c99 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenConditionalOperatorTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenConditionalOperatorTests.cs
@@ -1102,7 +1102,7 @@ static int M()
         return 0;
     }
 }";
-            var comp = CompileAndVerify(source);
+            var comp = CompileAndVerify(source, parseOptions: TestOptions.Regular10);
             comp.VerifyDiagnostics();
             comp.VerifyIL("C.Main", @"
 {
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenLockTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenLockTests.cs
index 9acbf01575d5e..f873d1ef0c65b 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenLockTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenLockTests.cs
@@ -543,7 +543,7 @@ static partial void PM(int p2)
 }
 ";
 
-            CompileAndVerify(text).VerifyIL("Test.Main", @"
+            CompileAndVerify(text, parseOptions: TestOptions.Regular10).VerifyIL("Test.Main", @"
 {
   // Code size       36 (0x24)
   .maxstack  2
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenNullCoalescingAssignmentTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenNullCoalescingAssignmentTests.cs
index ceb9e3b2f4be8..0c30cfd082de4 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenNullCoalescingAssignmentTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenNullCoalescingAssignmentTests.cs
@@ -703,7 +703,7 @@ public static void Main()
     }
     static void TestMethod() => Console.WriteLine(""In TestMethod"");
 }
-", expectedOutput: @"
+", parseOptions: TestOptions.Regular10, expectedOutput: @"
 In TestMethod
 In TestMethod
 ").VerifyIL("C.Main()", @"
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueDelegateCacheTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueDelegateCacheTests.cs
new file mode 100644
index 0000000000000..3b50141864d50
--- /dev/null
+++ b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueDelegateCacheTests.cs
@@ -0,0 +1,344 @@
+// 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.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeGen;
+using Microsoft.CodeAnalysis.CSharp.Symbols;
+using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.CSharp.UnitTests;
+using Microsoft.CodeAnalysis.Emit;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.CSharp.EditAndContinue.UnitTests;
+
+public class EditAndContinueDelegateCacheTests : EditAndContinueTestBase
+{
+    [Fact]
+    public void TargetChanged0()
+    {
+        var source0 = @"
+class C
+{
+    static int Target0() => 0;
+    static int Target1() => 1;
+
+    System.Func<int> F() => Target0;
+}
+";
+        var source1 = @"
+class C
+{
+    static int Target0() => 0;
+    static int Target1() => 1;
+
+    System.Func<int> F() => Target1;
+}
+";
+        var compilation0 = CreateCompilation(source0);
+        var compilation1 = compilation0.WithSource(source1);
+
+        Assert.Equal(compilation0.LanguageVersion, compilation1.LanguageVersion);
+
+        var f0 = compilation0.GetMember<MethodSymbol>("C.F");
+        var f1 = compilation1.GetMember<MethodSymbol>("C.F");
+
+        var v0 = CompileAndVerify(compilation0);
+        using var moduleData0 = ModuleMetadata.CreateFromImage(v0.EmittedAssemblyData);
+        var methodData0 = v0.TestData.GetMethodData("C.F");
+
+        var generation0 = EmitBaseline.CreateInitialBaseline(moduleData0, methodData0.EncDebugInfoProvider());
+        var diff1 = compilation1.EmitDifference(
+            generation0,
+            ImmutableArray.Create(
+                SemanticEdit.Create(SemanticEditKind.Update, f0, f1, preserveLocalVariables: true)));
+
+        diff1.EmitResult.Diagnostics.Verify();
+        diff1.VerifyIL("C.F", @"
+{
+  // Code size       28 (0x1c)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<int> C.<>O#1.<0>__Target1""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""int C.Target1()""
+  IL_0010:  newobj     ""System.Func<int>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<int> C.<>O#1.<0>__Target1""
+  IL_001b:  ret
+}
+");
+
+        var reader0 = moduleData0.MetadataReader;
+        var reader1 = diff1.GetMetadata().Reader;
+
+        CheckNames(reader0, reader0.GetTypeDefNames(), "<Module>", "C", "<>O");
+        CheckNames(new[] { reader0, reader1 }, reader1.GetTypeDefNames(), "<>O#1");
+    }
+
+    [Fact]
+    public void TargetChanged1()
+    {
+        var source0 = @"
+class C<T>
+{
+    static int Target0<G>() => 0;
+    static int Target1<G>() => 1;
+
+    System.Func<int> F() => Target0<T>;
+}
+";
+        var source1 = @"
+class C<T>
+{
+    static int Target0<G>() => 0;
+    static int Target1<G>() => 1;
+
+    System.Func<int> F() => Target1<T>;
+}
+";
+        var compilation0 = CreateCompilation(source0);
+        var compilation1 = compilation0.WithSource(source1);
+
+        Assert.Equal(compilation0.LanguageVersion, compilation1.LanguageVersion);
+
+        var f0 = compilation0.GetMember<MethodSymbol>("C.F");
+        var f1 = compilation1.GetMember<MethodSymbol>("C.F");
+
+        var v0 = CompileAndVerify(compilation0);
+        using var moduleData0 = ModuleMetadata.CreateFromImage(v0.EmittedAssemblyData);
+        var methodData0 = v0.TestData.GetMethodData("C<T>.F");
+
+        var generation0 = EmitBaseline.CreateInitialBaseline(moduleData0, methodData0.EncDebugInfoProvider());
+        var diff1 = compilation1.EmitDifference(
+            generation0,
+            ImmutableArray.Create(
+                SemanticEdit.Create(SemanticEditKind.Update, f0, f1, preserveLocalVariables: true)));
+
+        diff1.EmitResult.Diagnostics.Verify();
+        diff1.VerifyIL("C<T>.F", @"
+{
+  // Code size       28 (0x1c)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<int> C<T>.<>O#1.<0>__Target1""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""int C<T>.Target1<T>()""
+  IL_0010:  newobj     ""System.Func<int>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<int> C<T>.<>O#1.<0>__Target1""
+  IL_001b:  ret
+}
+");
+
+        var reader0 = moduleData0.MetadataReader;
+        var reader1 = diff1.GetMetadata().Reader;
+
+        CheckNames(reader0, reader0.GetTypeDefNames(), "<Module>", "C`1", "<>O");
+        CheckNames(new[] { reader0, reader1 }, reader1.GetTypeDefNames(), "<>O#1");
+    }
+
+    [Fact]
+    public void TargetChanged2()
+    {
+        var source0 = @"
+class C<T>
+{
+    static int Target0<G>() => 0;
+    static int Target1<G>() => 1;
+
+    System.Func<int> F<G>() => Target0<T>;
+}
+";
+        var source1 = @"
+class C<T>
+{
+    static int Target0<G>() => 0;
+    static int Target1<G>() => 1;
+
+    System.Func<int> F<G>() => Target1<T>;
+}
+";
+        var compilation0 = CreateCompilation(source0);
+        var compilation1 = compilation0.WithSource(source1);
+
+        Assert.Equal(compilation0.LanguageVersion, compilation1.LanguageVersion);
+
+        var f0 = compilation0.GetMember<MethodSymbol>("C.F");
+        var f1 = compilation1.GetMember<MethodSymbol>("C.F");
+
+        var v0 = CompileAndVerify(compilation0);
+        using var moduleData0 = ModuleMetadata.CreateFromImage(v0.EmittedAssemblyData);
+        var methodData0 = v0.TestData.GetMethodData("C<T>.F<G>");
+
+        var generation0 = EmitBaseline.CreateInitialBaseline(moduleData0, methodData0.EncDebugInfoProvider());
+        var diff1 = compilation1.EmitDifference(
+            generation0,
+            ImmutableArray.Create(
+                SemanticEdit.Create(SemanticEditKind.Update, f0, f1, preserveLocalVariables: true)));
+
+        diff1.EmitResult.Diagnostics.Verify();
+        diff1.VerifyIL("C<T>.F<G>", @"
+{
+  // Code size       28 (0x1c)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<int> C<T>.<>O#1.<0>__Target1""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""int C<T>.Target1<T>()""
+  IL_0010:  newobj     ""System.Func<int>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<int> C<T>.<>O#1.<0>__Target1""
+  IL_001b:  ret
+}
+");
+
+        var reader0 = moduleData0.MetadataReader;
+        var reader1 = diff1.GetMetadata().Reader;
+
+        CheckNames(reader0, reader0.GetTypeDefNames(), "<Module>", "C`1", "<>O");
+        CheckNames(new[] { reader0, reader1 }, reader1.GetTypeDefNames(), "<>O#1");
+    }
+
+    [Fact]
+    public void TargetChanged3()
+    {
+        var source0 = @"
+class C<T>
+{
+    static int Target0<G>() => 0;
+    static int Target1<G>() => 1;
+
+    System.Func<int> F<G>() => Target0<T>;
+}
+";
+        var source1 = @"
+class C<T>
+{
+    static int Target0<G>() => 0;
+    static int Target1<G>() => 1;
+
+    System.Func<int> F<G>() => Target1<G>;
+}
+";
+        var compilation0 = CreateCompilation(source0);
+        var compilation1 = compilation0.WithSource(source1);
+
+        Assert.Equal(compilation0.LanguageVersion, compilation1.LanguageVersion);
+
+        var f0 = compilation0.GetMember<MethodSymbol>("C.F");
+        var f1 = compilation1.GetMember<MethodSymbol>("C.F");
+
+        var v0 = CompileAndVerify(compilation0);
+        using var moduleData0 = ModuleMetadata.CreateFromImage(v0.EmittedAssemblyData);
+        var methodData0 = v0.TestData.GetMethodData("C<T>.F<G>");
+
+        var generation0 = EmitBaseline.CreateInitialBaseline(moduleData0, methodData0.EncDebugInfoProvider());
+        var diff1 = compilation1.EmitDifference(
+            generation0,
+            ImmutableArray.Create(
+                SemanticEdit.Create(SemanticEditKind.Update, f0, f1, preserveLocalVariables: true)));
+
+        diff1.EmitResult.Diagnostics.Verify();
+        diff1.VerifyIL("C<T>.F<G>", @"
+{
+  // Code size       28 (0x1c)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<int> C<T>.<F>O__2_0#1<G>.<0>__Target1""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""int C<T>.Target1<G>()""
+  IL_0010:  newobj     ""System.Func<int>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<int> C<T>.<F>O__2_0#1<G>.<0>__Target1""
+  IL_001b:  ret
+}
+");
+
+        var reader0 = moduleData0.MetadataReader;
+        var reader1 = diff1.GetMetadata().Reader;
+
+        CheckNames(reader0, reader0.GetTypeDefNames(), "<Module>", "C`1", "<>O");
+        CheckNames(new[] { reader0, reader1 }, reader1.GetTypeDefNames(), "<F>O__2_0#1`1");
+    }
+
+    [Fact]
+    public void TargetChanged4()
+    {
+        var source0 = @"
+class C<T>
+{
+    static int Target0<G>() => 0;
+    static int Target1<G>() => 1;
+
+    System.Func<int> F<G>() => Target0<G>;
+}
+";
+        var source1 = @"
+class C<T>
+{
+    static int Target0<G>() => 0;
+    static int Target1<G>() => 1;
+
+    System.Func<int> F<G>() => Target1<G>;
+}
+";
+        var compilation0 = CreateCompilation(source0);
+        var compilation1 = compilation0.WithSource(source1);
+
+        Assert.Equal(compilation0.LanguageVersion, compilation1.LanguageVersion);
+
+        var f0 = compilation0.GetMember<MethodSymbol>("C.F");
+        var f1 = compilation1.GetMember<MethodSymbol>("C.F");
+
+        var v0 = CompileAndVerify(compilation0);
+        using var moduleData0 = ModuleMetadata.CreateFromImage(v0.EmittedAssemblyData);
+        var methodData0 = v0.TestData.GetMethodData("C<T>.F<G>");
+
+        var generation0 = EmitBaseline.CreateInitialBaseline(moduleData0, methodData0.EncDebugInfoProvider());
+        var diff1 = compilation1.EmitDifference(
+            generation0,
+            ImmutableArray.Create(
+                SemanticEdit.Create(SemanticEditKind.Update, f0, f1, preserveLocalVariables: true)));
+
+        diff1.EmitResult.Diagnostics.Verify();
+        diff1.VerifyIL("C<T>.F<G>", @"
+{
+  // Code size       28 (0x1c)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<int> C<T>.<F>O__2_0#1<G>.<0>__Target1""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""int C<T>.Target1<G>()""
+  IL_0010:  newobj     ""System.Func<int>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<int> C<T>.<F>O__2_0#1<G>.<0>__Target1""
+  IL_001b:  ret
+}
+");
+
+        var reader0 = moduleData0.MetadataReader;
+        var reader1 = diff1.GetMetadata().Reader;
+
+        CheckNames(reader0, reader0.GetTypeDefNames(), "<Module>", "C`1", "<F>O__2_0`1");
+        CheckNames(new[] { reader0, reader1 }, reader1.GetTypeDefNames(), "<F>O__2_0#1`1");
+    }
+
+}
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTestBase.cs b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTestBase.cs
index db4b878a56567..0690435a76ff7 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTestBase.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTestBase.cs
@@ -276,7 +276,8 @@ public static class EditAndContinueTestExtensions
     {
         internal static CSharpCompilation WithSource(this CSharpCompilation compilation, CSharpTestSource newSource)
         {
-            return compilation.RemoveAllSyntaxTrees().AddSyntaxTrees(newSource.GetSyntaxTrees(TestOptions.Regular));
+            var previousParseOptions = (CSharpParseOptions)compilation.SyntaxTrees.FirstOrDefault()?.Options;
+            return compilation.RemoveAllSyntaxTrees().AddSyntaxTrees(newSource.GetSyntaxTrees(previousParseOptions));
         }
 
         internal static CSharpCompilation WithSource(this CSharpCompilation compilation, SyntaxTree newTree)
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs
index 4e08586668fdf..9414c65a5e97c 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs
@@ -9205,7 +9205,7 @@ static void M2(object o)
 }";
             var compilationPIA = CreateCompilation(sourcePIA, options: TestOptions.DebugDll);
             var referencePIA = compilationPIA.EmitToImageReference(embedInteropTypes: true);
-            var compilation0 = CreateCompilation(source0, options: TestOptions.DebugDll, references: new MetadataReference[] { referencePIA, CSharpRef });
+            var compilation0 = CreateCompilation(source0, parseOptions: TestOptions.Regular10, options: TestOptions.DebugDll, references: new MetadataReference[] { referencePIA, CSharpRef });
             var compilation1A = compilation0.WithSource(source1A);
             var compilation1B = compilation0.WithSource(source1B);
 
diff --git a/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenMethodGroupConversionCachingTests.cs b/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenMethodGroupConversionCachingTests.cs
new file mode 100644
index 0000000000000..50cc12f67f61a
--- /dev/null
+++ b/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenMethodGroupConversionCachingTests.cs
@@ -0,0 +1,6376 @@
+// 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 Microsoft.CodeAnalysis.CSharp.Symbols;
+using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.CSharp.UnitTests.CodeGen;
+
+public class CodeGenMethodGroupConversionCachingTests : CSharpTestBase
+{
+    const string PASS = "PASS";
+
+    [Fact]
+    public void Not_DelegateCreations_Static()
+    {
+        var source = @"
+using System;
+delegate void D();
+class C
+{
+    public static void Main(string[] args)
+    {
+        Invoke(new D(Target), new D(Target));
+    }
+
+    static void Target() { Console.WriteLine(""FAIL""); }
+    static void Invoke(D x, D y) { Console.Write(Object.ReferenceEquals(x, y) ? ""FAIL"" : ""PASS""); }
+}";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS, symbolValidator: VerifyNoCacheContainersIn("C"));
+        verifier.VerifyIL("C.Main", @"
+{
+  // Code size       30 (0x1e)
+  .maxstack  3
+  IL_0000:  ldnull
+  IL_0001:  ldftn      ""void C.Target()""
+  IL_0007:  newobj     ""D..ctor(object, System.IntPtr)""
+  IL_000c:  ldnull
+  IL_000d:  ldftn      ""void C.Target()""
+  IL_0013:  newobj     ""D..ctor(object, System.IntPtr)""
+  IL_0018:  call       ""void C.Invoke(D, D)""
+  IL_001d:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Not_DelegateCreations_Instance()
+    {
+        var source = @"
+using System;
+delegate void D();
+class C
+{
+    public static void Main(string[] args)
+    {
+        var c = new C();
+        c.Invoke(new D(c.Target), new D(c.Target));
+    }
+
+    void Target() { Console.WriteLine(""FAIL""); }
+    void Invoke(D x, D y) { Console.Write(Object.ReferenceEquals(x, y) ? ""FAIL"" : ""PASS""); }
+}";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS, symbolValidator: VerifyNoCacheContainersIn("C"));
+        verifier.VerifyIL("C.Main", @"
+{
+  // Code size       37 (0x25)
+  .maxstack  4
+  .locals init (C V_0) //c
+  IL_0000:  newobj     ""C..ctor()""
+  IL_0005:  stloc.0
+  IL_0006:  ldloc.0
+  IL_0007:  ldloc.0
+  IL_0008:  ldftn      ""void C.Target()""
+  IL_000e:  newobj     ""D..ctor(object, System.IntPtr)""
+  IL_0013:  ldloc.0
+  IL_0014:  ldftn      ""void C.Target()""
+  IL_001a:  newobj     ""D..ctor(object, System.IntPtr)""
+  IL_001f:  callvirt   ""void C.Invoke(D, D)""
+  IL_0024:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Not_Conversions_Instance()
+    {
+        var source = @"
+using System;
+delegate void D();
+class C
+{
+    public static void Main(string[] args)
+    {
+        var c = new C();
+        c.Invoke(c.Target, c.Target);
+    }
+
+    void Target() { Console.WriteLine(""FAIL""); }
+    void Invoke(D x, D y) { Console.Write(Object.ReferenceEquals(x, y) ? ""FAIL"" : ""PASS""); }
+}";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS, symbolValidator: VerifyNoCacheContainersIn("C"));
+        verifier.VerifyIL("C.Main", @"
+{
+  // Code size       37 (0x25)
+  .maxstack  4
+  .locals init (C V_0) //c
+  IL_0000:  newobj     ""C..ctor()""
+  IL_0005:  stloc.0
+  IL_0006:  ldloc.0
+  IL_0007:  ldloc.0
+  IL_0008:  ldftn      ""void C.Target()""
+  IL_000e:  newobj     ""D..ctor(object, System.IntPtr)""
+  IL_0013:  ldloc.0
+  IL_0014:  ldftn      ""void C.Target()""
+  IL_001a:  newobj     ""D..ctor(object, System.IntPtr)""
+  IL_001f:  callvirt   ""void C.Invoke(D, D)""
+  IL_0024:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Not_DelegateCreations_InstanceExtensionMethod()
+    {
+        var source = @"
+using System;
+delegate void D();
+class C
+{
+    public static void Main(string[] args)
+    {
+        var c = new C();
+        c.Invoke(new D(c.Target), new D(c.Target));
+    }
+
+    void Invoke(D x, D y) { Console.Write(Object.ReferenceEquals(x, y) ? ""FAIL"" : ""PASS""); }
+}
+static class E
+{
+    public static void Target(this C that) { Console.WriteLine(""FAIL""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS, symbolValidator: VerifyNoCacheContainersIn("C"));
+        verifier.VerifyIL("C.Main", @"
+{
+  // Code size       37 (0x25)
+  .maxstack  4
+  .locals init (C V_0) //c
+  IL_0000:  newobj     ""C..ctor()""
+  IL_0005:  stloc.0
+  IL_0006:  ldloc.0
+  IL_0007:  ldloc.0
+  IL_0008:  ldftn      ""void E.Target(C)""
+  IL_000e:  newobj     ""D..ctor(object, System.IntPtr)""
+  IL_0013:  ldloc.0
+  IL_0014:  ldftn      ""void E.Target(C)""
+  IL_001a:  newobj     ""D..ctor(object, System.IntPtr)""
+  IL_001f:  callvirt   ""void C.Invoke(D, D)""
+  IL_0024:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Not_Conversions_InstanceExtensionMethod()
+    {
+        var source = @"
+using System;
+delegate void D();
+class C
+{
+    public static void Main(string[] args)
+    {
+        var c = new C();
+        c.Invoke(c.Target, c.Target);
+    }
+
+    void Invoke(D x, D y) { Console.Write(Object.ReferenceEquals(x, y) ? ""FAIL"" : ""PASS""); }
+}
+static class E
+{
+    public static void Target(this C that) { Console.WriteLine(""FAIL""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS, symbolValidator: VerifyNoCacheContainersIn("C"));
+        verifier.VerifyIL("C.Main", @"
+{
+  // Code size       37 (0x25)
+  .maxstack  4
+  .locals init (C V_0) //c
+  IL_0000:  newobj     ""C..ctor()""
+  IL_0005:  stloc.0
+  IL_0006:  ldloc.0
+  IL_0007:  ldloc.0
+  IL_0008:  ldftn      ""void E.Target(C)""
+  IL_000e:  newobj     ""D..ctor(object, System.IntPtr)""
+  IL_0013:  ldloc.0
+  IL_0014:  ldftn      ""void E.Target(C)""
+  IL_001a:  newobj     ""D..ctor(object, System.IntPtr)""
+  IL_001f:  callvirt   ""void C.Invoke(D, D)""
+  IL_0024:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Not_DelegateCreations_StaticExtensionMethod()
+    {
+        var source = @"
+using System;
+delegate void D(C arg);
+class C
+{
+    public static void Main(string[] args)
+    {
+        var c = new C();
+        c.Invoke(new D(E.Target), new D(E.Target));
+    }
+
+    void Invoke(D x, D y) { Console.Write(Object.ReferenceEquals(x, y) ? ""FAIL"" : ""PASS""); }
+}
+static class E
+{
+    public static void Target(this C that) { Console.WriteLine(""FAIL""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS, symbolValidator: VerifyNoCacheContainersIn("C"));
+        verifier.VerifyIL("C.Main", @"
+{
+  // Code size       35 (0x23)
+  .maxstack  4
+  IL_0000:  newobj     ""C..ctor()""
+  IL_0005:  ldnull
+  IL_0006:  ldftn      ""void E.Target(C)""
+  IL_000c:  newobj     ""D..ctor(object, System.IntPtr)""
+  IL_0011:  ldnull
+  IL_0012:  ldftn      ""void E.Target(C)""
+  IL_0018:  newobj     ""D..ctor(object, System.IntPtr)""
+  IL_001d:  callvirt   ""void C.Invoke(D, D)""
+  IL_0022:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Not_InExpressionLamba0()
+    {
+        var source = @"
+using System;
+using System.Linq.Expressions;
+class C
+{
+    public static void Main(string[] args)
+    {
+        Expression<Func<int, Func<int, int>>> e = x => Target;
+        Console.WriteLine(e);
+    }
+
+    static int Target(int x) => 0;
+}
+";
+        var verifier = CompileAndVerify(source
+#if NETFRAMEWORK
+            , expectedOutput: "x => Convert(Int32 Target(Int32).CreateDelegate(System.Func`2[System.Int32,System.Int32], null))"
+#else
+            , expectedOutput: "x => Convert(Int32 Target(Int32).CreateDelegate(System.Func`2[System.Int32,System.Int32], null), Func`2)"
+#endif
+            , symbolValidator: VerifyNoCacheContainersIn("C"));
+        verifier.VerifyIL("C.Main", @"
+{
+  // Code size      160 (0xa0)
+  .maxstack  7
+  .locals init (System.Linq.Expressions.ParameterExpression V_0)
+  IL_0000:  ldtoken    ""int""
+  IL_0005:  call       ""System.Type System.Type.GetTypeFromHandle(System.RuntimeTypeHandle)""
+  IL_000a:  ldstr      ""x""
+  IL_000f:  call       ""System.Linq.Expressions.ParameterExpression System.Linq.Expressions.Expression.Parameter(System.Type, string)""
+  IL_0014:  stloc.0
+  IL_0015:  ldtoken    ""int C.Target(int)""
+  IL_001a:  call       ""System.Reflection.MethodBase System.Reflection.MethodBase.GetMethodFromHandle(System.RuntimeMethodHandle)""
+  IL_001f:  castclass  ""System.Reflection.MethodInfo""
+  IL_0024:  ldtoken    ""System.Reflection.MethodInfo""
+  IL_0029:  call       ""System.Type System.Type.GetTypeFromHandle(System.RuntimeTypeHandle)""
+  IL_002e:  call       ""System.Linq.Expressions.ConstantExpression System.Linq.Expressions.Expression.Constant(object, System.Type)""
+  IL_0033:  ldtoken    ""System.Delegate System.Reflection.MethodInfo.CreateDelegate(System.Type, object)""
+  IL_0038:  call       ""System.Reflection.MethodBase System.Reflection.MethodBase.GetMethodFromHandle(System.RuntimeMethodHandle)""
+  IL_003d:  castclass  ""System.Reflection.MethodInfo""
+  IL_0042:  ldc.i4.2
+  IL_0043:  newarr     ""System.Linq.Expressions.Expression""
+  IL_0048:  dup
+  IL_0049:  ldc.i4.0
+  IL_004a:  ldtoken    ""System.Func<int, int>""
+  IL_004f:  call       ""System.Type System.Type.GetTypeFromHandle(System.RuntimeTypeHandle)""
+  IL_0054:  ldtoken    ""System.Type""
+  IL_0059:  call       ""System.Type System.Type.GetTypeFromHandle(System.RuntimeTypeHandle)""
+  IL_005e:  call       ""System.Linq.Expressions.ConstantExpression System.Linq.Expressions.Expression.Constant(object, System.Type)""
+  IL_0063:  stelem.ref
+  IL_0064:  dup
+  IL_0065:  ldc.i4.1
+  IL_0066:  ldnull
+  IL_0067:  ldtoken    ""object""
+  IL_006c:  call       ""System.Type System.Type.GetTypeFromHandle(System.RuntimeTypeHandle)""
+  IL_0071:  call       ""System.Linq.Expressions.ConstantExpression System.Linq.Expressions.Expression.Constant(object, System.Type)""
+  IL_0076:  stelem.ref
+  IL_0077:  call       ""System.Linq.Expressions.MethodCallExpression System.Linq.Expressions.Expression.Call(System.Linq.Expressions.Expression, System.Reflection.MethodInfo, params System.Linq.Expressions.Expression[])""
+  IL_007c:  ldtoken    ""System.Func<int, int>""
+  IL_0081:  call       ""System.Type System.Type.GetTypeFromHandle(System.RuntimeTypeHandle)""
+  IL_0086:  call       ""System.Linq.Expressions.UnaryExpression System.Linq.Expressions.Expression.Convert(System.Linq.Expressions.Expression, System.Type)""
+  IL_008b:  ldc.i4.1
+  IL_008c:  newarr     ""System.Linq.Expressions.ParameterExpression""
+  IL_0091:  dup
+  IL_0092:  ldc.i4.0
+  IL_0093:  ldloc.0
+  IL_0094:  stelem.ref
+  IL_0095:  call       ""System.Linq.Expressions.Expression<System.Func<int, System.Func<int, int>>> System.Linq.Expressions.Expression.Lambda<System.Func<int, System.Func<int, int>>>(System.Linq.Expressions.Expression, params System.Linq.Expressions.ParameterExpression[])""
+  IL_009a:  call       ""void System.Console.WriteLine(object)""
+  IL_009f:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Not_InExpressionLamba1()
+    {
+        var source = @"
+using System;
+using System.Linq.Expressions;
+class C
+{
+    public static void Main(string[] args)
+    {
+        Func<int, Expression<Func<int, Func<int, int>>>> f = x => y => Target;
+        Console.WriteLine(f(0));
+    }
+
+    static int Target(int x) => 0;
+}
+";
+        var verifier = CompileAndVerify(source
+#if NETFRAMEWORK
+            , expectedOutput: "y => Convert(Int32 Target(Int32).CreateDelegate(System.Func`2[System.Int32,System.Int32], null))"
+#else
+            , expectedOutput: "y => Convert(Int32 Target(Int32).CreateDelegate(System.Func`2[System.Int32,System.Int32], null), Func`2)"
+#endif
+            , symbolValidator: VerifyNoCacheContainersIn("C"));
+        verifier.VerifyIL("C.<>c.<Main>b__0_0", @"
+{
+  // Code size      155 (0x9b)
+  .maxstack  7
+  .locals init (System.Linq.Expressions.ParameterExpression V_0)
+  IL_0000:  ldtoken    ""int""
+  IL_0005:  call       ""System.Type System.Type.GetTypeFromHandle(System.RuntimeTypeHandle)""
+  IL_000a:  ldstr      ""y""
+  IL_000f:  call       ""System.Linq.Expressions.ParameterExpression System.Linq.Expressions.Expression.Parameter(System.Type, string)""
+  IL_0014:  stloc.0
+  IL_0015:  ldtoken    ""int C.Target(int)""
+  IL_001a:  call       ""System.Reflection.MethodBase System.Reflection.MethodBase.GetMethodFromHandle(System.RuntimeMethodHandle)""
+  IL_001f:  castclass  ""System.Reflection.MethodInfo""
+  IL_0024:  ldtoken    ""System.Reflection.MethodInfo""
+  IL_0029:  call       ""System.Type System.Type.GetTypeFromHandle(System.RuntimeTypeHandle)""
+  IL_002e:  call       ""System.Linq.Expressions.ConstantExpression System.Linq.Expressions.Expression.Constant(object, System.Type)""
+  IL_0033:  ldtoken    ""System.Delegate System.Reflection.MethodInfo.CreateDelegate(System.Type, object)""
+  IL_0038:  call       ""System.Reflection.MethodBase System.Reflection.MethodBase.GetMethodFromHandle(System.RuntimeMethodHandle)""
+  IL_003d:  castclass  ""System.Reflection.MethodInfo""
+  IL_0042:  ldc.i4.2
+  IL_0043:  newarr     ""System.Linq.Expressions.Expression""
+  IL_0048:  dup
+  IL_0049:  ldc.i4.0
+  IL_004a:  ldtoken    ""System.Func<int, int>""
+  IL_004f:  call       ""System.Type System.Type.GetTypeFromHandle(System.RuntimeTypeHandle)""
+  IL_0054:  ldtoken    ""System.Type""
+  IL_0059:  call       ""System.Type System.Type.GetTypeFromHandle(System.RuntimeTypeHandle)""
+  IL_005e:  call       ""System.Linq.Expressions.ConstantExpression System.Linq.Expressions.Expression.Constant(object, System.Type)""
+  IL_0063:  stelem.ref
+  IL_0064:  dup
+  IL_0065:  ldc.i4.1
+  IL_0066:  ldnull
+  IL_0067:  ldtoken    ""object""
+  IL_006c:  call       ""System.Type System.Type.GetTypeFromHandle(System.RuntimeTypeHandle)""
+  IL_0071:  call       ""System.Linq.Expressions.ConstantExpression System.Linq.Expressions.Expression.Constant(object, System.Type)""
+  IL_0076:  stelem.ref
+  IL_0077:  call       ""System.Linq.Expressions.MethodCallExpression System.Linq.Expressions.Expression.Call(System.Linq.Expressions.Expression, System.Reflection.MethodInfo, params System.Linq.Expressions.Expression[])""
+  IL_007c:  ldtoken    ""System.Func<int, int>""
+  IL_0081:  call       ""System.Type System.Type.GetTypeFromHandle(System.RuntimeTypeHandle)""
+  IL_0086:  call       ""System.Linq.Expressions.UnaryExpression System.Linq.Expressions.Expression.Convert(System.Linq.Expressions.Expression, System.Type)""
+  IL_008b:  ldc.i4.1
+  IL_008c:  newarr     ""System.Linq.Expressions.ParameterExpression""
+  IL_0091:  dup
+  IL_0092:  ldc.i4.0
+  IL_0093:  ldloc.0
+  IL_0094:  stelem.ref
+  IL_0095:  call       ""System.Linq.Expressions.Expression<System.Func<int, System.Func<int, int>>> System.Linq.Expressions.Expression.Lambda<System.Func<int, System.Func<int, int>>>(System.Linq.Expressions.Expression, params System.Linq.Expressions.ParameterExpression[])""
+  IL_009a:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Not_InStaticConstructor0()
+    {
+        var source = @"
+using System;
+class C
+{
+    static readonly Action ManualCache = Target;
+    static void Target() { }
+}
+";
+        var verifier = CompileAndVerify(source, symbolValidator: VerifyNoCacheContainersIn("C"));
+        verifier.VerifyIL("C..cctor", @"
+{
+  // Code size       18 (0x12)
+  .maxstack  2
+  IL_0000:  ldnull
+  IL_0001:  ldftn      ""void C.Target()""
+  IL_0007:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_000c:  stsfld     ""System.Action C.ManualCache""
+  IL_0011:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Not_InStaticConstructor1()
+    {
+        var source = @"
+using System;
+struct C
+{
+    static readonly Action ManualCache;
+    static void Target() { }
+
+    static C()
+    {
+        ManualCache = Target;
+    }
+}
+";
+        var verifier = CompileAndVerify(source, symbolValidator: VerifyNoCacheContainersIn("C"));
+        verifier.VerifyIL("C..cctor", @"
+{
+  // Code size       18 (0x12)
+  .maxstack  2
+  IL_0000:  ldnull
+  IL_0001:  ldftn      ""void C.Target()""
+  IL_0007:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_000c:  stsfld     ""System.Action C.ManualCache""
+  IL_0011:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Not_TargetTypedNew0()
+    {
+        var source = @"
+using System;
+
+Action f = new(Target);
+f();
+
+static void Target() { Console.WriteLine(""PASS""); }
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS, symbolValidator: VerifyNoCacheContainersIn("Program"));
+        verifier.VerifyIL("<top-level-statements-entry-point>", @"
+{
+  // Code size       18 (0x12)
+  .maxstack  2
+  IL_0000:  ldnull
+  IL_0001:  ldftn      ""void Program.<<Main>$>g__Target|0_0()""
+  IL_0007:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_000c:  callvirt   ""void System.Action.Invoke()""
+  IL_0011:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Not_TargetTypedNew1()
+    {
+        var source = @"
+#nullable enable
+using System;
+
+Action? f = new(Target);
+f();
+
+static void Target() { Console.WriteLine(""PASS""); }
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS, symbolValidator: VerifyNoCacheContainersIn("Program"));
+        verifier.VerifyIL("<top-level-statements-entry-point>", @"
+{
+  // Code size       18 (0x12)
+  .maxstack  2
+  IL_0000:  ldnull
+  IL_0001:  ldftn      ""void Program.<<Main>$>g__Target|0_0()""
+  IL_0007:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_000c:  callvirt   ""void System.Action.Invoke()""
+  IL_0011:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Not_CSharp10()
+    {
+        var source = @"
+var f = Target;
+f();
+static void Target() { }
+";
+        var verifier = CompileAndVerify(source, parseOptions: TestOptions.Regular10, symbolValidator: VerifyNoCacheContainersIn("Program"));
+        verifier.VerifyIL("<top-level-statements-entry-point>", @"
+{
+  // Code size       18 (0x12)
+  .maxstack  2
+  IL_0000:  ldnull
+  IL_0001:  ldftn      ""void Program.<<Main>$>g__Target|0_0()""
+  IL_0007:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_000c:  callvirt   ""void System.Action.Invoke()""
+  IL_0011:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheExplicitConversions_TypeScoped_CouldBeModuleScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        Test((Action)Target);
+    }
+
+    static void Test(Action action)
+    {
+        action();
+    }
+
+    static void Target() { Console.WriteLine(""PASS""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("C.Main", @"
+{
+  // Code size       33 (0x21)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action C.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void C.Target()""
+  IL_0010:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action C.<>O.<0>__Target""
+  IL_001b:  call       ""void C.Test(System.Action)""
+  IL_0020:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheExplicitConversions_TypeScoped_CouldBeModuleScoped1()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        var d = new D<int>();
+        d.Test()();
+    }
+
+    public static void Target() { Console.WriteLine(""PASS""); }
+}
+class D<T>
+{
+    public Action Test()
+    {
+        return (Action)C.Target;
+    }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.Test", @"
+{
+  // Code size       28 (0x1c)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void C.Target()""
+  IL_0010:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action D<T>.<>O.<0>__Target""
+  IL_001b:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheExplicitConversions_TypeScoped_CouldBeModuleScoped2()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<int>()).Test();
+    }
+}
+class D<T>
+{
+    public void Test()
+    {
+        var t = (Action)E<int>.Target;
+        t();
+    }
+}
+class E<V>
+{
+    public static void Target() { Console.WriteLine(""PASS""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.Test", @"
+{
+  // Code size       33 (0x21)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void E<int>.Target()""
+  IL_0010:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action D<T>.<>O.<0>__Target""
+  IL_001b:  callvirt   ""void System.Action.Invoke()""
+  IL_0020:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheExplicitConversions_TypeScoped_CouldBeModuleScoped3()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<int>()).Test();
+    }
+}
+class D<T>
+{
+    public void Test()
+    {
+        var t = (Action<int>)E<int>.Target;
+        t(0);
+    }
+}
+class E<V>
+{
+    public static void Target(V v) { Console.WriteLine(""PASS""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.Test", @"
+{
+  // Code size       34 (0x22)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action<int> D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void E<int>.Target(int)""
+  IL_0010:  newobj     ""System.Action<int>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action<int> D<T>.<>O.<0>__Target""
+  IL_001b:  ldc.i4.0
+  IL_001c:  callvirt   ""void System.Action<int>.Invoke(int)""
+  IL_0021:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheExplicitConversions_TypeScoped_CouldBeModuleScoped4()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<int>()).Test();
+    }
+}
+class D<T>
+{
+    public void Test()
+    {
+        var t = (Action<int>)E<int>.Target<double>;
+        t(0);
+    }
+}
+class E<V>
+{
+    public static void Target<K>(V v) { Console.WriteLine(""PASS""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.Test", @"
+{
+  // Code size       34 (0x22)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action<int> D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void E<int>.Target<double>(int)""
+  IL_0010:  newobj     ""System.Action<int>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action<int> D<T>.<>O.<0>__Target""
+  IL_001b:  ldc.i4.0
+  IL_001c:  callvirt   ""void System.Action<int>.Invoke(int)""
+  IL_0021:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheExplicitConversions_TypeScoped_CouldBeModuleScoped5()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<int>()).Test();
+    }
+}
+class D<T>
+{
+    public void Test()
+    {
+        var t = (Func<int, int>)E<int>.Target<double>;
+        t(0);
+    }
+}
+class E<V>
+{
+    public static V Target<K>(V v) { Console.WriteLine(""PASS""); return default(V); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.Test", @"
+{
+  // Code size       35 (0x23)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<int, int> D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""int E<int>.Target<double>(int)""
+  IL_0010:  newobj     ""System.Func<int, int>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<int, int> D<T>.<>O.<0>__Target""
+  IL_001b:  ldc.i4.0
+  IL_001c:  callvirt   ""int System.Func<int, int>.Invoke(int)""
+  IL_0021:  pop
+  IL_0022:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheExplicitConversions_TypeScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<int>()).Test();
+    }
+}
+class D<T>
+{
+    public void Test()
+    {
+        var t = (Action)Target;
+        t();
+    }
+
+    static void Target() { Console.WriteLine(""PASS""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.Test", @"
+{
+  // Code size       33 (0x21)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void D<T>.Target()""
+  IL_0010:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action D<T>.<>O.<0>__Target""
+  IL_001b:  callvirt   ""void System.Action.Invoke()""
+  IL_0020:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheExplicitConversions_TypeScoped1()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<int>()).Test();
+    }
+}
+class D<T>
+{
+    public void Test()
+    {
+        var t = (Action)Target<int>;
+        t();
+    }
+
+    static void Target<K>() { Console.WriteLine(""PASS""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.Test", @"
+{
+  // Code size       33 (0x21)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void D<T>.Target<int>()""
+  IL_0010:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action D<T>.<>O.<0>__Target""
+  IL_001b:  callvirt   ""void System.Action.Invoke()""
+  IL_0020:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheExplicitConversions_TypeScoped2()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<int>()).Test();
+    }
+}
+class D<T>
+{
+    public void Test()
+    {
+        var t = (Action)Target<T>;
+        t();
+    }
+
+    static void Target<K>() { Console.WriteLine(""PASS""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.Test", @"
+{
+  // Code size       33 (0x21)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void D<T>.Target<T>()""
+  IL_0010:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action D<T>.<>O.<0>__Target""
+  IL_001b:  callvirt   ""void System.Action.Invoke()""
+  IL_0020:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheExplicitConversions_TypeScoped3()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<int>()).Test();
+    }
+}
+class D<T>
+{
+    public void Test()
+    {
+        var t = (Action)E<T>.Target;
+        t();
+    }
+}
+class E<V>
+{
+    public static void Target() { Console.WriteLine(""PASS""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.Test", @"
+{
+  // Code size       33 (0x21)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void E<T>.Target()""
+  IL_0010:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action D<T>.<>O.<0>__Target""
+  IL_001b:  callvirt   ""void System.Action.Invoke()""
+  IL_0020:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheExplicitConversions_TypeScoped4()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<int>()).Test();
+    }
+}
+class D<T>
+{
+    public void Test()
+    {
+        var t = (Action)E<T>.Target<double>;
+        t();
+    }
+}
+class E<V>
+{
+    public static void Target<N>() { Console.WriteLine(""PASS""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.Test", @"
+{
+  // Code size       33 (0x21)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void E<T>.Target<double>()""
+  IL_0010:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action D<T>.<>O.<0>__Target""
+  IL_001b:  callvirt   ""void System.Action.Invoke()""
+  IL_0020:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheExplicitConversions_TypeScoped5()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<int>()).Test();
+    }
+}
+class D<T>
+{
+    public void Test()
+    {
+        var t = (Func<T>)E<int>.Target<T>;
+        t();
+    }
+}
+class E<V>
+{
+    public static N Target<N>() { Console.WriteLine(""PASS""); return default(N); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.Test", @"
+{
+  // Code size       34 (0x22)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<T> D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""T E<int>.Target<T>()""
+  IL_0010:  newobj     ""System.Func<T>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<T> D<T>.<>O.<0>__Target""
+  IL_001b:  callvirt   ""T System.Func<T>.Invoke()""
+  IL_0020:  pop
+  IL_0021:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheExplicitConversions_TypeScoped6()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<int>()).Test();
+    }
+}
+class D<T>
+{
+    public void Test()
+    {
+        var t = (Func<int>)E<T>.Target<int>;
+        t();
+    }
+}
+class E<K>
+{
+    public static V Target<V>() { Console.WriteLine(""PASS""); return default(V); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.Test", @"
+{
+  // Code size       34 (0x22)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<int> D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""int E<T>.Target<int>()""
+  IL_0010:  newobj     ""System.Func<int>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<int> D<T>.<>O.<0>__Target""
+  IL_001b:  callvirt   ""int System.Func<int>.Invoke()""
+  IL_0020:  pop
+  IL_0021:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheExplicitConversions_TypeScoped7()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<int>()).Test();
+    }
+}
+class D<T>
+{
+    public void Test()
+    {
+        var t = (Func<T, int>)E<T>.Target<int>;
+        t(default(T));
+    }
+}
+class E<K>
+{
+    public static V Target<V>(K k) { Console.WriteLine(""PASS""); return default(V); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.Test", @"
+{
+  // Code size       43 (0x2b)
+  .maxstack  2
+  .locals init (T V_0)
+  IL_0000:  ldsfld     ""System.Func<T, int> D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""int E<T>.Target<int>(T)""
+  IL_0010:  newobj     ""System.Func<T, int>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<T, int> D<T>.<>O.<0>__Target""
+  IL_001b:  ldloca.s   V_0
+  IL_001d:  initobj    ""T""
+  IL_0023:  ldloc.0
+  IL_0024:  callvirt   ""int System.Func<T, int>.Invoke(T)""
+  IL_0029:  pop
+  IL_002a:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheExplicitConversions_MethodScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        D.Test<int>();
+    }
+
+    public static void Target<K>() { Console.WriteLine(""PASS""); }
+}
+class D
+{
+    public static void Test<T>()
+    {
+        var t = (Action)C.Target<T>;
+        t();
+    }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D.Test<T>", @"
+{
+  // Code size       33 (0x21)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action D.<Test>O__0_0<T>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void C.Target<T>()""
+  IL_0010:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action D.<Test>O__0_0<T>.<0>__Target""
+  IL_001b:  callvirt   ""void System.Action.Invoke()""
+  IL_0020:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheExplicitConversions_MethodScoped1()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D()).Test<int>();
+    }
+}
+class D
+{
+    public void Test<T>()
+    {
+        var t = (Action)E<T>.Target;
+        t();
+    }
+}
+class E<K>
+{
+    public static void Target() { Console.WriteLine(""PASS""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D.Test<T>", @"
+{
+  // Code size       33 (0x21)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action D.<Test>O__0_0<T>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void E<T>.Target()""
+  IL_0010:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action D.<Test>O__0_0<T>.<0>__Target""
+  IL_001b:  callvirt   ""void System.Action.Invoke()""
+  IL_0020:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheExplicitConversions_MethodScoped2()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D()).Test<int>();
+    }
+}
+class D
+{
+    public void Test<T>()
+    {
+        var t = (Func<T, int>)E<T>.Target<int>;
+        t(default(T));
+    }
+}
+class E<K>
+{
+    public static V Target<V>(K k) { Console.WriteLine(""PASS""); return default(V); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D.Test<T>", @"
+{
+  // Code size       43 (0x2b)
+  .maxstack  2
+  .locals init (T V_0)
+  IL_0000:  ldsfld     ""System.Func<T, int> D.<Test>O__0_0<T>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""int E<T>.Target<int>(T)""
+  IL_0010:  newobj     ""System.Func<T, int>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<T, int> D.<Test>O__0_0<T>.<0>__Target""
+  IL_001b:  ldloca.s   V_0
+  IL_001d:  initobj    ""T""
+  IL_0023:  ldloc.0
+  IL_0024:  callvirt   ""int System.Func<T, int>.Invoke(T)""
+  IL_0029:  pop
+  IL_002a:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheExplicitConversions_MethodScoped3()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<long>()).Test<int>();
+    }
+}
+class D<M>
+{
+    public void Test<T>()
+    {
+        var t = (Action<M, T>)E<M>.Target<T>;
+        t(default(M), default(T));
+    }
+}
+class E<K>
+{
+    public static void Target<V>(K k, V v) { Console.WriteLine(""PASS""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<M>.Test<T>", @"
+{
+  // Code size       51 (0x33)
+  .maxstack  3
+  .locals init (M V_0,
+                T V_1)
+  IL_0000:  ldsfld     ""System.Action<M, T> D<M>.<Test>O__0_0<T>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void E<M>.Target<T>(M, T)""
+  IL_0010:  newobj     ""System.Action<M, T>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action<M, T> D<M>.<Test>O__0_0<T>.<0>__Target""
+  IL_001b:  ldloca.s   V_0
+  IL_001d:  initobj    ""M""
+  IL_0023:  ldloc.0
+  IL_0024:  ldloca.s   V_1
+  IL_0026:  initobj    ""T""
+  IL_002c:  ldloc.1
+  IL_002d:  callvirt   ""void System.Action<M, T>.Invoke(M, T)""
+  IL_0032:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheImplicitConversions_TypeScoped_CouldBeModuleScoped0()
+    {
+        var source = @"
+using System;
+delegate void MyAction<T>();
+class C
+{
+    public static void Main(string[] args)
+    {
+        MyAction<int> t = Target;
+        t();
+    }
+
+    static void Target() { Console.WriteLine(""PASS""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("C.Main", @"
+{
+  // Code size       33 (0x21)
+  .maxstack  2
+  IL_0000:  ldsfld     ""MyAction<int> C.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void C.Target()""
+  IL_0010:  newobj     ""MyAction<int>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""MyAction<int> C.<>O.<0>__Target""
+  IL_001b:  callvirt   ""void MyAction<int>.Invoke()""
+  IL_0020:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheImplicitConversions_TypeScoped_CouldBeModuleScoped1()
+    {
+        var source = @"
+using System;
+class C
+{
+    public delegate void MyAction<T>();
+
+    public static void Main(string[] args)
+    {
+        MyAction<int> t = Target;
+        t();
+    }
+
+    static void Target() { Console.WriteLine(""PASS""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("C.Main", @"
+{
+  // Code size       33 (0x21)
+  .maxstack  2
+  IL_0000:  ldsfld     ""C.MyAction<int> C.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void C.Target()""
+  IL_0010:  newobj     ""C.MyAction<int>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""C.MyAction<int> C.<>O.<0>__Target""
+  IL_001b:  callvirt   ""void C.MyAction<int>.Invoke()""
+  IL_0020:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheImplicitConversions_TypeScoped0()
+    {
+        var source = @"
+using System;
+delegate void MyAction();
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<int>()).Test();
+    }
+}
+class D<T>
+{
+    public void Test()
+    {
+        MyAction t = Target;
+        t();
+    }
+
+    public static void Target() { Console.WriteLine(""PASS""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.Test", @"
+{
+  // Code size       33 (0x21)
+  .maxstack  2
+  IL_0000:  ldsfld     ""MyAction D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void D<T>.Target()""
+  IL_0010:  newobj     ""MyAction..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""MyAction D<T>.<>O.<0>__Target""
+  IL_001b:  callvirt   ""void MyAction.Invoke()""
+  IL_0020:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheImplicitConversions_TypeScoped1()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<int>()).Test()();
+    }
+}
+class D<T>
+{
+    public delegate void MyAction();
+
+    public MyAction Test()
+    {
+        return Target<int>;
+    }
+
+    static void Target<K>() { Console.WriteLine(""PASS""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.Test", @"
+{
+  // Code size       28 (0x1c)
+  .maxstack  2
+  IL_0000:  ldsfld     ""D<T>.MyAction D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void D<T>.Target<int>()""
+  IL_0010:  newobj     ""D<T>.MyAction..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""D<T>.MyAction D<T>.<>O.<0>__Target""
+  IL_001b:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheImplicitConversions_TypeScoped2()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<int>()).Test();
+    }
+}
+class D<T>
+{
+    delegate void MyAction<M>();
+
+    public void Test()
+    {
+        MyAction<int> t = Target<T>;
+        t();
+    }
+
+    static void Target<K>() { Console.WriteLine(""PASS""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.Test", @"
+{
+  // Code size       33 (0x21)
+  .maxstack  2
+  IL_0000:  ldsfld     ""D<T>.MyAction<int> D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void D<T>.Target<T>()""
+  IL_0010:  newobj     ""D<T>.MyAction<int>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""D<T>.MyAction<int> D<T>.<>O.<0>__Target""
+  IL_001b:  callvirt   ""void D<T>.MyAction<int>.Invoke()""
+  IL_0020:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheImplicitConversions_TypeScoped3()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<int>()).Test();
+    }
+}
+class D<T>
+{
+    delegate void MyAction<M>();
+
+    public void Test()
+    {
+        MyAction<T> t = E<T>.Target;
+        t();
+    }
+}
+class E<V>
+{
+    public static void Target() { Console.WriteLine(""PASS""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.Test", @"
+{
+  // Code size       33 (0x21)
+  .maxstack  2
+  IL_0000:  ldsfld     ""D<T>.MyAction<T> D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void E<T>.Target()""
+  IL_0010:  newobj     ""D<T>.MyAction<T>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""D<T>.MyAction<T> D<T>.<>O.<0>__Target""
+  IL_001b:  callvirt   ""void D<T>.MyAction<T>.Invoke()""
+  IL_0020:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheImplicitConversions_TypeScoped4()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<int>()).Test();
+    }
+}
+class D<T>
+{
+    delegate void MyAction<M>();
+
+    public void Test()
+    {
+        MyAction<T> t = E<T>.Target<int>;
+        t();
+    }
+}
+class E<V>
+{
+    public static void Target<N>() { Console.WriteLine(""PASS""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.Test", @"
+{
+  // Code size       33 (0x21)
+  .maxstack  2
+  IL_0000:  ldsfld     ""D<T>.MyAction<T> D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void E<T>.Target<int>()""
+  IL_0010:  newobj     ""D<T>.MyAction<T>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""D<T>.MyAction<T> D<T>.<>O.<0>__Target""
+  IL_001b:  callvirt   ""void D<T>.MyAction<T>.Invoke()""
+  IL_0020:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheImplicitConversions_TypeScoped5()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<int>()).Test();
+    }
+}
+class D<T>
+{
+    delegate T MyFunc();
+
+    public void Test()
+    {
+        MyFunc t = E<T>.Target<T, int>;
+        t();
+    }
+}
+class E<K>
+{
+    public static V Target<V, K>() { Console.WriteLine(""PASS""); return default(V); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.Test", @"
+{
+  // Code size       34 (0x22)
+  .maxstack  2
+  IL_0000:  ldsfld     ""D<T>.MyFunc D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""T E<T>.Target<T, int>()""
+  IL_0010:  newobj     ""D<T>.MyFunc..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""D<T>.MyFunc D<T>.<>O.<0>__Target""
+  IL_001b:  callvirt   ""T D<T>.MyFunc.Invoke()""
+  IL_0020:  pop
+  IL_0021:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheImplicitConversions_TypeScoped6()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<int>()).Test();
+    }
+}
+class D<T>
+{
+    delegate int MyFunc(T i);
+
+    public void Test()
+    {
+        MyFunc t = E<T>.Target<int>;
+        t(default(T));
+    }
+}
+class E<K>
+{
+    public static V Target<V>(K k) { Console.WriteLine(""PASS""); return default(V); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.Test", @"
+{
+  // Code size       43 (0x2b)
+  .maxstack  2
+  .locals init (T V_0)
+  IL_0000:  ldsfld     ""D<T>.MyFunc D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""int E<T>.Target<int>(T)""
+  IL_0010:  newobj     ""D<T>.MyFunc..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""D<T>.MyFunc D<T>.<>O.<0>__Target""
+  IL_001b:  ldloca.s   V_0
+  IL_001d:  initobj    ""T""
+  IL_0023:  ldloc.0
+  IL_0024:  callvirt   ""int D<T>.MyFunc.Invoke(T)""
+  IL_0029:  pop
+  IL_002a:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheImplicitConversions_TypeScoped7()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<int, double>()).Test();
+    }
+}
+class D<T, M>
+{
+    delegate T MyFunc(M m);
+
+    public void Test()
+    {
+        MyFunc t = E<M>.Target<T>;
+        t(default(M));
+    }
+}
+class E<K>
+{
+    public static V Target<V>(K k) { Console.WriteLine(""PASS""); return default(V); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T, M>.Test", @"
+{
+  // Code size       43 (0x2b)
+  .maxstack  2
+  .locals init (M V_0)
+  IL_0000:  ldsfld     ""D<T, M>.MyFunc D<T, M>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""T E<M>.Target<T>(M)""
+  IL_0010:  newobj     ""D<T, M>.MyFunc..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""D<T, M>.MyFunc D<T, M>.<>O.<0>__Target""
+  IL_001b:  ldloca.s   V_0
+  IL_001d:  initobj    ""M""
+  IL_0023:  ldloc.0
+  IL_0024:  callvirt   ""T D<T, M>.MyFunc.Invoke(M)""
+  IL_0029:  pop
+  IL_002a:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheImplicitConversions_TypeScoped8()
+    {
+        var source = @"
+using System;
+class C
+{
+    delegate void MyAction<T>();
+
+    public static void Main(string[] args)
+    {
+        MyAction<int> t = Target;
+        t();
+    }
+
+    static void Target() { Console.WriteLine(""PASS""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("C.Main", @"
+{
+  // Code size       33 (0x21)
+  .maxstack  2
+  IL_0000:  ldsfld     ""C.MyAction<int> C.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void C.Target()""
+  IL_0010:  newobj     ""C.MyAction<int>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""C.MyAction<int> C.<>O.<0>__Target""
+  IL_001b:  callvirt   ""void C.MyAction<int>.Invoke()""
+  IL_0020:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheImplicitConversions_MethodScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D()).Test<int>();
+    }
+
+    public static void Target<K>() { Console.WriteLine(""PASS""); }
+}
+class D
+{
+    delegate void MyAction();
+
+    public void Test<T>()
+    {
+        MyAction t = C.Target<T>;
+        t();
+    }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D.Test<T>", @"
+{
+  // Code size       33 (0x21)
+  .maxstack  2
+  IL_0000:  ldsfld     ""D.MyAction D.<Test>O__1_0<T>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void C.Target<T>()""
+  IL_0010:  newobj     ""D.MyAction..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""D.MyAction D.<Test>O__1_0<T>.<0>__Target""
+  IL_001b:  callvirt   ""void D.MyAction.Invoke()""
+  IL_0020:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheImplicitConversions_MethodScoped1()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<int>()).Test<int>();
+    }
+
+    public static void Target<K, N>(K k) { Console.WriteLine(""PASS""); }
+}
+class D<V>
+{
+    delegate void MyAction<M>(M m);
+
+    public void Test<T>()
+    {
+        MyAction<V> t = C.Target<V, T>;
+        t(default(V));
+    }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<V>.Test<T>", @"
+{
+  // Code size       42 (0x2a)
+  .maxstack  2
+  .locals init (V V_0)
+  IL_0000:  ldsfld     ""D<V>.MyAction<V> D<V>.<Test>O__1_0<T>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void C.Target<V, T>(V)""
+  IL_0010:  newobj     ""D<V>.MyAction<V>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""D<V>.MyAction<V> D<V>.<Test>O__1_0<T>.<0>__Target""
+  IL_001b:  ldloca.s   V_0
+  IL_001d:  initobj    ""V""
+  IL_0023:  ldloc.0
+  IL_0024:  callvirt   ""void D<V>.MyAction<V>.Invoke(V)""
+  IL_0029:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CacheImplicitConversions_MethodScoped2()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<byte>()).Test<int>();
+    }
+
+    public static N Target<K, N>(K k, N n) { Console.WriteLine(""PASS""); return default(N); }
+}
+class D<V>
+{
+    delegate V MyFunc<M>(M m, V v);
+
+    public void Test<T>()
+    {
+        MyFunc<T> t = C.Target<T, V>;
+        t(default(T), default(V));
+    }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<V>.Test<T>", @"
+{
+  // Code size       52 (0x34)
+  .maxstack  3
+  .locals init (T V_0,
+                V V_1)
+  IL_0000:  ldsfld     ""D<V>.MyFunc<T> D<V>.<Test>O__1_0<T>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""V C.Target<T, V>(T, V)""
+  IL_0010:  newobj     ""D<V>.MyFunc<T>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""D<V>.MyFunc<T> D<V>.<Test>O__1_0<T>.<0>__Target""
+  IL_001b:  ldloca.s   V_0
+  IL_001d:  initobj    ""T""
+  IL_0023:  ldloc.0
+  IL_0024:  ldloca.s   V_1
+  IL_0026:  initobj    ""V""
+  IL_002c:  ldloc.1
+  IL_002d:  callvirt   ""V D<V>.MyFunc<T>.Invoke(T, V)""
+  IL_0032:  pop
+  IL_0033:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Where_TypeScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<C>()).Test();
+    }
+}
+class D<T> where T : C
+{
+    delegate void MyAction(T t);
+
+    public void Test()
+    {
+        MyAction t = E<int>.Target<C>;
+        t(null);
+    }
+}
+class E<V>
+{
+    public static void Target<N>(N n) { Console.WriteLine(""PASS""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.Test", @"
+{
+  // Code size       42 (0x2a)
+  .maxstack  2
+  .locals init (T V_0)
+  IL_0000:  ldsfld     ""D<T>.MyAction D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void E<int>.Target<C>(C)""
+  IL_0010:  newobj     ""D<T>.MyAction..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""D<T>.MyAction D<T>.<>O.<0>__Target""
+  IL_001b:  ldloca.s   V_0
+  IL_001d:  initobj    ""T""
+  IL_0023:  ldloc.0
+  IL_0024:  callvirt   ""void D<T>.MyAction.Invoke(T)""
+  IL_0029:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Where_MethodScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D<C>()).Test(new C());
+    }
+}
+class D<T> where T : C
+{
+    delegate T MyFunc();
+
+    public void Test<M>(M m) where M : T
+    {
+        MyFunc t = E<int>.Target<M>;
+        t();
+    }
+}
+class E<V>
+{
+    public static N Target<N>() { Console.WriteLine(""PASS""); return default(N); }
+}
+";
+        static void containerValidator(ModuleSymbol module)
+        {
+            var testClass = module.GlobalNamespace.GetTypeMember("D");
+            var container = testClass.GetTypeMember("<Test>O__1_0");
+            AssertEx.NotNull(container);
+
+            var typeParameters = container.TypeParameters;
+            Assert.Equal(1, container.TypeParameters.Length);
+
+            var m = typeParameters[0];
+            Assert.Equal(1, m.ConstraintTypes().Length);
+            Assert.Equal(testClass.TypeParameters[0], m.ConstraintTypes()[0]);
+        }
+        CompileAndVerify(source, symbolValidator: containerValidator, expectedOutput: PASS).VerifyIL("D<T>.Test<M>", @"
+{
+  // Code size       34 (0x22)
+  .maxstack  2
+  IL_0000:  ldsfld     ""D<T>.MyFunc D<T>.<Test>O__1_0<M>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""M E<int>.Target<M>()""
+  IL_0010:  newobj     ""D<T>.MyFunc..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""D<T>.MyFunc D<T>.<Test>O__1_0<M>.<0>__Target""
+  IL_001b:  callvirt   ""T D<T>.MyFunc.Invoke()""
+  IL_0020:  pop
+  IL_0021:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Where_MethodScoped1()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D()).Test(new C());
+    }
+}
+class D
+{
+    delegate C MyFunc();
+
+    public void Test<M>(M m) where M : C
+    {
+        MyFunc t = E<int>.Target<M>;
+        t();
+    }
+}
+class E<V>
+{
+    public static N Target<N>() { Console.WriteLine(""PASS""); return default(N); }
+}
+";
+        static void containerValidator(ModuleSymbol module)
+        {
+            var globalNs = module.GlobalNamespace;
+            var mainClass = globalNs.GetTypeMember("C");
+            var container = globalNs.GetMember<NamedTypeSymbol>("D.<Test>O__1_0");
+            AssertEx.NotNull(container);
+
+            var typeParameters = container.TypeParameters;
+            Assert.Equal(1, container.TypeParameters.Length);
+
+            var m = typeParameters[0];
+            Assert.Equal(1, m.ConstraintTypes().Length);
+            Assert.Equal(mainClass, m.ConstraintTypes()[0]);
+        }
+        CompileAndVerify(source, symbolValidator: containerValidator, expectedOutput: PASS).VerifyIL("D.Test<M>", @"
+{
+  // Code size       34 (0x22)
+  .maxstack  2
+  IL_0000:  ldsfld     ""D.MyFunc D.<Test>O__1_0<M>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""M E<int>.Target<M>()""
+  IL_0010:  newobj     ""D.MyFunc..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""D.MyFunc D.<Test>O__1_0<M>.<0>__Target""
+  IL_001b:  callvirt   ""C D.MyFunc.Invoke()""
+  IL_0020:  pop
+  IL_0021:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Where_MethodScoped2()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        (new D()).Test(0);
+    }
+}
+class D
+{
+    public void Test<M>(M m) where M : struct
+    {
+        Func<M?> t = E.Target<M?>;
+        t();
+    }
+}
+class E
+{
+    public static N Target<N>() { Console.WriteLine(""PASS""); return default(N); }
+}
+";
+        static void containerValidator(ModuleSymbol module)
+        {
+            var container = module.GlobalNamespace.GetMember<NamedTypeSymbol>("D.<Test>O__0_0");
+            AssertEx.NotNull(container);
+
+            var typeParameters = container.TypeParameters;
+            Assert.Equal(1, container.TypeParameters.Length);
+
+            var m = typeParameters[0];
+            AssertEx.NotNull(m);
+            Assert.True(m.IsValueType);
+        }
+        CompileAndVerify(source, symbolValidator: containerValidator, expectedOutput: PASS).VerifyIL("D.Test<M>", @"
+{
+  // Code size       34 (0x22)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<M?> D.<Test>O__0_0<M>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""M? E.Target<M?>()""
+  IL_0010:  newobj     ""System.Func<M?>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<M?> D.<Test>O__0_0<M>.<0>__Target""
+  IL_001b:  callvirt   ""M? System.Func<M?>.Invoke()""
+  IL_0020:  pop
+  IL_0021:  ret
+}
+");
+    }
+
+    [Fact]
+    public void ExtensionMethod_TypeScoped_CouldBeModuleScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        var t = (Action<C>)E.Target;
+        t(null);
+    }
+}
+static class E
+{
+    public static void Target(this C c) { Console.WriteLine(""PASS""); }
+}
+";
+        CompileAndVerify(source, expectedOutput: PASS).VerifyIL("C.Main", @"
+{
+  // Code size       34 (0x22)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action<C> C.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void E.Target(C)""
+  IL_0010:  newobj     ""System.Action<C>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action<C> C.<>O.<0>__Target""
+  IL_001b:  ldnull
+  IL_001c:  callvirt   ""void System.Action<C>.Invoke(C)""
+  IL_0021:  ret
+}
+");
+    }
+
+    [Fact]
+    public void ExtensionMethod_TypeScoped_CouldBeModuleScoped1()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        Action<C> t = E.Target;
+        t(null);
+    }
+}
+static class E
+{
+    public static void Target<T>(this T t) { Console.WriteLine(""PASS""); }
+}
+";
+        CompileAndVerify(source, expectedOutput: PASS).VerifyIL("C.Main", @"
+{
+  // Code size       34 (0x22)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action<C> C.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void E.Target<C>(C)""
+  IL_0010:  newobj     ""System.Action<C>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action<C> C.<>O.<0>__Target""
+  IL_001b:  ldnull
+  IL_001c:  callvirt   ""void System.Action<C>.Invoke(C)""
+  IL_0021:  ret
+}
+");
+    }
+
+    [Fact]
+    public void ExtensionMethod_TypeScoped_CouldBeModuleScoped2()
+    {
+        var source = @"
+using System;
+static class E
+{
+    static void Test()
+    {
+        Action<int> t = Target<int>;
+    }
+
+    public static void Target<T>(this T t) { }
+}
+";
+        CompileAndVerify(source).VerifyIL("E.Test", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action<int> E.<>O.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void E.Target<int>(int)""
+  IL_000e:  newobj     ""System.Action<int>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action<int> E.<>O.<0>__Target""
+  IL_0018:  ret
+}
+");
+    }
+
+    [Fact]
+    public void ExtensionMethod_TypeScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        D<C>.Test();
+    }
+}
+class D<T> where T : C
+{
+    public static void Test()
+    {
+        var t = (Action<T>)E.Target;
+        t(null);
+    }
+}
+static class E
+{
+    public static void Target(this C c) { Console.WriteLine(""PASS""); }
+}
+";
+        CompileAndVerify(source, expectedOutput: PASS).VerifyIL("D<T>.Test", @"
+{
+  // Code size       42 (0x2a)
+  .maxstack  2
+  .locals init (T V_0)
+  IL_0000:  ldsfld     ""System.Action<T> D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void E.Target(C)""
+  IL_0010:  newobj     ""System.Action<T>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action<T> D<T>.<>O.<0>__Target""
+  IL_001b:  ldloca.s   V_0
+  IL_001d:  initobj    ""T""
+  IL_0023:  ldloc.0
+  IL_0024:  callvirt   ""void System.Action<T>.Invoke(T)""
+  IL_0029:  ret
+}
+");
+    }
+
+    [Fact]
+    public void ExtensionMethod_TypeScoped1()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        D<int>.Test(0);
+    }
+}
+class D<K>
+{
+    public static void Test(K k)
+    {
+        Action<K> t = E.Target;
+        t(k);
+    }
+}
+static class E
+{
+    public static void Target<T>(this T t) { Console.WriteLine(""PASS""); }
+}
+";
+        CompileAndVerify(source, expectedOutput: PASS).VerifyIL("D<K>.Test", @"
+{
+  // Code size       34 (0x22)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action<K> D<K>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void E.Target<K>(K)""
+  IL_0010:  newobj     ""System.Action<K>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action<K> D<K>.<>O.<0>__Target""
+  IL_001b:  ldarg.0
+  IL_001c:  callvirt   ""void System.Action<K>.Invoke(K)""
+  IL_0021:  ret
+}
+");
+    }
+
+    [Fact]
+    public void ExtensionMethod_TypeScoped2()
+    {
+        var source = @"
+using System;
+static class E
+{
+    class F<T>
+    {
+        void Test()
+        {
+            Action<T> t = Target<T>;
+        }
+    }
+
+    public static void Target<T>(this T t) { }
+}
+";
+        CompileAndVerify(source).VerifyIL("E.F<T>.Test", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action<T> E.F<T>.<>O.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void E.Target<T>(T)""
+  IL_000e:  newobj     ""System.Action<T>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action<T> E.F<T>.<>O.<0>__Target""
+  IL_0018:  ret
+}
+");
+    }
+
+    [Fact]
+    public void ExtensionMethod_MethodScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        Test(0);
+    }
+
+    static void Test<T>(T arg)
+    {
+        var t = (Action<T>)E.Target;
+        t(arg);
+    }
+}
+static class E
+{
+    public static void Target<M>(this M m) { Console.WriteLine(""PASS""); }
+}
+";
+        CompileAndVerify(source, expectedOutput: PASS).VerifyIL("C.Test<T>", @"
+{
+  // Code size       34 (0x22)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action<T> C.<Test>O__1_0<T>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void E.Target<T>(T)""
+  IL_0010:  newobj     ""System.Action<T>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action<T> C.<Test>O__1_0<T>.<0>__Target""
+  IL_001b:  ldarg.0
+  IL_001c:  callvirt   ""void System.Action<T>.Invoke(T)""
+  IL_0021:  ret
+}
+");
+    }
+
+    [Fact]
+    public void ExtensionMethod_MethodScoped1()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        Test<C>();
+    }
+
+    static void Test<T>() where T : C
+    {
+        var t = (Action<T>)E.Target;
+        t(null);
+    }
+}
+static class E
+{
+    public static void Target(this C c) { Console.WriteLine(""PASS""); }
+}
+";
+        CompileAndVerify(source, expectedOutput: PASS).VerifyIL("C.Test<T>", @"
+{
+  // Code size       42 (0x2a)
+  .maxstack  2
+  .locals init (T V_0)
+  IL_0000:  ldsfld     ""System.Action<T> C.<Test>O__1_0<T>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void E.Target(C)""
+  IL_0010:  newobj     ""System.Action<T>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action<T> C.<Test>O__1_0<T>.<0>__Target""
+  IL_001b:  ldloca.s   V_0
+  IL_001d:  initobj    ""T""
+  IL_0023:  ldloc.0
+  IL_0024:  callvirt   ""void System.Action<T>.Invoke(T)""
+  IL_0029:  ret
+}
+");
+    }
+
+    [Fact]
+    public void ExtensionMethod_MethodScoped2()
+    {
+        var source = @"
+using System;
+static class E
+{
+    static void Test<T>()
+    {
+        Action<T> t = Target<T>;
+    }
+
+    public static void Target<T>(this T t) { }
+}
+";
+        CompileAndVerify(source).VerifyIL("E.Test<T>", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action<T> E.<Test>O__0_0<T>.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void E.Target<T>(T)""
+  IL_000e:  newobj     ""System.Action<T>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action<T> E.<Test>O__0_0<T>.<0>__Target""
+  IL_0018:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Lambda_TypeScoped_CouldBeModuleScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        Action test = () => Invoke(Target);
+        test();
+    }
+
+    static void Invoke(Action a) => a();
+
+    static void Target() => Console.WriteLine(""PASS"");
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("C.<>c.<Main>b__0_0", @"
+{
+  // Code size       33 (0x21)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action C.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void C.Target()""
+  IL_0010:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action C.<>O.<0>__Target""
+  IL_001b:  call       ""void C.Invoke(System.Action)""
+  IL_0020:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Lambda_TypeScoped_CouldBeModuleScoped1()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Main(string[] args)
+    {
+        Action test = () => ((Action)D.Target)();
+        test();
+    }
+}
+class D
+{
+    public static void Target() { Console.WriteLine(""PASS""); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("C.<>c.<Main>b__0_0", @"
+{
+  // Code size       33 (0x21)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action C.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void D.Target()""
+  IL_0010:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action C.<>O.<0>__Target""
+  IL_001b:  callvirt   ""void System.Action.Invoke()""
+  IL_0020:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Lambda_TypeScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    static void Main(string[] args)
+    {
+        D<int>.Test();
+    }
+}
+class D<T>
+{
+    public static void Test()
+    {
+        Action test = () =>
+        {
+            ((Func<T>)Target)();
+        };
+        test();
+    }
+
+    static T Target() { Console.WriteLine(""PASS""); return default(T); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.<>c.<Test>b__0_0", @"
+{
+  // Code size       34 (0x22)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<T> D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""T D<T>.Target()""
+  IL_0010:  newobj     ""System.Func<T>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<T> D<T>.<>O.<0>__Target""
+  IL_001b:  callvirt   ""T System.Func<T>.Invoke()""
+  IL_0020:  pop
+  IL_0021:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Lambda_TypeScoped1()
+    {
+        var source = @"
+using System;
+class C
+{
+    static void Main(string[] args)
+    {
+        D<int>.Test();
+    }
+}
+class D<T>
+{
+    delegate T MyFunc();    
+    public static void Test()
+    {
+        Func<MyFunc> a = () => E.Target<T>;
+        a()();
+    }
+}
+class E
+{
+    public static V Target<V>() { Console.WriteLine(""PASS""); return default(V); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.<>c.<Test>b__1_0", @"
+{
+  // Code size       28 (0x1c)
+  .maxstack  2
+  IL_0000:  ldsfld     ""D<T>.MyFunc D<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""T E.Target<T>()""
+  IL_0010:  newobj     ""D<T>.MyFunc..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""D<T>.MyFunc D<T>.<>O.<0>__Target""
+  IL_001b:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Lambda_MethodScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    static void Main(string[] args)
+    {
+        D<int>.Test(0);
+    }
+}
+class D<T>
+{
+    public static void Test<G>(G g)
+    {
+        Action test = () =>
+        {
+            ((Func<T>)Target<G>)();
+        };
+        test();
+    }
+
+    static T Target<K>() { Console.WriteLine(""PASS""); return default(T); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D<T>.<>c__0<G>.<Test>b__0_0", @"
+{
+  // Code size       34 (0x22)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<T> D<T>.<Test>O__0_0<G>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""T D<T>.Target<G>()""
+  IL_0010:  newobj     ""System.Func<T>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<T> D<T>.<Test>O__0_0<G>.<0>__Target""
+  IL_001b:  callvirt   ""T System.Func<T>.Invoke()""
+  IL_0020:  pop
+  IL_0021:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Lambda_MethodScoped1()
+    {
+        var source = @"
+using System;
+class C
+{
+    static void Main(string[] args)
+    {
+        D.Test(0);
+    }
+}
+class D
+{
+    public static void Test<G>(G g)
+    {
+        Func<Func<G>> a = () => E<G>.Target;
+        a()();
+    }
+}
+class E<V>
+{
+    public static V Target() { Console.WriteLine(""PASS""); return default(V); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS);
+        verifier.VerifyIL("D.<>c__0<G>.<Test>b__0_0", @"
+{
+  // Code size       28 (0x1c)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<G> D.<Test>O__0_0<G>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""G E<G>.Target()""
+  IL_0010:  newobj     ""System.Func<G>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<G> D.<Test>O__0_0<G>.<0>__Target""
+  IL_001b:  ret
+}
+");
+    }
+
+    [Fact]
+    public void SameTypeAndSymbolResultsSameField_TypeScoped0()
+    {
+        var source = @"
+using System;
+class C<T>
+{
+    void Test0() { var t = (Action)D.Target<T>; }
+    void Test1() { Action t = D.Target<T>; }
+}
+class D
+{
+    public static void Target<V>() { }
+}
+";
+        var verifier = CompileAndVerify(source, symbolValidator: VerifyCacheContainer("C.<>O", arity: 0
+            , "System.Action <0>__Target"
+        ));
+        verifier.VerifyIL("C<T>.Test0", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action C<T>.<>O.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void D.Target<T>()""
+  IL_000e:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action C<T>.<>O.<0>__Target""
+  IL_0018:  ret
+}
+");
+        verifier.VerifyIL("C<T>.Test1", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action C<T>.<>O.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void D.Target<T>()""
+  IL_000e:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action C<T>.<>O.<0>__Target""
+  IL_0018:  ret
+}
+");
+    }
+
+    [Fact]
+    public void SameTypeAndSymbolResultsSameField_TypeScoped1()
+    {
+        var source = @"
+using System;
+class C<T>
+{
+    void Test0() { var t = (Func<T>)Target<T>; }
+    void Test1() { Func<T> t = Target<T>; }
+    static V Target<V>() { return default(V); }
+}
+";
+        var verifier = CompileAndVerify(source, symbolValidator: VerifyCacheContainer("C.<>O", arity: 0
+            , "System.Func<T> <0>__Target"
+        ));
+        verifier.VerifyIL("C<T>.Test0", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<T> C<T>.<>O.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""T C<T>.Target<T>()""
+  IL_000e:  newobj     ""System.Func<T>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Func<T> C<T>.<>O.<0>__Target""
+  IL_0018:  ret
+}
+");
+        verifier.VerifyIL("C<T>.Test1", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<T> C<T>.<>O.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""T C<T>.Target<T>()""
+  IL_000e:  newobj     ""System.Func<T>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Func<T> C<T>.<>O.<0>__Target""
+  IL_0018:  ret
+}
+");
+    }
+
+    [Fact]
+    public void SameTypeAndSymbolResultsSameField_TypeScoped2()
+    {
+        var source = @"
+using System;
+class C<T, V>
+{
+    delegate T MyFunc();
+    void Test0() { var t = (MyFunc)Target; }
+    void Test1() { MyFunc t = Target; }
+    static T Target() { return default(T); }
+}
+";
+        var verifier = CompileAndVerify(source, symbolValidator: VerifyCacheContainer("C.<>O", arity: 0
+            , "C<T, V>.MyFunc <0>__Target"
+        ));
+        verifier.VerifyIL("C<T, V>.Test0", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""C<T, V>.MyFunc C<T, V>.<>O.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""T C<T, V>.Target()""
+  IL_000e:  newobj     ""C<T, V>.MyFunc..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""C<T, V>.MyFunc C<T, V>.<>O.<0>__Target""
+  IL_0018:  ret
+}
+");
+        verifier.VerifyIL("C<T, V>.Test1", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""C<T, V>.MyFunc C<T, V>.<>O.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""T C<T, V>.Target()""
+  IL_000e:  newobj     ""C<T, V>.MyFunc..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""C<T, V>.MyFunc C<T, V>.<>O.<0>__Target""
+  IL_0018:  ret
+}
+");
+    }
+
+    [Fact]
+    public void SameTypeAndSymbolResultsSameField_TypeScoped3_CLRSignature()
+    {
+        var source = @"
+#nullable enable
+using System;
+class C<T>
+{
+    void Test0() { var t = (Func<T?>)Target<T?>; }
+    void Test1() { Func<T> t = Target<T>; }
+    static V Target<V>() { return default(V); }
+}
+";
+        var verifier = CompileAndVerify(source, symbolValidator: VerifyCacheContainer("C.<>O", arity: 0
+            , "System.Func<T?> <0>__Target"
+        ));
+        verifier.VerifyIL("C<T>.Test0", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<T> C<T>.<>O.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""T C<T>.Target<T>()""
+  IL_000e:  newobj     ""System.Func<T>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Func<T> C<T>.<>O.<0>__Target""
+  IL_0018:  ret
+}
+");
+        verifier.VerifyIL("C<T>.Test1", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<T> C<T>.<>O.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""T C<T>.Target<T>()""
+  IL_000e:  newobj     ""System.Func<T>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Func<T> C<T>.<>O.<0>__Target""
+  IL_0018:  ret
+}
+");
+    }
+
+    [Fact]
+    public void SameTypeAndSymbolResultsSameField_TypeScoped4_CLRSignature()
+    {
+        var source = @"
+using System;
+class C<T>
+{
+    void Test0() { var t = (Func<(T x, T y)>)Target<(T x, T y)>; }
+    void Test1() { Func<(T a, T b)> t = Target<(T c, T d)>; }
+    static V Target<V>() { return default(V); }
+}
+";
+        var verifier = CompileAndVerify(source, symbolValidator: VerifyCacheContainer("C.<>O", arity: 0
+            , "System.Func<(T x, T y)> <0>__Target"
+        ));
+        verifier.VerifyIL("C<T>.Test0", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<System.ValueTuple<T, T>> C<T>.<>O.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""System.ValueTuple<T, T> C<T>.Target<System.ValueTuple<T, T>>()""
+  IL_000e:  newobj     ""System.Func<System.ValueTuple<T, T>>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Func<System.ValueTuple<T, T>> C<T>.<>O.<0>__Target""
+  IL_0018:  ret
+}
+");
+        verifier.VerifyIL("C<T>.Test1", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<System.ValueTuple<T, T>> C<T>.<>O.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""System.ValueTuple<T, T> C<T>.Target<System.ValueTuple<T, T>>()""
+  IL_000e:  newobj     ""System.Func<System.ValueTuple<T, T>>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Func<System.ValueTuple<T, T>> C<T>.<>O.<0>__Target""
+  IL_0018:  ret
+}
+");
+    }
+
+    [Fact]
+    public void SameTypeAndSymbolResultsSameField_TypeScoped5_AnonymousDelegate()
+    {
+        var source = @"
+class C
+{
+    void Test0<T>(T t) { G0(Target<int>); }
+    void Test1<T>(T t) { G1(Target<int>); }
+
+    void G0(System.Delegate d) { }
+    void G1(System.Delegate d) { }
+
+    static dynamic Target<G>(ref G g) => 0;
+}
+";
+        var verifier = CompileAndVerify(source, symbolValidator: VerifyCacheContainer("C.<>O", arity: 0
+            , "<>F{00000001}<System.Int32, System.Object> <0>__Target"
+        ));
+        verifier.VerifyIL("C.Test0<T>", @"
+{
+  // Code size       34 (0x22)
+  .maxstack  3
+  IL_0000:  ldarg.0
+  IL_0001:  ldsfld     ""<anonymous delegate> C.<>O.<0>__Target""
+  IL_0006:  dup
+  IL_0007:  brtrue.s   IL_001c
+  IL_0009:  pop
+  IL_000a:  ldnull
+  IL_000b:  ldftn      ""dynamic C.Target<int>(ref int)""
+  IL_0011:  newobj     ""<>F{00000001}<int, dynamic>..ctor(object, System.IntPtr)""
+  IL_0016:  dup
+  IL_0017:  stsfld     ""<anonymous delegate> C.<>O.<0>__Target""
+  IL_001c:  call       ""void C.G0(System.Delegate)""
+  IL_0021:  ret
+}
+");
+        verifier.VerifyIL("C.Test1<T>", @"
+{
+  // Code size       34 (0x22)
+  .maxstack  3
+  IL_0000:  ldarg.0
+  IL_0001:  ldsfld     ""<anonymous delegate> C.<>O.<0>__Target""
+  IL_0006:  dup
+  IL_0007:  brtrue.s   IL_001c
+  IL_0009:  pop
+  IL_000a:  ldnull
+  IL_000b:  ldftn      ""dynamic C.Target<int>(ref int)""
+  IL_0011:  newobj     ""<>F{00000001}<int, dynamic>..ctor(object, System.IntPtr)""
+  IL_0016:  dup
+  IL_0017:  stsfld     ""<anonymous delegate> C.<>O.<0>__Target""
+  IL_001c:  call       ""void C.G1(System.Delegate)""
+  IL_0021:  ret
+}
+");
+    }
+
+    [Fact]
+    public void SameTypeAndSymbolResultsSameField_MethodScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    void Test<V>()
+    {
+        var t0 = (Action)D.Target<V>;
+        Action t1 = D.Target<V>;
+    }
+}
+class D
+{
+    public static void Target<B>() { }
+}
+";
+        var verifier = CompileAndVerify(source, symbolValidator: VerifyCacheContainer("C.<Test>O__0_0", arity: 1
+            , "System.Action <0>__Target"
+        ));
+        verifier.VerifyIL("C.Test<V>", @"
+{
+  // Code size       49 (0x31)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action C.<Test>O__0_0<V>.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void D.Target<V>()""
+  IL_000e:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action C.<Test>O__0_0<V>.<0>__Target""
+  IL_0018:  ldsfld     ""System.Action C.<Test>O__0_0<V>.<0>__Target""
+  IL_001d:  brtrue.s   IL_0030
+  IL_001f:  ldnull
+  IL_0020:  ldftn      ""void D.Target<V>()""
+  IL_0026:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_002b:  stsfld     ""System.Action C.<Test>O__0_0<V>.<0>__Target""
+  IL_0030:  ret
+}
+");
+    }
+
+    [Fact]
+    public void SameTypeAndSymbolResultsSameField_MethodScoped1()
+    {
+        var source = @"
+using System;
+class C<T>
+{
+    void Test<V>()
+    {
+        var t0 = (Func<T, V>)D<V>.Target<T>;
+        Func<T, V> t1 = D<V>.Target<T>;
+    }
+}
+class D<B>
+{
+    public static B Target<H>(H h) => default(B);
+}
+";
+        var verifier = CompileAndVerify(source, symbolValidator: VerifyCacheContainer("C.<Test>O__0_0", arity: 1
+            , "System.Func<T, V> <0>__Target"
+        ));
+        verifier.VerifyIL("C<T>.Test<V>", @"
+{
+  // Code size       49 (0x31)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<T, V> C<T>.<Test>O__0_0<V>.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""V D<V>.Target<T>(T)""
+  IL_000e:  newobj     ""System.Func<T, V>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Func<T, V> C<T>.<Test>O__0_0<V>.<0>__Target""
+  IL_0018:  ldsfld     ""System.Func<T, V> C<T>.<Test>O__0_0<V>.<0>__Target""
+  IL_001d:  brtrue.s   IL_0030
+  IL_001f:  ldnull
+  IL_0020:  ldftn      ""V D<V>.Target<T>(T)""
+  IL_0026:  newobj     ""System.Func<T, V>..ctor(object, System.IntPtr)""
+  IL_002b:  stsfld     ""System.Func<T, V> C<T>.<Test>O__0_0<V>.<0>__Target""
+  IL_0030:  ret
+}
+");
+    }
+
+    [Fact]
+    public void SameTypeAndSymbolResultsSameField_MethodScoped2()
+    {
+        var source = @"
+using System;
+class C<A, T>
+{
+    delegate O MyFunc(int num);
+    class O { }
+    void Test<V>() where V : O
+    {
+        var t0 = (MyFunc)D.Target<V>;
+        MyFunc t1 = D.Target<V>;
+    }
+}
+static class D
+{
+    public static B Target<B>(this int num) => default(B);
+}
+";
+        var verifier = CompileAndVerify(source, symbolValidator: VerifyCacheContainer("C.<Test>O__2_0", arity: 1
+            , "C<A, T>.MyFunc <0>__Target"
+        ));
+        verifier.VerifyIL("C<A, T>.Test<V>", @"
+{
+  // Code size       49 (0x31)
+  .maxstack  2
+  IL_0000:  ldsfld     ""C<A, T>.MyFunc C<A, T>.<Test>O__2_0<V>.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""V D.Target<V>(int)""
+  IL_000e:  newobj     ""C<A, T>.MyFunc..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""C<A, T>.MyFunc C<A, T>.<Test>O__2_0<V>.<0>__Target""
+  IL_0018:  ldsfld     ""C<A, T>.MyFunc C<A, T>.<Test>O__2_0<V>.<0>__Target""
+  IL_001d:  brtrue.s   IL_0030
+  IL_001f:  ldnull
+  IL_0020:  ldftn      ""V D.Target<V>(int)""
+  IL_0026:  newobj     ""C<A, T>.MyFunc..ctor(object, System.IntPtr)""
+  IL_002b:  stsfld     ""C<A, T>.MyFunc C<A, T>.<Test>O__2_0<V>.<0>__Target""
+  IL_0030:  ret
+}
+");
+    }
+
+    [Fact]
+    public void SameTypeAndSymbolResultsSameField_MethodScoped3_CLRSignature()
+    {
+        var source = @"
+using System;
+class C<T>
+{
+    void Test<V>()
+    {
+        var t0 = (Func<object, T, V>)D<V>.Target<T>;
+        Func<dynamic, T, V> t1 = D<V>.Target<T>;
+    }
+}
+class D<B>
+{
+    public static B Target<H>(dynamic o, H h) => default(B);
+}
+";
+        var verifier = CompileAndVerify(source, symbolValidator: VerifyCacheContainer("C.<Test>O__0_0", arity: 1
+            , "System.Func<System.Object, T, V> <0>__Target"
+        ));
+        verifier.VerifyIL("C<T>.Test<V>", @"
+{
+  // Code size       49 (0x31)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<object, T, V> C<T>.<Test>O__0_0<V>.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""V D<V>.Target<T>(dynamic, T)""
+  IL_000e:  newobj     ""System.Func<object, T, V>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Func<object, T, V> C<T>.<Test>O__0_0<V>.<0>__Target""
+  IL_0018:  ldsfld     ""System.Func<object, T, V> C<T>.<Test>O__0_0<V>.<0>__Target""
+  IL_001d:  brtrue.s   IL_0030
+  IL_001f:  ldnull
+  IL_0020:  ldftn      ""V D<V>.Target<T>(dynamic, T)""
+  IL_0026:  newobj     ""System.Func<dynamic, T, V>..ctor(object, System.IntPtr)""
+  IL_002b:  stsfld     ""System.Func<object, T, V> C<T>.<Test>O__0_0<V>.<0>__Target""
+  IL_0030:  ret
+}
+");
+    }
+
+    [Fact]
+    public void SameTypeAndSymbolResultsSameField_MethodScoped4_AnonymousDelegate()
+    {
+        var source = @"
+class C
+{
+    void Test<T>(T t)
+    {
+        G0(Target<T>);
+        G1(Target<T>);
+    }
+
+    void G0(System.Delegate d) { }
+    void G1(System.Delegate d) { }
+
+    static dynamic Target<G>(ref G g) => 0;
+}
+";
+        var verifier = CompileAndVerify(source, symbolValidator: VerifyCacheContainer("C.<Test>O__0_0", arity: 1
+            , "<>F{00000001}<T, System.Object> <0>__Target"
+        ));
+        verifier.VerifyIL("C.Test<T>", @"
+{
+  // Code size       67 (0x43)
+  .maxstack  3
+  IL_0000:  ldarg.0
+  IL_0001:  ldsfld     ""<anonymous delegate> C.<Test>O__0_0<T>.<0>__Target""
+  IL_0006:  dup
+  IL_0007:  brtrue.s   IL_001c
+  IL_0009:  pop
+  IL_000a:  ldnull
+  IL_000b:  ldftn      ""dynamic C.Target<T>(ref T)""
+  IL_0011:  newobj     ""<>F{00000001}<T, dynamic>..ctor(object, System.IntPtr)""
+  IL_0016:  dup
+  IL_0017:  stsfld     ""<anonymous delegate> C.<Test>O__0_0<T>.<0>__Target""
+  IL_001c:  call       ""void C.G0(System.Delegate)""
+  IL_0021:  ldarg.0
+  IL_0022:  ldsfld     ""<anonymous delegate> C.<Test>O__0_0<T>.<0>__Target""
+  IL_0027:  dup
+  IL_0028:  brtrue.s   IL_003d
+  IL_002a:  pop
+  IL_002b:  ldnull
+  IL_002c:  ldftn      ""dynamic C.Target<T>(ref T)""
+  IL_0032:  newobj     ""<>F{00000001}<T, dynamic>..ctor(object, System.IntPtr)""
+  IL_0037:  dup
+  IL_0038:  stsfld     ""<anonymous delegate> C.<Test>O__0_0<T>.<0>__Target""
+  IL_003d:  call       ""void C.G1(System.Delegate)""
+  IL_0042:  ret
+}
+");
+    }
+
+    [Fact]
+    public void ContainersCanBeShared_TypeScoped0()
+    {
+        var source = @"
+using System;
+class A<T>
+{
+    class B<V>
+    {
+        void Test0()
+        {
+            Action<T> t0 = Target0;
+            Action<T> t1 = Target1;
+        }
+
+        void Test1()
+        {
+            Action<T> t1 = Target1;
+            Action<T> t2 = D<T>.Target2;
+        }
+
+        void Test2()
+        {
+            Action<T> t2 = D<T>.Target2;
+            Action<T, V> t3 = D<T>.Target3<V>;
+        }
+
+        void Test3()
+        {
+            Action<T, V> t3 = D<T>.Target3<V>;
+            Action<T, V> t4 = D<T>.E<V>.Target4;
+        }
+
+        void Test4()
+        {
+            Action<T, V> t4 = D<T>.E<V>.Target4;
+            Action<T> t5 = E.Target5<T>;
+        }
+
+        void Test5()
+        {
+            Action<T> t5t = E.Target5<T>;
+            Action<V> t5v = E.Target5<V>;
+        }
+
+        static void Target0(T t) { }
+    }
+
+    static void Target1(T t) { }
+}
+class D<K>
+{
+    public static void Target2(K k) { }
+
+    public static void Target3<M>(K k, M m) { }
+
+    public class E<P>
+    {
+        public static void Target4(K k, P p) { }
+    }
+}
+static class E
+{
+    public static void Target5<N>(this N n) { }
+}
+";
+        var verifier = CompileAndVerify(source, symbolValidator: VerifyCacheContainer("A.B.<>O", arity: 0
+            , "System.Action<T> <0>__Target0"
+            , "System.Action<T> <1>__Target1"
+            , "System.Action<T> <2>__Target2"
+            , "System.Action<T, V> <3>__Target3"
+            , "System.Action<T, V> <4>__Target4"
+            , "System.Action<T> <5>__Target5"
+            , "System.Action<V> <6>__Target5"
+        ));
+        verifier.VerifyIL("A<T>.B<V>.Test0", @"
+{
+  // Code size       49 (0x31)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action<T> A<T>.B<V>.<>O.<0>__Target0""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void A<T>.B<V>.Target0(T)""
+  IL_000e:  newobj     ""System.Action<T>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action<T> A<T>.B<V>.<>O.<0>__Target0""
+  IL_0018:  ldsfld     ""System.Action<T> A<T>.B<V>.<>O.<1>__Target1""
+  IL_001d:  brtrue.s   IL_0030
+  IL_001f:  ldnull
+  IL_0020:  ldftn      ""void A<T>.Target1(T)""
+  IL_0026:  newobj     ""System.Action<T>..ctor(object, System.IntPtr)""
+  IL_002b:  stsfld     ""System.Action<T> A<T>.B<V>.<>O.<1>__Target1""
+  IL_0030:  ret
+}
+");
+        verifier.VerifyIL("A<T>.B<V>.Test1", @"
+{
+  // Code size       49 (0x31)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action<T> A<T>.B<V>.<>O.<1>__Target1""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void A<T>.Target1(T)""
+  IL_000e:  newobj     ""System.Action<T>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action<T> A<T>.B<V>.<>O.<1>__Target1""
+  IL_0018:  ldsfld     ""System.Action<T> A<T>.B<V>.<>O.<2>__Target2""
+  IL_001d:  brtrue.s   IL_0030
+  IL_001f:  ldnull
+  IL_0020:  ldftn      ""void D<T>.Target2(T)""
+  IL_0026:  newobj     ""System.Action<T>..ctor(object, System.IntPtr)""
+  IL_002b:  stsfld     ""System.Action<T> A<T>.B<V>.<>O.<2>__Target2""
+  IL_0030:  ret
+}
+");
+        verifier.VerifyIL("A<T>.B<V>.Test2", @"
+{
+  // Code size       49 (0x31)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action<T> A<T>.B<V>.<>O.<2>__Target2""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void D<T>.Target2(T)""
+  IL_000e:  newobj     ""System.Action<T>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action<T> A<T>.B<V>.<>O.<2>__Target2""
+  IL_0018:  ldsfld     ""System.Action<T, V> A<T>.B<V>.<>O.<3>__Target3""
+  IL_001d:  brtrue.s   IL_0030
+  IL_001f:  ldnull
+  IL_0020:  ldftn      ""void D<T>.Target3<V>(T, V)""
+  IL_0026:  newobj     ""System.Action<T, V>..ctor(object, System.IntPtr)""
+  IL_002b:  stsfld     ""System.Action<T, V> A<T>.B<V>.<>O.<3>__Target3""
+  IL_0030:  ret
+}
+");
+        verifier.VerifyIL("A<T>.B<V>.Test3", @"
+{
+  // Code size       49 (0x31)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action<T, V> A<T>.B<V>.<>O.<3>__Target3""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void D<T>.Target3<V>(T, V)""
+  IL_000e:  newobj     ""System.Action<T, V>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action<T, V> A<T>.B<V>.<>O.<3>__Target3""
+  IL_0018:  ldsfld     ""System.Action<T, V> A<T>.B<V>.<>O.<4>__Target4""
+  IL_001d:  brtrue.s   IL_0030
+  IL_001f:  ldnull
+  IL_0020:  ldftn      ""void D<T>.E<V>.Target4(T, V)""
+  IL_0026:  newobj     ""System.Action<T, V>..ctor(object, System.IntPtr)""
+  IL_002b:  stsfld     ""System.Action<T, V> A<T>.B<V>.<>O.<4>__Target4""
+  IL_0030:  ret
+}
+");
+        verifier.VerifyIL("A<T>.B<V>.Test4", @"
+{
+  // Code size       49 (0x31)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action<T, V> A<T>.B<V>.<>O.<4>__Target4""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void D<T>.E<V>.Target4(T, V)""
+  IL_000e:  newobj     ""System.Action<T, V>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action<T, V> A<T>.B<V>.<>O.<4>__Target4""
+  IL_0018:  ldsfld     ""System.Action<T> A<T>.B<V>.<>O.<5>__Target5""
+  IL_001d:  brtrue.s   IL_0030
+  IL_001f:  ldnull
+  IL_0020:  ldftn      ""void E.Target5<T>(T)""
+  IL_0026:  newobj     ""System.Action<T>..ctor(object, System.IntPtr)""
+  IL_002b:  stsfld     ""System.Action<T> A<T>.B<V>.<>O.<5>__Target5""
+  IL_0030:  ret
+}
+");
+        verifier.VerifyIL("A<T>.B<V>.Test5", @"
+{
+  // Code size       49 (0x31)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action<T> A<T>.B<V>.<>O.<5>__Target5""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void E.Target5<T>(T)""
+  IL_000e:  newobj     ""System.Action<T>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action<T> A<T>.B<V>.<>O.<5>__Target5""
+  IL_0018:  ldsfld     ""System.Action<V> A<T>.B<V>.<>O.<6>__Target5""
+  IL_001d:  brtrue.s   IL_0030
+  IL_001f:  ldnull
+  IL_0020:  ldftn      ""void E.Target5<V>(V)""
+  IL_0026:  newobj     ""System.Action<V>..ctor(object, System.IntPtr)""
+  IL_002b:  stsfld     ""System.Action<V> A<T>.B<V>.<>O.<6>__Target5""
+  IL_0030:  ret
+}
+");
+    }
+
+    [Fact]
+    public void ContainersCanBeShared_MethodScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    void Test<T>()
+    {
+        Action    a = Target0<T>;
+        Action<T> b = Target1;
+        Action    c = D<T>.Target2;
+        Action<C> d = E.Target3<T>;
+    }
+
+    static void Target0<T>() { }
+    static void Target1<T>(T t) { }
+
+    class D<K>
+    {
+        public static void Target2() { }
+    }
+}
+static class E
+{
+    public static void Target3<V>(this C c) { }
+}
+";
+        var verifier = CompileAndVerify(source, symbolValidator: VerifyCacheContainer("C.<Test>O__0_0", arity: 1
+            , "System.Action <0>__Target0"
+            , "System.Action<T> <1>__Target1"
+            , "System.Action <2>__Target2"
+            , "System.Action<C> <3>__Target3"
+        ));
+        verifier.VerifyIL("C.Test<T>", @"
+{
+  // Code size       97 (0x61)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action C.<Test>O__0_0<T>.<0>__Target0""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void C.Target0<T>()""
+  IL_000e:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action C.<Test>O__0_0<T>.<0>__Target0""
+  IL_0018:  ldsfld     ""System.Action<T> C.<Test>O__0_0<T>.<1>__Target1""
+  IL_001d:  brtrue.s   IL_0030
+  IL_001f:  ldnull
+  IL_0020:  ldftn      ""void C.Target1<T>(T)""
+  IL_0026:  newobj     ""System.Action<T>..ctor(object, System.IntPtr)""
+  IL_002b:  stsfld     ""System.Action<T> C.<Test>O__0_0<T>.<1>__Target1""
+  IL_0030:  ldsfld     ""System.Action C.<Test>O__0_0<T>.<2>__Target2""
+  IL_0035:  brtrue.s   IL_0048
+  IL_0037:  ldnull
+  IL_0038:  ldftn      ""void C.D<T>.Target2()""
+  IL_003e:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0043:  stsfld     ""System.Action C.<Test>O__0_0<T>.<2>__Target2""
+  IL_0048:  ldsfld     ""System.Action<C> C.<Test>O__0_0<T>.<3>__Target3""
+  IL_004d:  brtrue.s   IL_0060
+  IL_004f:  ldnull
+  IL_0050:  ldftn      ""void E.Target3<T>(C)""
+  IL_0056:  newobj     ""System.Action<C>..ctor(object, System.IntPtr)""
+  IL_005b:  stsfld     ""System.Action<C> C.<Test>O__0_0<T>.<3>__Target3""
+  IL_0060:  ret
+}
+");
+    }
+
+    [Fact]
+    public void ContainersCanBeShared_MethodScoped1()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Target0<T>() { }
+    public static void Target1<T>(T t) { }
+
+    public class D<T>
+    {
+        public static void Target2() { }
+    }
+}
+static class E
+{
+    static void Test<T>()
+    {
+        Action    a = C.Target0<T>;
+        Action<T> b = C.Target1;
+        Action    c = C.D<T>.Target2;
+        Action<C> d = Target3<T>;
+    }
+
+    public static void Target3<T>(this C c) { }
+}
+";
+        var verifier = CompileAndVerify(source, symbolValidator: VerifyCacheContainer("E.<Test>O__0_0", arity: 1
+            , "System.Action <0>__Target0"
+            , "System.Action<T> <1>__Target1"
+            , "System.Action <2>__Target2"
+            , "System.Action<C> <3>__Target3"
+        ));
+        verifier.VerifyIL("E.Test<T>", @"
+{
+  // Code size       97 (0x61)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action E.<Test>O__0_0<T>.<0>__Target0""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void C.Target0<T>()""
+  IL_000e:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action E.<Test>O__0_0<T>.<0>__Target0""
+  IL_0018:  ldsfld     ""System.Action<T> E.<Test>O__0_0<T>.<1>__Target1""
+  IL_001d:  brtrue.s   IL_0030
+  IL_001f:  ldnull
+  IL_0020:  ldftn      ""void C.Target1<T>(T)""
+  IL_0026:  newobj     ""System.Action<T>..ctor(object, System.IntPtr)""
+  IL_002b:  stsfld     ""System.Action<T> E.<Test>O__0_0<T>.<1>__Target1""
+  IL_0030:  ldsfld     ""System.Action E.<Test>O__0_0<T>.<2>__Target2""
+  IL_0035:  brtrue.s   IL_0048
+  IL_0037:  ldnull
+  IL_0038:  ldftn      ""void C.D<T>.Target2()""
+  IL_003e:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0043:  stsfld     ""System.Action E.<Test>O__0_0<T>.<2>__Target2""
+  IL_0048:  ldsfld     ""System.Action<C> E.<Test>O__0_0<T>.<3>__Target3""
+  IL_004d:  brtrue.s   IL_0060
+  IL_004f:  ldnull
+  IL_0050:  ldftn      ""void E.Target3<T>(C)""
+  IL_0056:  newobj     ""System.Action<C>..ctor(object, System.IntPtr)""
+  IL_005b:  stsfld     ""System.Action<C> E.<Test>O__0_0<T>.<3>__Target3""
+  IL_0060:  ret
+}
+");
+    }
+
+    [Fact]
+    public void ContainersCanBeShared_SkippingUnused()
+    {
+        var source = @"
+using System;
+class C
+{
+    public static void Target<T>(T t) { }
+}
+static class E
+{
+    static void Test<T>()
+    {
+        void LF2<G>()
+        {
+            void LF3()
+            {
+                Action<T> d = C.Target<T>;
+                static void LF4 () { Action<T> d = C.Target<T>; }
+
+                LF4();
+            }
+                
+            void LF5()
+            {
+                Action<T> d = C.Target<T>;
+            }
+
+            LF3(); LF5();
+        }
+        
+        LF2<int>();
+    }
+}
+";
+        var verifier = CompileAndVerify(source, symbolValidator: VerifyCacheContainer("E.<Test>O__0_0", arity: 1
+            , "System.Action<T> <0>__Target"
+        ));
+        verifier.VerifyIL("E.<Test>g__LF3|0_1<T, G>", @"
+{
+  // Code size       30 (0x1e)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action<T> E.<Test>O__0_0<T>.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void C.Target<T>(T)""
+  IL_000e:  newobj     ""System.Action<T>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action<T> E.<Test>O__0_0<T>.<0>__Target""
+  IL_0018:  call       ""void E.<Test>g__LF4|0_3<T, G>()""
+  IL_001d:  ret
+}
+");
+        verifier.VerifyIL("E.<Test>g__LF4|0_3<T, G>", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action<T> E.<Test>O__0_0<T>.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void C.Target<T>(T)""
+  IL_000e:  newobj     ""System.Action<T>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action<T> E.<Test>O__0_0<T>.<0>__Target""
+  IL_0018:  ret
+}
+");
+        verifier.VerifyIL("E.<Test>g__LF5|0_2<T, G>", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action<T> E.<Test>O__0_0<T>.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void C.Target<T>(T)""
+  IL_000e:  newobj     ""System.Action<T>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action<T> E.<Test>O__0_0<T>.<0>__Target""
+  IL_0018:  ret
+}
+");
+    }
+
+    [Fact]
+    public void ContainersCanBeShared_LocalFunctions()
+    {
+        var source = @"
+using System;
+static class E
+{
+    static void Test<T>()
+    {
+        void Owner<G>()
+        {
+            void LF1()
+            {
+                Action d = LF2;
+                static void LF2() { Console.Write(""PA""); }
+
+                d();
+            }
+                
+            void LF3()
+            {
+                Action d = LF2;
+                static void LF2() { Console.Write(""SS""); }
+
+                d();
+            }
+
+            LF1(); LF3();
+        }
+        
+        Owner<int>();
+    }
+
+    static void Main(string[] args) { Test<int>(); }
+}
+";
+        var verifier = CompileAndVerify(source, expectedOutput: PASS, symbolValidator: VerifyCacheContainer("E.<Owner>O__0_0", arity: 2
+            , "System.Action <0>__LF2"
+            , "System.Action <1>__LF2"
+        ));
+        verifier.VerifyIL("E.<Test>g__LF1|0_1<T, G>", @"
+{
+  // Code size       33 (0x21)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action E.<Owner>O__0_0<T, G>.<0>__LF2""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void E.<Test>g__LF2|0_3<T, G>()""
+  IL_0010:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action E.<Owner>O__0_0<T, G>.<0>__LF2""
+  IL_001b:  callvirt   ""void System.Action.Invoke()""
+  IL_0020:  ret
+}
+");
+        verifier.VerifyIL("E.<Test>g__LF3|0_2<T, G>", @"
+{
+  // Code size       33 (0x21)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action E.<Owner>O__0_0<T, G>.<1>__LF2""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void E.<Test>g__LF2|0_4<T, G>()""
+  IL_0010:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action E.<Owner>O__0_0<T, G>.<1>__LF2""
+  IL_001b:  callvirt   ""void System.Action.Invoke()""
+  IL_0020:  ret
+}
+");
+    }
+
+    [Fact]
+    public void NameAmbiguity_Containers0()
+    {
+        var source = @"
+void Owner<T>(int i)
+{
+    var f = Target<T>;
+}
+void X()
+{
+    void Owner<T>(string s)
+    {
+        var f = Target<T>;
+    }
+}
+static void Target<T>() { }
+";
+        var verifier = CompileAndVerify(source, symbolValidator: static module =>
+        {
+            VerifyCacheContainer("Program.<Owner>O__0_0", arity: 1, "System.Action <0>__Target")(module);
+            VerifyCacheContainer("Program.<Owner>O__0_1", arity: 1, "System.Action <0>__Target")(module);
+        });
+        verifier.VerifyIL("Program.<<Main>$>g__Owner|0_0<T>", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action Program.<Owner>O__0_0<T>.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void Program.<<Main>$>g__Target|0_2<T>()""
+  IL_000e:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action Program.<Owner>O__0_0<T>.<0>__Target""
+  IL_0018:  ret
+}
+");
+        verifier.VerifyIL("Program.<<Main>$>g__Owner|0_3<T>", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action Program.<Owner>O__0_1<T>.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void Program.<<Main>$>g__Target|0_2<T>()""
+  IL_000e:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action Program.<Owner>O__0_1<T>.<0>__Target""
+  IL_0018:  ret
+}
+");
+    }
+
+    [Fact]
+    public void NameAmbiguity_Containers1()
+    {
+        var source = @"
+class C
+{
+    void Owner<T>(int i)
+    {
+        var f = Target<T>;
+    }
+    void Owner<T>(string s)
+    {
+        var f = Target<T>;
+    }
+    static void Target<T>() { }
+}
+";
+        var verifier = CompileAndVerify(source, symbolValidator: static module =>
+        {
+            VerifyCacheContainer("C.<Owner>O__0_0", arity: 1, "System.Action <0>__Target")(module);
+            VerifyCacheContainer("C.<Owner>O__1_0", arity: 1, "System.Action <0>__Target")(module);
+        });
+        verifier.VerifyIL("C.Owner<T>(int)", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action C.<Owner>O__0_0<T>.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void C.Target<T>()""
+  IL_000e:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action C.<Owner>O__0_0<T>.<0>__Target""
+  IL_0018:  ret
+}
+");
+        verifier.VerifyIL("C.Owner<T>(string)", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action C.<Owner>O__1_0<T>.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void C.Target<T>()""
+  IL_000e:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action C.<Owner>O__1_0<T>.<0>__Target""
+  IL_0018:  ret
+}
+");
+    }
+
+    [Fact]
+    public void NameAmbiguity_Containers2()
+    {
+        var source = @"
+class C
+{
+    void Owner<T>(int i)
+    {
+        var f = Target<T>;
+    }
+    void F()
+    {
+        void Owner<T>(string s)
+        {
+            var f = Target<T>;
+        }
+    }
+    static void Target<T>() { }
+}
+";
+        var verifier = CompileAndVerify(source, symbolValidator: static module =>
+        {
+            VerifyCacheContainer("C.<Owner>O__0_0", arity: 1, "System.Action <0>__Target")(module);
+            VerifyCacheContainer("C.<Owner>O__1_0", arity: 1, "System.Action <0>__Target")(module);
+        });
+        verifier.VerifyIL("C.Owner<T>(int)", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action C.<Owner>O__0_0<T>.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void C.Target<T>()""
+  IL_000e:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action C.<Owner>O__0_0<T>.<0>__Target""
+  IL_0018:  ret
+}
+");
+        verifier.VerifyIL("C.<F>g__Owner|1_0<T>", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action C.<Owner>O__1_0<T>.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void C.Target<T>()""
+  IL_000e:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action C.<Owner>O__1_0<T>.<0>__Target""
+  IL_0018:  ret
+}
+");
+    }
+
+    [Fact]
+    public void NameAmbiguity_Fields0()
+    {
+        var source = @"
+void F0()
+{
+    var f = Target;
+    static void Target() { }
+}
+void F1()
+{
+    var f = Target;
+    static void Target() { }
+}
+";
+        var verifier = CompileAndVerify(source, symbolValidator: VerifyCacheContainer("Program.<>O", arity: 0
+            , "System.Action <0>__Target"
+            , "System.Action <1>__Target"
+        ));
+        verifier.VerifyIL("Program.<<Main>$>g__F0|0_0", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action Program.<>O.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void Program.<<Main>$>g__Target|0_2()""
+  IL_000e:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action Program.<>O.<0>__Target""
+  IL_0018:  ret
+}
+");
+        verifier.VerifyIL("Program.<<Main>$>g__F1|0_1", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action Program.<>O.<1>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void Program.<<Main>$>g__Target|0_3()""
+  IL_000e:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action Program.<>O.<1>__Target""
+  IL_0018:  ret
+}
+");
+    }
+
+    [Fact]
+    public void NameAmbiguity_Fields2()
+    {
+        var source = @"
+class C
+{
+    void F()
+    {
+        void Owner<T>()
+        {
+            void F0()
+            {
+                var f = Target<T>;
+                static void Target<G>() { }
+            }
+            void F1()
+            {
+                var f = Target<T>;
+                static void Target<G>() { }
+            }
+        }
+    }
+}
+";
+        var verifier = CompileAndVerify(source, symbolValidator: VerifyCacheContainer("C.<Owner>O__0_0", arity: 1
+            , "System.Action <0>__Target"
+            , "System.Action <1>__Target"
+        ));
+        verifier.VerifyIL("C.<F>g__F0|0_1<T>", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action C.<Owner>O__0_0<T>.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void C.<F>g__Target|0_3<T, T>()""
+  IL_000e:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action C.<Owner>O__0_0<T>.<0>__Target""
+  IL_0018:  ret
+}
+");
+        verifier.VerifyIL("C.<F>g__F1|0_2<T>", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action C.<Owner>O__0_0<T>.<1>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void C.<F>g__Target|0_4<T, T>()""
+  IL_000e:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action C.<Owner>O__0_0<T>.<1>__Target""
+  IL_0018:  ret
+}
+");
+    }
+
+    [Fact]
+    public void NameAmbiguity_Fields3()
+    {
+        var source = @"
+using System;
+class C
+{
+    void F()
+    {
+        void Owner<T>()
+        {
+            Action<int> f = E<T>.Target;
+
+            void F1()
+            {
+                Action<string> f = E<T>.Target;
+            }
+        }
+    }
+}
+class E<T>
+{
+    public static void Target(int i) { }
+    public static void Target(string i) { }
+}
+";
+        var verifier = CompileAndVerify(source, symbolValidator: VerifyCacheContainer("C.<Owner>O__0_0", arity: 1
+            , "System.Action<System.Int32> <0>__Target"
+            , "System.Action<System.String> <1>__Target"
+        ));
+        verifier.VerifyIL("C.<F>g__Owner|0_0<T>", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action<int> C.<Owner>O__0_0<T>.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void E<T>.Target(int)""
+  IL_000e:  newobj     ""System.Action<int>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action<int> C.<Owner>O__0_0<T>.<0>__Target""
+  IL_0018:  ret
+}
+");
+        verifier.VerifyIL("C.<F>g__F1|0_1<T>", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action<string> C.<Owner>O__0_0<T>.<1>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void E<T>.Target(string)""
+  IL_000e:  newobj     ""System.Action<string>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action<string> C.<Owner>O__0_0<T>.<1>__Target""
+  IL_0018:  ret
+}
+");
+    }
+
+    [Fact]
+    public void NameAmbiguity_Fields1()
+    {
+        var source = @"
+class C
+{
+    void F0()
+    {
+        var f = Target;
+        static void Target() { }
+    }
+    void F1()
+    {
+        var f = Target;
+        static void Target() { }
+    }
+}
+";
+        var verifier = CompileAndVerify(source, symbolValidator: VerifyCacheContainer("C.<>O", arity: 0
+            , "System.Action <0>__Target"
+            , "System.Action <1>__Target"
+        ));
+        verifier.VerifyIL("C.F0", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action C.<>O.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void C.<F0>g__Target|0_0()""
+  IL_000e:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action C.<>O.<0>__Target""
+  IL_0018:  ret
+}
+");
+        verifier.VerifyIL("C.F1", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action C.<>O.<1>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""void C.<F1>g__Target|1_0()""
+  IL_000e:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Action C.<>O.<1>__Target""
+  IL_0018:  ret
+}
+");
+    }
+
+    [Fact]
+    public void EventHandlers_TypeScoped_CouldBeModuleScoped0()
+    {
+        var source = @"
+using System;
+using System.Reflection;
+class C
+{
+    void Test()
+    {
+        AppDomain.CurrentDomain.AssemblyResolve += Target;
+    }
+
+    static Assembly Target(object sender, ResolveEventArgs e) => null;
+}
+";
+        CompileAndVerify(source).VerifyIL("C.Test", @"
+{
+  // Code size       38 (0x26)
+  .maxstack  3
+  IL_0000:  call       ""System.AppDomain System.AppDomain.CurrentDomain.get""
+  IL_0005:  ldsfld     ""System.ResolveEventHandler C.<>O.<0>__Target""
+  IL_000a:  dup
+  IL_000b:  brtrue.s   IL_0020
+  IL_000d:  pop
+  IL_000e:  ldnull
+  IL_000f:  ldftn      ""System.Reflection.Assembly C.Target(object, System.ResolveEventArgs)""
+  IL_0015:  newobj     ""System.ResolveEventHandler..ctor(object, System.IntPtr)""
+  IL_001a:  dup
+  IL_001b:  stsfld     ""System.ResolveEventHandler C.<>O.<0>__Target""
+  IL_0020:  callvirt   ""void System.AppDomain.AssemblyResolve.add""
+  IL_0025:  ret
+}
+");
+    }
+
+    [Fact]
+    public void EventHandlers_TypeScoped_CouldBeModuleScoped1()
+    {
+        var source = @"
+using System;
+class MyEventArgs : EventArgs { }
+class C<TEventArgs> where TEventArgs : EventArgs
+{
+    event EventHandler<TEventArgs> SomethingHappened;
+ 
+    void Test()
+    {
+        var c = new C<MyEventArgs>();
+        c.SomethingHappened += D.Target;
+    }
+
+}
+class D
+{
+    public static void Target(object sender, MyEventArgs e) { }
+}
+";
+        CompileAndVerify(source).VerifyIL("C<TEventArgs>.Test", @"
+{
+  // Code size       38 (0x26)
+  .maxstack  3
+  IL_0000:  newobj     ""C<MyEventArgs>..ctor()""
+  IL_0005:  ldsfld     ""System.EventHandler<MyEventArgs> C<TEventArgs>.<>O.<0>__Target""
+  IL_000a:  dup
+  IL_000b:  brtrue.s   IL_0020
+  IL_000d:  pop
+  IL_000e:  ldnull
+  IL_000f:  ldftn      ""void D.Target(object, MyEventArgs)""
+  IL_0015:  newobj     ""System.EventHandler<MyEventArgs>..ctor(object, System.IntPtr)""
+  IL_001a:  dup
+  IL_001b:  stsfld     ""System.EventHandler<MyEventArgs> C<TEventArgs>.<>O.<0>__Target""
+  IL_0020:  callvirt   ""void C<MyEventArgs>.SomethingHappened.add""
+  IL_0025:  ret
+}
+");
+    }
+
+    [Fact]
+    public void EventHandlers_TypeScoped0()
+    {
+        var source = @"
+using System;
+class C<TEventArgs> where TEventArgs : EventArgs
+{
+    event EventHandler<TEventArgs> SomethingHappened;
+ 
+    void Test()
+    {
+        this.SomethingHappened += Target;
+    }
+
+    static void Target(object sender, TEventArgs e) { }
+}
+";
+        CompileAndVerify(source).VerifyIL("C<TEventArgs>.Test", @"
+{
+  // Code size       34 (0x22)
+  .maxstack  3
+  IL_0000:  ldarg.0
+  IL_0001:  ldsfld     ""System.EventHandler<TEventArgs> C<TEventArgs>.<>O.<0>__Target""
+  IL_0006:  dup
+  IL_0007:  brtrue.s   IL_001c
+  IL_0009:  pop
+  IL_000a:  ldnull
+  IL_000b:  ldftn      ""void C<TEventArgs>.Target(object, TEventArgs)""
+  IL_0011:  newobj     ""System.EventHandler<TEventArgs>..ctor(object, System.IntPtr)""
+  IL_0016:  dup
+  IL_0017:  stsfld     ""System.EventHandler<TEventArgs> C<TEventArgs>.<>O.<0>__Target""
+  IL_001c:  call       ""void C<TEventArgs>.SomethingHappened.add""
+  IL_0021:  ret
+}
+");
+    }
+
+    [Fact]
+    public void EventHandlers_MethodScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    void Test<TEventArgs>() where TEventArgs : EventArgs
+    {
+        var d = new D<TEventArgs>();
+        d.SomethingHappened += Target;
+    }
+
+    static void Target<TEventArgs>(object sender, TEventArgs e) where TEventArgs : EventArgs { }
+}
+class D<TEventArgs> where TEventArgs : EventArgs
+{
+    public event EventHandler<TEventArgs> SomethingHappened;
+}
+";
+        CompileAndVerify(source).VerifyIL("C.Test<TEventArgs>", @"
+{
+  // Code size       38 (0x26)
+  .maxstack  3
+  IL_0000:  newobj     ""D<TEventArgs>..ctor()""
+  IL_0005:  ldsfld     ""System.EventHandler<TEventArgs> C.<Test>O__0_0<TEventArgs>.<0>__Target""
+  IL_000a:  dup
+  IL_000b:  brtrue.s   IL_0020
+  IL_000d:  pop
+  IL_000e:  ldnull
+  IL_000f:  ldftn      ""void C.Target<TEventArgs>(object, TEventArgs)""
+  IL_0015:  newobj     ""System.EventHandler<TEventArgs>..ctor(object, System.IntPtr)""
+  IL_001a:  dup
+  IL_001b:  stsfld     ""System.EventHandler<TEventArgs> C.<Test>O__0_0<TEventArgs>.<0>__Target""
+  IL_0020:  callvirt   ""void D<TEventArgs>.SomethingHappened.add""
+  IL_0025:  ret
+}
+");
+    }
+
+    [Fact]
+    public void AnonymousTypes_TypeScoped_CouldBeModuleScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    static void Main(string[] args) => Invoke(new { x = 0 }, Target);
+
+    static void Invoke<T>(T t, Action<T> f) => f(t);
+
+    static void Target<T>(T t) => Console.WriteLine(t);
+}
+";
+        CompileAndVerify(source, expectedOutput: "{ x = 0 }").VerifyIL("C.Main", @"
+{
+  // Code size       39 (0x27)
+  .maxstack  3
+  IL_0000:  ldc.i4.0
+  IL_0001:  newobj     ""<>f__AnonymousType0<int>..ctor(int)""
+  IL_0006:  ldsfld     ""System.Action<<anonymous type: int x>> C.<>O.<0>__Target""
+  IL_000b:  dup
+  IL_000c:  brtrue.s   IL_0021
+  IL_000e:  pop
+  IL_000f:  ldnull
+  IL_0010:  ldftn      ""void C.Target<<anonymous type: int x>>(<anonymous type: int x>)""
+  IL_0016:  newobj     ""System.Action<<anonymous type: int x>>..ctor(object, System.IntPtr)""
+  IL_001b:  dup
+  IL_001c:  stsfld     ""System.Action<<anonymous type: int x>> C.<>O.<0>__Target""
+  IL_0021:  call       ""void C.Invoke<<anonymous type: int x>>(<anonymous type: int x>, System.Action<<anonymous type: int x>>)""
+  IL_0026:  ret
+}
+");
+    }
+
+    [Fact]
+    public void AnonymousTypes_TypeScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    static void Main(string[] args) => (new D<int>()).Test(0);
+}
+class D<G>
+{
+    public void Test(G g) => Invoke(new { x = g }, Target);
+
+    static void Invoke<T>(T t, Action<T> f) => f(t);
+
+    static void Target<T>(T t) => Console.WriteLine(t);
+}
+";
+        CompileAndVerify(source, expectedOutput: "{ x = 0 }").VerifyIL("D<G>.Test", @"
+{
+  // Code size       39 (0x27)
+  .maxstack  3
+  IL_0000:  ldarg.1
+  IL_0001:  newobj     ""<>f__AnonymousType0<G>..ctor(G)""
+  IL_0006:  ldsfld     ""System.Action<<anonymous type: G x>> D<G>.<>O.<0>__Target""
+  IL_000b:  dup
+  IL_000c:  brtrue.s   IL_0021
+  IL_000e:  pop
+  IL_000f:  ldnull
+  IL_0010:  ldftn      ""void D<G>.Target<<anonymous type: G x>>(<anonymous type: G x>)""
+  IL_0016:  newobj     ""System.Action<<anonymous type: G x>>..ctor(object, System.IntPtr)""
+  IL_001b:  dup
+  IL_001c:  stsfld     ""System.Action<<anonymous type: G x>> D<G>.<>O.<0>__Target""
+  IL_0021:  call       ""void D<G>.Invoke<<anonymous type: G x>>(<anonymous type: G x>, System.Action<<anonymous type: G x>>)""
+  IL_0026:  ret
+}
+");
+    }
+
+    [Fact]
+    public void AnonymousTypes_TypeScoped1()
+    {
+        var source = @"
+using System;
+class C
+{
+    static void Main(string[] args) => (new D<int>()).Test(0);
+}
+class D<G>
+{
+    public void Test(G g) => Invoke(new { x = g }, E.Target);
+
+    static void Invoke<T>(T t, Action<T> f) => f(t);
+}
+class E
+{
+    public static void Target<T>(T t) => Console.WriteLine(t);
+}
+";
+        CompileAndVerify(source, expectedOutput: "{ x = 0 }").VerifyIL("D<G>.Test", @"
+{
+  // Code size       39 (0x27)
+  .maxstack  3
+  IL_0000:  ldarg.1
+  IL_0001:  newobj     ""<>f__AnonymousType0<G>..ctor(G)""
+  IL_0006:  ldsfld     ""System.Action<<anonymous type: G x>> D<G>.<>O.<0>__Target""
+  IL_000b:  dup
+  IL_000c:  brtrue.s   IL_0021
+  IL_000e:  pop
+  IL_000f:  ldnull
+  IL_0010:  ldftn      ""void E.Target<<anonymous type: G x>>(<anonymous type: G x>)""
+  IL_0016:  newobj     ""System.Action<<anonymous type: G x>>..ctor(object, System.IntPtr)""
+  IL_001b:  dup
+  IL_001c:  stsfld     ""System.Action<<anonymous type: G x>> D<G>.<>O.<0>__Target""
+  IL_0021:  call       ""void D<G>.Invoke<<anonymous type: G x>>(<anonymous type: G x>, System.Action<<anonymous type: G x>>)""
+  IL_0026:  ret
+}
+");
+    }
+
+    [Fact]
+    public void AnonymousTypes_TypeScoped2()
+    {
+        var source = @"
+using System;
+class C
+{
+    static void Main(string[] args) => D<int>.Test();
+}
+class D<G>
+{
+    delegate void MyAction<T>(T t);
+
+    public static void Test() => Invoke(new { x = 0 }, Target);
+
+    static void Invoke<T>(T t, MyAction<T> f) => f(t);
+
+    static void Target<T>(T t) => Console.WriteLine(t);
+}
+";
+        CompileAndVerify(source, expectedOutput: "{ x = 0 }").VerifyIL("D<G>.Test", @"
+{
+  // Code size       39 (0x27)
+  .maxstack  3
+  IL_0000:  ldc.i4.0
+  IL_0001:  newobj     ""<>f__AnonymousType0<int>..ctor(int)""
+  IL_0006:  ldsfld     ""D<G>.MyAction<<anonymous type: int x>> D<G>.<>O.<0>__Target""
+  IL_000b:  dup
+  IL_000c:  brtrue.s   IL_0021
+  IL_000e:  pop
+  IL_000f:  ldnull
+  IL_0010:  ldftn      ""void D<G>.Target<<anonymous type: int x>>(<anonymous type: int x>)""
+  IL_0016:  newobj     ""D<G>.MyAction<<anonymous type: int x>>..ctor(object, System.IntPtr)""
+  IL_001b:  dup
+  IL_001c:  stsfld     ""D<G>.MyAction<<anonymous type: int x>> D<G>.<>O.<0>__Target""
+  IL_0021:  call       ""void D<G>.Invoke<<anonymous type: int x>>(<anonymous type: int x>, D<G>.MyAction<<anonymous type: int x>>)""
+  IL_0026:  ret
+}
+");
+    }
+
+    [Fact]
+    public void AnonymousTypes_MethodScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    static void Main(string[] args) => D.Test(0);
+}
+class D
+{
+    public static void Test<T>(T t) => Invoke(new { x = t }, Target);
+
+    static void Invoke<T>(T t, Action<T> f) => f(t);
+
+    static void Target<T>(T t) => Console.WriteLine(t);
+}
+";
+        CompileAndVerify(source, expectedOutput: "{ x = 0 }").VerifyIL("D.Test<T>", @"
+{
+  // Code size       39 (0x27)
+  .maxstack  3
+  IL_0000:  ldarg.0
+  IL_0001:  newobj     ""<>f__AnonymousType0<T>..ctor(T)""
+  IL_0006:  ldsfld     ""System.Action<<anonymous type: T x>> D.<Test>O__0_0<T>.<0>__Target""
+  IL_000b:  dup
+  IL_000c:  brtrue.s   IL_0021
+  IL_000e:  pop
+  IL_000f:  ldnull
+  IL_0010:  ldftn      ""void D.Target<<anonymous type: T x>>(<anonymous type: T x>)""
+  IL_0016:  newobj     ""System.Action<<anonymous type: T x>>..ctor(object, System.IntPtr)""
+  IL_001b:  dup
+  IL_001c:  stsfld     ""System.Action<<anonymous type: T x>> D.<Test>O__0_0<T>.<0>__Target""
+  IL_0021:  call       ""void D.Invoke<<anonymous type: T x>>(<anonymous type: T x>, System.Action<<anonymous type: T x>>)""
+  IL_0026:  ret
+}
+");
+    }
+
+    [Fact]
+    public void AnonymousTypes_MethodScoped1()
+    {
+        var source = @"
+using System;
+class C
+{
+    static void Main(string[] args) => D.Test(0);
+}
+class D
+{
+    public static void Test<T>(T t) => Invoke(t, new { x = 0 }, Target);
+
+    static void Invoke<T, V>(T t, V v, Action<T, V> f) => f(t, v);
+
+    static void Target<T, V>(T t, V v) => Console.WriteLine(v);
+}
+";
+        CompileAndVerify(source, expectedOutput: "{ x = 0 }").VerifyIL("D.Test<T>", @"
+{
+  // Code size       40 (0x28)
+  .maxstack  4
+  IL_0000:  ldarg.0
+  IL_0001:  ldc.i4.0
+  IL_0002:  newobj     ""<>f__AnonymousType0<int>..ctor(int)""
+  IL_0007:  ldsfld     ""System.Action<T, <anonymous type: int x>> D.<Test>O__0_0<T>.<0>__Target""
+  IL_000c:  dup
+  IL_000d:  brtrue.s   IL_0022
+  IL_000f:  pop
+  IL_0010:  ldnull
+  IL_0011:  ldftn      ""void D.Target<T, <anonymous type: int x>>(T, <anonymous type: int x>)""
+  IL_0017:  newobj     ""System.Action<T, <anonymous type: int x>>..ctor(object, System.IntPtr)""
+  IL_001c:  dup
+  IL_001d:  stsfld     ""System.Action<T, <anonymous type: int x>> D.<Test>O__0_0<T>.<0>__Target""
+  IL_0022:  call       ""void D.Invoke<T, <anonymous type: int x>>(T, <anonymous type: int x>, System.Action<T, <anonymous type: int x>>)""
+  IL_0027:  ret
+}
+");
+    }
+
+    [Fact]
+    public void AnonymousClass_AnonymousDelegate0()
+    {
+        var source = @"
+using System;
+class D
+{
+    public void Owner<T>()
+    {
+        static void Test<NotUsed>(T t)
+        {
+            var f = F<T>;
+            var a = new { x = f };
+
+            Invoke(a, Target);
+        }
+    }
+
+    static void F<T>(ref T t) { }
+
+    static void Invoke<T>(T t, Action<T> f) { }
+
+    static void Target<T>(T t) { }
+}
+";
+        CompileAndVerify(source).VerifyIL("D.<Owner>g__Test|0_0<T, NotUsed>", @"
+{
+  // Code size       65 (0x41)
+  .maxstack  3
+  IL_0000:  ldsfld     ""<anonymous delegate> D.<Owner>O__0_0<T>.<0>__F""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void D.F<T>(ref T)""
+  IL_0010:  newobj     ""<>A{00000001}<T>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""<anonymous delegate> D.<Owner>O__0_0<T>.<0>__F""
+  IL_001b:  newobj     ""<>f__AnonymousType0<<anonymous delegate>>..ctor(<anonymous delegate>)""
+  IL_0020:  ldsfld     ""System.Action<<anonymous type: <anonymous delegate> x>> D.<Owner>O__0_0<T>.<1>__Target""
+  IL_0025:  dup
+  IL_0026:  brtrue.s   IL_003b
+  IL_0028:  pop
+  IL_0029:  ldnull
+  IL_002a:  ldftn      ""void D.Target<<anonymous type: <anonymous delegate> x>>(<anonymous type: <anonymous delegate> x>)""
+  IL_0030:  newobj     ""System.Action<<anonymous type: <anonymous delegate> x>>..ctor(object, System.IntPtr)""
+  IL_0035:  dup
+  IL_0036:  stsfld     ""System.Action<<anonymous type: <anonymous delegate> x>> D.<Owner>O__0_0<T>.<1>__Target""
+  IL_003b:  call       ""void D.Invoke<<anonymous type: <anonymous delegate> x>>(<anonymous type: <anonymous delegate> x>, System.Action<<anonymous type: <anonymous delegate> x>>)""
+  IL_0040:  ret
+}
+");
+    }
+
+    [Fact]
+    public void AnonymousClass_AnonymousDelegate1()
+    {
+        var source = @"
+using System;
+class D<T>
+{
+    public void Top<N0>()
+    {
+        static void Test<N1>(T t)
+        {
+            var f = F;
+            var a = new { x = f };
+
+            Invoke(a, Target);
+        }
+    }
+
+    static void F(ref T t) { }
+
+    static void Invoke<G>(G t, Action<G> f) { }
+
+    static void Target<G>(G t) { }
+}
+";
+        CompileAndVerify(source).VerifyIL("D<T>.<Top>g__Test|0_0<N0, N1>", @"
+{
+  // Code size       65 (0x41)
+  .maxstack  3
+  IL_0000:  ldsfld     ""<anonymous delegate> D<T>.<>O.<0>__F""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void D<T>.F(ref T)""
+  IL_0010:  newobj     ""<>A{00000001}<T>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""<anonymous delegate> D<T>.<>O.<0>__F""
+  IL_001b:  newobj     ""<>f__AnonymousType0<<anonymous delegate>>..ctor(<anonymous delegate>)""
+  IL_0020:  ldsfld     ""System.Action<<anonymous type: <anonymous delegate> x>> D<T>.<>O.<1>__Target""
+  IL_0025:  dup
+  IL_0026:  brtrue.s   IL_003b
+  IL_0028:  pop
+  IL_0029:  ldnull
+  IL_002a:  ldftn      ""void D<T>.Target<<anonymous type: <anonymous delegate> x>>(<anonymous type: <anonymous delegate> x>)""
+  IL_0030:  newobj     ""System.Action<<anonymous type: <anonymous delegate> x>>..ctor(object, System.IntPtr)""
+  IL_0035:  dup
+  IL_0036:  stsfld     ""System.Action<<anonymous type: <anonymous delegate> x>> D<T>.<>O.<1>__Target""
+  IL_003b:  call       ""void D<T>.Invoke<<anonymous type: <anonymous delegate> x>>(<anonymous type: <anonymous delegate> x>, System.Action<<anonymous type: <anonymous delegate> x>>)""
+  IL_0040:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Pointer_TypeScoped_CouldBeModuleScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    unsafe void Test()
+    {
+        Func<int*[]> t = Target;
+        t();
+    }
+
+    unsafe static int*[] Target() => default(int*[]);
+}
+";
+        CompileAndVerify(source, options: TestOptions.UnsafeReleaseDll).VerifyIL("C.Test", @"
+{
+  // Code size       34 (0x22)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<int*[]> C.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""int*[] C.Target()""
+  IL_0010:  newobj     ""System.Func<int*[]>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<int*[]> C.<>O.<0>__Target""
+  IL_001b:  callvirt   ""int*[] System.Func<int*[]>.Invoke()""
+  IL_0020:  pop
+  IL_0021:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Pointer_TypeScoped0()
+    {
+        var source = @"
+using System;
+class C<T>
+{
+    unsafe void Test()
+    {
+        Func<T, int*[]> t = Target;
+        t(default(T));
+    }
+
+    unsafe static int*[] Target(T t) => default(int*[]);
+}
+";
+        CompileAndVerify(source, options: TestOptions.UnsafeReleaseDll).VerifyIL("C<T>.Test", @"
+{
+  // Code size       43 (0x2b)
+  .maxstack  2
+  .locals init (T V_0)
+  IL_0000:  ldsfld     ""System.Func<T, int*[]> C<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""int*[] C<T>.Target(T)""
+  IL_0010:  newobj     ""System.Func<T, int*[]>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<T, int*[]> C<T>.<>O.<0>__Target""
+  IL_001b:  ldloca.s   V_0
+  IL_001d:  initobj    ""T""
+  IL_0023:  ldloc.0
+  IL_0024:  callvirt   ""int*[] System.Func<T, int*[]>.Invoke(T)""
+  IL_0029:  pop
+  IL_002a:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Pointer_MethodScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    unsafe void Test<T>(T t)
+    {
+        Func<T, int*[]> f = Target<T>;
+        f(t);
+    }
+
+    unsafe static int*[] Target<G>(G g) => default(int*[]);
+}
+";
+        CompileAndVerify(source, options: TestOptions.UnsafeReleaseDll).VerifyIL("C.Test<T>", @"
+{
+  // Code size       35 (0x23)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<T, int*[]> C.<Test>O__0_0<T>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""int*[] C.Target<T>(T)""
+  IL_0010:  newobj     ""System.Func<T, int*[]>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<T, int*[]> C.<Test>O__0_0<T>.<0>__Target""
+  IL_001b:  ldarg.1
+  IL_001c:  callvirt   ""int*[] System.Func<T, int*[]>.Invoke(T)""
+  IL_0021:  pop
+  IL_0022:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Dynamic_TypeScoped_CouldBeModuleScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    void Test()
+    {
+        Func<dynamic> t = Target;
+        t();
+    }
+
+    static dynamic Target() => 0;
+}
+";
+        CompileAndVerify(source).VerifyIL("C.Test", @"
+{
+  // Code size       34 (0x22)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<dynamic> C.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""dynamic C.Target()""
+  IL_0010:  newobj     ""System.Func<dynamic>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<dynamic> C.<>O.<0>__Target""
+  IL_001b:  callvirt   ""dynamic System.Func<dynamic>.Invoke()""
+  IL_0020:  pop
+  IL_0021:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Dynamic_TypeScoped0()
+    {
+        var source = @"
+using System;
+class C<T>
+{
+    void Test()
+    {
+        Func<T, dynamic> t = Target;
+        t(default(T));
+    }
+
+    static dynamic Target(T t) => 0;
+}
+";
+        CompileAndVerify(source).VerifyIL("C<T>.Test", @"
+{
+  // Code size       43 (0x2b)
+  .maxstack  2
+  .locals init (T V_0)
+  IL_0000:  ldsfld     ""System.Func<T, dynamic> C<T>.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""dynamic C<T>.Target(T)""
+  IL_0010:  newobj     ""System.Func<T, dynamic>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<T, dynamic> C<T>.<>O.<0>__Target""
+  IL_001b:  ldloca.s   V_0
+  IL_001d:  initobj    ""T""
+  IL_0023:  ldloc.0
+  IL_0024:  callvirt   ""dynamic System.Func<T, dynamic>.Invoke(T)""
+  IL_0029:  pop
+  IL_002a:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Dynamic_MethodScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    void Test<T>(T t)
+    {
+        Func<T, dynamic> f = Target<T>;
+        f(t);
+    }
+
+    static dynamic Target<G>(G g) => 0;
+}
+";
+        CompileAndVerify(source).VerifyIL("C.Test<T>", @"
+{
+  // Code size       35 (0x23)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<T, dynamic> C.<Test>O__0_0<T>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""dynamic C.Target<T>(T)""
+  IL_0010:  newobj     ""System.Func<T, dynamic>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<T, dynamic> C.<Test>O__0_0<T>.<0>__Target""
+  IL_001b:  ldarg.1
+  IL_001c:  callvirt   ""dynamic System.Func<T, dynamic>.Invoke(T)""
+  IL_0021:  pop
+  IL_0022:  ret
+}
+");
+    }
+
+    [Fact]
+    public void SynthesizedAnonymousDelegate_TypeScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    void Test<T>(T t)
+    {
+        G(Target<int>);
+    }
+
+    void G(Delegate d) {}
+
+    static dynamic Target<G>(ref G g) => 0;
+}
+";
+        CompileAndVerify(source).VerifyIL("C.Test<T>", @"
+{
+  // Code size       34 (0x22)
+  .maxstack  3
+  IL_0000:  ldarg.0
+  IL_0001:  ldsfld     ""<anonymous delegate> C.<>O.<0>__Target""
+  IL_0006:  dup
+  IL_0007:  brtrue.s   IL_001c
+  IL_0009:  pop
+  IL_000a:  ldnull
+  IL_000b:  ldftn      ""dynamic C.Target<int>(ref int)""
+  IL_0011:  newobj     ""<>F{00000001}<int, dynamic>..ctor(object, System.IntPtr)""
+  IL_0016:  dup
+  IL_0017:  stsfld     ""<anonymous delegate> C.<>O.<0>__Target""
+  IL_001c:  call       ""void C.G(System.Delegate)""
+  IL_0021:  ret
+}
+");
+    }
+
+    [Fact]
+    public void SynthesizedAnonymousDelegate_MethodScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    void Test<T>(T t)
+    {
+        G(Target<T>);
+    }
+
+    void G(Delegate d) {}
+
+    static dynamic Target<G>(ref G g) => 0;
+}
+";
+        CompileAndVerify(source).VerifyIL("C.Test<T>", @"
+{
+  // Code size       34 (0x22)
+  .maxstack  3
+  IL_0000:  ldarg.0
+  IL_0001:  ldsfld     ""<anonymous delegate> C.<Test>O__0_0<T>.<0>__Target""
+  IL_0006:  dup
+  IL_0007:  brtrue.s   IL_001c
+  IL_0009:  pop
+  IL_000a:  ldnull
+  IL_000b:  ldftn      ""dynamic C.Target<T>(ref T)""
+  IL_0011:  newobj     ""<>F{00000001}<T, dynamic>..ctor(object, System.IntPtr)""
+  IL_0016:  dup
+  IL_0017:  stsfld     ""<anonymous delegate> C.<Test>O__0_0<T>.<0>__Target""
+  IL_001c:  call       ""void C.G(System.Delegate)""
+  IL_0021:  ret
+}
+");
+    }
+
+    [Fact]
+    public void TopLevelMethod_LocalFunctions_TypeScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    void Test(int t)
+    {
+        Func<int, dynamic> f = Target<int>;
+        f(t);
+
+        static dynamic Target<G>(G g) => 0;
+    }
+}
+";
+        CompileAndVerify(source).VerifyIL("C.Test", @"
+{
+  // Code size       35 (0x23)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<int, dynamic> C.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""dynamic C.<Test>g__Target|0_0<int>(int)""
+  IL_0010:  newobj     ""System.Func<int, dynamic>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<int, dynamic> C.<>O.<0>__Target""
+  IL_001b:  ldarg.1
+  IL_001c:  callvirt   ""dynamic System.Func<int, dynamic>.Invoke(int)""
+  IL_0021:  pop
+  IL_0022:  ret
+}
+");
+    }
+
+    [Fact]
+    public void TopLevelMethod_LocalFunctions_NotStatic()
+    {
+        var source = @"
+using System;
+class C
+{
+    void Test(int t)
+    {
+        Func<int, dynamic> f = Target<int>;
+        f(t);
+
+        dynamic Target<G>(G g) => 0;
+    }
+}
+";
+        CompileAndVerify(source).VerifyIL("C.Test", @"
+{
+  // Code size       20 (0x14)
+  .maxstack  2
+  IL_0000:  ldnull
+  IL_0001:  ldftn      ""dynamic C.<Test>g__Target|0_0<int>(int)""
+  IL_0007:  newobj     ""System.Func<int, dynamic>..ctor(object, System.IntPtr)""
+  IL_000c:  ldarg.1
+  IL_000d:  callvirt   ""dynamic System.Func<int, dynamic>.Invoke(int)""
+  IL_0012:  pop
+  IL_0013:  ret
+}
+");
+    }
+
+    [Fact]
+    public void TopLevelMethod_LocalFunctions_MethodScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    void Test<T>(T t)
+    {
+        Func<T, dynamic> f = Target<T>;
+        f(t);
+
+        static dynamic Target<G>(G g) => 0;
+    }
+}
+";
+        CompileAndVerify(source).VerifyIL("C.Test<T>", @"
+{
+  // Code size       35 (0x23)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<T, dynamic> C.<Test>O__0_0<T>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""dynamic C.<Test>g__Target|0_0<T, T>(T)""
+  IL_0010:  newobj     ""System.Func<T, dynamic>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<T, dynamic> C.<Test>O__0_0<T>.<0>__Target""
+  IL_001b:  ldarg.1
+  IL_001c:  callvirt   ""dynamic System.Func<T, dynamic>.Invoke(T)""
+  IL_0021:  pop
+  IL_0022:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Local_LocalFunctions_MethodScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    void TopLevel<T>(T t)
+    {
+        void Test()
+        {
+            Func<T, dynamic> f = Target<T>;
+            f(t);
+
+            static dynamic Target<G>(G g) => 0;
+        }
+    }
+}
+";
+        CompileAndVerify(source).VerifyIL("C.<TopLevel>g__Test|0_0<T>", @"
+{
+  // Code size       40 (0x28)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<T, dynamic> C.<TopLevel>O__0_0<T>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""dynamic C.<TopLevel>g__Target|0_1<T, T>(T)""
+  IL_0010:  newobj     ""System.Func<T, dynamic>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<T, dynamic> C.<TopLevel>O__0_0<T>.<0>__Target""
+  IL_001b:  ldarg.0
+  IL_001c:  ldfld      ""T C.<>c__DisplayClass0_0<T>.t""
+  IL_0021:  callvirt   ""dynamic System.Func<T, dynamic>.Invoke(T)""
+  IL_0026:  pop
+  IL_0027:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Lambda_Local_LocalFunctions_MethodScoped0()
+    {
+        var source = @"
+using System;
+class C
+{
+    void TopLevel<T>(T t)
+    {
+        Action x = () =>
+        {
+            void Test()
+            {
+                Func<T, dynamic> f = Target<T>;
+                f(t);
+
+                static dynamic Target<G>(G g) => 0;
+            }
+
+            Test();
+        };
+
+        x();
+    }
+}
+";
+        CompileAndVerify(source).VerifyIL("C.<>c__DisplayClass0_0<T>.<TopLevel>g__Test|1", @"
+{
+  // Code size       40 (0x28)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<T, dynamic> C.<TopLevel>O__0_0<T>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""dynamic C.<TopLevel>g__Target|0_2<T, T>(T)""
+  IL_0010:  newobj     ""System.Func<T, dynamic>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<T, dynamic> C.<TopLevel>O__0_0<T>.<0>__Target""
+  IL_001b:  ldarg.0
+  IL_001c:  ldfld      ""T C.<>c__DisplayClass0_0<T>.t""
+  IL_0021:  callvirt   ""dynamic System.Func<T, dynamic>.Invoke(T)""
+  IL_0026:  pop
+  IL_0027:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Lambda_Local_LocalFunctions_MethodScoped1()
+    {
+        var source = @"
+using System;
+class C
+{
+    void TopLevel<T>(T t)
+    {
+        Action y = () =>
+        {
+            void Test() { /* Test method ordinals in generated names */ }
+            Test();
+        };
+        Action x = () =>
+        {
+            void Test()
+            {
+                Func<T, dynamic> f = Target<T>;
+                f(t);
+
+                static dynamic Target<G>(G g) => 0;
+            }
+
+            Test();
+        };
+
+        x();
+        y();
+    }
+}
+";
+        CompileAndVerify(source).VerifyIL("C.<>c__DisplayClass0_0<T>.<TopLevel>g__Test|3", @"
+{
+  // Code size       40 (0x28)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<T, dynamic> C.<TopLevel>O__0_0<T>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""dynamic C.<TopLevel>g__Target|0_4<T, T>(T)""
+  IL_0010:  newobj     ""System.Func<T, dynamic>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<T, dynamic> C.<TopLevel>O__0_0<T>.<0>__Target""
+  IL_001b:  ldarg.0
+  IL_001c:  ldfld      ""T C.<>c__DisplayClass0_0<T>.t""
+  IL_0021:  callvirt   ""dynamic System.Func<T, dynamic>.Invoke(T)""
+  IL_0026:  pop
+  IL_0027:  ret
+}
+");
+    }
+
+    [Fact]
+    public void TopLevelStatement_Lambda_Local_LocalFunctions_MethodScoped0()
+    {
+        var source = @"
+using System;
+
+Action y = () =>
+{
+    void Test() { /* Test method ordinals in generated names */ }
+    Test();
+};
+Action x = () =>
+{
+    void Test<T>(T t)
+    {
+        Func<T, dynamic> f = Target<T>;
+        f(t);
+
+        static dynamic Target<G>(G g) => 0;
+    }
+
+    Test(0);
+};
+
+x();
+y();
+";
+        CompileAndVerify(source).VerifyIL("Program.<<Main>$>g__Test|0_3<T>", @"
+{
+  // Code size       35 (0x23)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<T, dynamic> Program.<Test>O__0_0<T>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""dynamic Program.<<Main>$>g__Target|0_4<T, T>(T)""
+  IL_0010:  newobj     ""System.Func<T, dynamic>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<T, dynamic> Program.<Test>O__0_0<T>.<0>__Target""
+  IL_001b:  ldarg.0
+  IL_001c:  callvirt   ""dynamic System.Func<T, dynamic>.Invoke(T)""
+  IL_0021:  pop
+  IL_0022:  ret
+}
+");
+    }
+
+    [Fact]
+    public void TopLevelStatement_Lambda_Local_LocalFunctions_MethodScoped1()
+    {
+        var source = @"
+var y = () =>
+{
+    void Test() { /* Test method ordinals in generated names */ }
+    Test();
+};
+var x = () =>
+{
+    void Test<T>(T t)
+    {
+        var f = Target<int>;
+        f(0);
+
+        static dynamic Target<G>(G g)
+        {
+            T f = default;
+            return f;
+        }
+    }
+
+    Test(false);
+};
+
+x();
+y();
+";
+        CompileAndVerify(source).VerifyIL("Program.<<Main>$>g__Test|0_3<T>", @"
+{
+  // Code size       35 (0x23)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<int, dynamic> Program.<Test>O__0_0<T>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""dynamic Program.<<Main>$>g__Target|0_4<T, int>(int)""
+  IL_0010:  newobj     ""System.Func<int, dynamic>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<int, dynamic> Program.<Test>O__0_0<T>.<0>__Target""
+  IL_001b:  ldc.i4.0
+  IL_001c:  callvirt   ""dynamic System.Func<int, dynamic>.Invoke(int)""
+  IL_0021:  pop
+  IL_0022:  ret
+}
+");
+    }
+
+    [Fact]
+    public void TopLevelStatement_Tuples_LocalFunction_TypeScoped0()
+    {
+        var source = @"
+(System.Action a, int _) = (Target, 0);
+static void Target() { }
+";
+        CompileAndVerify(source).VerifyIL("<top-level-statements-entry-point>", @"
+{
+  // Code size       29 (0x1d)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action Program.<>O.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void Program.<<Main>$>g__Target|0_0()""
+  IL_0010:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action Program.<>O.<0>__Target""
+  IL_001b:  pop
+  IL_001c:  ret
+}
+");
+    }
+
+    [Fact]
+    public void TopLevelStatement_Tuples_LocalFunction_TypeScoped1()
+    {
+        var source = @"
+var t = Target;
+static (int a, int b) Target() => (0, 0);
+";
+        CompileAndVerify(source).VerifyIL("<top-level-statements-entry-point>", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<System.ValueTuple<int, int>> Program.<>O.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""System.ValueTuple<int, int> Program.<<Main>$>g__Target|0_0()""
+  IL_000e:  newobj     ""System.Func<System.ValueTuple<int, int>>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Func<System.ValueTuple<int, int>> Program.<>O.<0>__Target""
+  IL_0018:  ret
+}
+");
+    }
+
+    [Fact]
+    public void TopLevelStatement_Tuples_LocalFunction_MethodScoped0()
+    {
+        var source = @"
+Test(0);
+static void Test<T>(T t)
+{
+    (System.Action a, int _) = (Target, 0);
+    static void Target() { }
+}
+";
+        CompileAndVerify(source).VerifyIL("Program.<<Main>$>g__Test|0_0<T>", @"
+{
+  // Code size       29 (0x1d)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Action Program.<Test>O__0_0<T>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void Program.<<Main>$>g__Target|0_1<T>()""
+  IL_0010:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Action Program.<Test>O__0_0<T>.<0>__Target""
+  IL_001b:  pop
+  IL_001c:  ret
+}
+");
+    }
+
+    [Fact]
+    public void TopLevelStatement_Tuples_LocalFunction_MethodScoped1()
+    {
+        var source = @"
+Test(0);
+static void Test<T>(T t)
+{
+    (System.Func<(T, int)> a, int _) = (Target, 0);
+    static (T, int) Target() => (default(T), 0);
+}
+";
+        CompileAndVerify(source).VerifyIL("Program.<<Main>$>g__Test|0_0<T>", @"
+{
+  // Code size       29 (0x1d)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<System.ValueTuple<T, int>> Program.<Test>O__0_0<T>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""System.ValueTuple<T, int> Program.<<Main>$>g__Target|0_1<T>()""
+  IL_0010:  newobj     ""System.Func<System.ValueTuple<T, int>>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<System.ValueTuple<T, int>> Program.<Test>O__0_0<T>.<0>__Target""
+  IL_001b:  pop
+  IL_001c:  ret
+}
+");
+    }
+
+    [Fact]
+    public void TopLevelStatement_Tuples_LocalFunction_MethodScoped2()
+    {
+        var source = @"
+Test(0);
+static void Test<T>(T t)
+{
+    (System.Func<T, (T, T)> a, int _) = (Target<T>, 0);
+    static (T, G) Target<G>(G g) => (default(T), g);
+}
+";
+        CompileAndVerify(source).VerifyIL("Program.<<Main>$>g__Test|0_0<T>", @"
+{
+  // Code size       29 (0x1d)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<T, System.ValueTuple<T, T>> Program.<Test>O__0_0<T>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""System.ValueTuple<T, T> Program.<<Main>$>g__Target|0_1<T, T>(T)""
+  IL_0010:  newobj     ""System.Func<T, System.ValueTuple<T, T>>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<T, System.ValueTuple<T, T>> Program.<Test>O__0_0<T>.<0>__Target""
+  IL_001b:  pop
+  IL_001c:  ret
+}
+");
+    }
+
+    [Fact]
+    public void TopLevelStatement_Tuples_LocalFunction_MethodScoped3()
+    {
+        var source = @"
+Test(0);
+static void Test<T>(T t)
+{
+    (System.Func<T, (T, T)> a, int _) = (Target<T, T>, 0);
+}
+static (T, G) Target<T, G>(G g) => (default(T), g);
+";
+        CompileAndVerify(source).VerifyIL("Program.<<Main>$>g__Test|0_0<T>", @"
+{
+  // Code size       29 (0x1d)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<T, System.ValueTuple<T, T>> Program.<Test>O__0_0<T>.<0>__Target""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""System.ValueTuple<T, T> Program.<<Main>$>g__Target|0_1<T, T>(T)""
+  IL_0010:  newobj     ""System.Func<T, System.ValueTuple<T, T>>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<T, System.ValueTuple<T, T>> Program.<Test>O__0_0<T>.<0>__Target""
+  IL_001b:  pop
+  IL_001c:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Tuples_LocalFunction_TypeScoped0()
+    {
+        var source = @"
+class C<T>
+{
+    void Test()
+    {
+        var x = Target;
+        static (T, T) Target(T t) => (t, t);
+    }
+}
+";
+        CompileAndVerify(source).VerifyIL("C<T>.Test", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<T, System.ValueTuple<T, T>> C<T>.<>O.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""System.ValueTuple<T, T> C<T>.<Test>g__Target|0_0(T)""
+  IL_000e:  newobj     ""System.Func<T, System.ValueTuple<T, T>>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Func<T, System.ValueTuple<T, T>> C<T>.<>O.<0>__Target""
+  IL_0018:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Tuples_LocalFunction_MethodScoped0()
+    {
+        var source = @"
+class C<T>
+{
+    void Test<G>()
+    {
+        var x = Target;
+        static (T, G) Target(T t, G g) => (t, g);
+    }
+}
+";
+        CompileAndVerify(source).VerifyIL("C<T>.Test<G>", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<T, G, System.ValueTuple<T, G>> C<T>.<Test>O__0_0<G>.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""System.ValueTuple<T, G> C<T>.<Test>g__Target|0_0<G>(T, G)""
+  IL_000e:  newobj     ""System.Func<T, G, System.ValueTuple<T, G>>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Func<T, G, System.ValueTuple<T, G>> C<T>.<Test>O__0_0<G>.<0>__Target""
+  IL_0018:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Tuples_LocalFunction_MethodScoped1()
+    {
+        var source = @"
+class C<T>
+{
+    void Test<G>()
+    {
+        var x = Target<T>;
+        static (T, G, V) Target<V>(T t, G g, V v) => (t, g, v);
+    }
+}
+";
+        CompileAndVerify(source).VerifyIL("C<T>.Test<G>", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<T, G, T, System.ValueTuple<T, G, T>> C<T>.<Test>O__0_0<G>.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""System.ValueTuple<T, G, T> C<T>.<Test>g__Target|0_0<G, T>(T, G, T)""
+  IL_000e:  newobj     ""System.Func<T, G, T, System.ValueTuple<T, G, T>>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Func<T, G, T, System.ValueTuple<T, G, T>> C<T>.<Test>O__0_0<G>.<0>__Target""
+  IL_0018:  ret
+}
+");
+    }
+
+    [Fact]
+    public void Tuples_LocalFunction_MethodScoped2()
+    {
+        var source = @"
+class M<N>
+{
+    void F<I>()
+    {
+        void Test<C>()
+        {
+            var x = Target<N>;
+            static (N, I, C, E) Target<E>(N n, I i, C c, E e) => (n, i, c, e);
+        }
+    }
+}
+";
+        CompileAndVerify(source).VerifyIL("M<N>.<F>g__Test|0_0<I, C>", @"
+{
+  // Code size       25 (0x19)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<N, I, C, N, System.ValueTuple<N, I, C, N>> M<N>.<Test>O__0_0<I, C>.<0>__Target""
+  IL_0005:  brtrue.s   IL_0018
+  IL_0007:  ldnull
+  IL_0008:  ldftn      ""System.ValueTuple<N, I, C, N> M<N>.<F>g__Target|0_1<I, C, N>(N, I, C, N)""
+  IL_000e:  newobj     ""System.Func<N, I, C, N, System.ValueTuple<N, I, C, N>>..ctor(object, System.IntPtr)""
+  IL_0013:  stsfld     ""System.Func<N, I, C, N, System.ValueTuple<N, I, C, N>> M<N>.<Test>O__0_0<I, C>.<0>__Target""
+  IL_0018:  ret
+}
+");
+    }
+
+    [Fact]
+    public void TestConditionalOperatorMethodGroup()
+    {
+        var source = @"
+class C
+{
+    static void Main()
+    {
+        bool b = true;
+        System.Func<int> f = null;
+        System.Console.WriteLine(f);
+        System.Func<int> g1 = b ? f : M;
+        System.Console.WriteLine(g1);
+        System.Func<int> g2 = b ? M : f;
+        System.Console.WriteLine(g2);
+    }
+
+    static int M()
+    {
+        return 0;
+    }
+}";
+        var comp = CompileAndVerify(source, parseOptions: TestOptions.RegularNext);
+        comp.VerifyDiagnostics();
+        comp.VerifyIL("C.Main", @"
+{
+  // Code size       85 (0x55)
+  .maxstack  3
+  .locals init (System.Func<int> V_0) //f
+  IL_0000:  ldc.i4.1
+  IL_0001:  ldnull
+  IL_0002:  stloc.0
+  IL_0003:  ldloc.0
+  IL_0004:  call       ""void System.Console.WriteLine(object)""
+  IL_0009:  dup
+  IL_000a:  brtrue.s   IL_0029
+  IL_000c:  ldsfld     ""System.Func<int> C.<>O.<0>__M""
+  IL_0011:  dup
+  IL_0012:  brtrue.s   IL_002a
+  IL_0014:  pop
+  IL_0015:  ldnull
+  IL_0016:  ldftn      ""int C.M()""
+  IL_001c:  newobj     ""System.Func<int>..ctor(object, System.IntPtr)""
+  IL_0021:  dup
+  IL_0022:  stsfld     ""System.Func<int> C.<>O.<0>__M""
+  IL_0027:  br.s       IL_002a
+  IL_0029:  ldloc.0
+  IL_002a:  call       ""void System.Console.WriteLine(object)""
+  IL_002f:  brtrue.s   IL_0034
+  IL_0031:  ldloc.0
+  IL_0032:  br.s       IL_004f
+  IL_0034:  ldsfld     ""System.Func<int> C.<>O.<0>__M""
+  IL_0039:  dup
+  IL_003a:  brtrue.s   IL_004f
+  IL_003c:  pop
+  IL_003d:  ldnull
+  IL_003e:  ldftn      ""int C.M()""
+  IL_0044:  newobj     ""System.Func<int>..ctor(object, System.IntPtr)""
+  IL_0049:  dup
+  IL_004a:  stsfld     ""System.Func<int> C.<>O.<0>__M""
+  IL_004f:  call       ""void System.Console.WriteLine(object)""
+  IL_0054:  ret
+}
+");
+    }
+
+    [Fact]
+    public void WinMdEventAssignment()
+    {
+        var source = @"
+class C
+{
+    public event System.Action Instance;
+    public static event System.Action Static;
+}
+
+class D
+{
+    C c;
+
+    void InstanceAdd()
+    {
+        c.Instance += Action;
+    }
+
+    void InstanceRemove()
+    {
+        c.Instance -= Action;
+    }
+
+    static void StaticAdd()
+    {
+        C.Static += Action;
+    }
+
+    static void StaticRemove()
+    {
+        C.Static -= Action;
+    }
+
+    static void Action()
+    {
+    }
+}
+";
+        var verifier = CompileAndVerifyWithWinRt(source, parseOptions: TestOptions.RegularNext, options: TestOptions.ReleaseWinMD);
+
+        verifier.VerifyIL("D.InstanceAdd", @"
+{
+  // Code size       64 (0x40)
+  .maxstack  4
+  .locals init (C V_0)
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""C D.c""
+  IL_0006:  stloc.0
+  IL_0007:  ldloc.0
+  IL_0008:  ldftn      ""System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken C.Instance.add""
+  IL_000e:  newobj     ""System.Func<System.Action, System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>..ctor(object, System.IntPtr)""
+  IL_0013:  ldloc.0
+  IL_0014:  ldftn      ""void C.Instance.remove""
+  IL_001a:  newobj     ""System.Action<System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>..ctor(object, System.IntPtr)""
+  IL_001f:  ldsfld     ""System.Action D.<>O.<0>__Action""
+  IL_0024:  dup
+  IL_0025:  brtrue.s   IL_003a
+  IL_0027:  pop
+  IL_0028:  ldnull
+  IL_0029:  ldftn      ""void D.Action()""
+  IL_002f:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0034:  dup
+  IL_0035:  stsfld     ""System.Action D.<>O.<0>__Action""
+  IL_003a:  call       ""void System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal.AddEventHandler<System.Action>(System.Func<System.Action, System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>, System.Action<System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>, System.Action)""
+  IL_003f:  ret
+}");
+
+        verifier.VerifyIL("D.InstanceRemove", @"
+{
+  // Code size       50 (0x32)
+  .maxstack  3
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""C D.c""
+  IL_0006:  ldftn      ""void C.Instance.remove""
+  IL_000c:  newobj     ""System.Action<System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>..ctor(object, System.IntPtr)""
+  IL_0011:  ldsfld     ""System.Action D.<>O.<0>__Action""
+  IL_0016:  dup
+  IL_0017:  brtrue.s   IL_002c
+  IL_0019:  pop
+  IL_001a:  ldnull
+  IL_001b:  ldftn      ""void D.Action()""
+  IL_0021:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0026:  dup
+  IL_0027:  stsfld     ""System.Action D.<>O.<0>__Action""
+  IL_002c:  call       ""void System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal.RemoveEventHandler<System.Action>(System.Action<System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>, System.Action)""
+  IL_0031:  ret
+}");
+        verifier.VerifyIL("D.StaticAdd", @"
+{
+  // Code size       57 (0x39)
+  .maxstack  4
+  IL_0000:  ldnull
+  IL_0001:  ldftn      ""System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken C.Static.add""
+  IL_0007:  newobj     ""System.Func<System.Action, System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>..ctor(object, System.IntPtr)""
+  IL_000c:  ldnull
+  IL_000d:  ldftn      ""void C.Static.remove""
+  IL_0013:  newobj     ""System.Action<System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>..ctor(object, System.IntPtr)""
+  IL_0018:  ldsfld     ""System.Action D.<>O.<0>__Action""
+  IL_001d:  dup
+  IL_001e:  brtrue.s   IL_0033
+  IL_0020:  pop
+  IL_0021:  ldnull
+  IL_0022:  ldftn      ""void D.Action()""
+  IL_0028:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_002d:  dup
+  IL_002e:  stsfld     ""System.Action D.<>O.<0>__Action""
+  IL_0033:  call       ""void System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal.AddEventHandler<System.Action>(System.Func<System.Action, System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>, System.Action<System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>, System.Action)""
+  IL_0038:  ret
+}");
+
+        verifier.VerifyIL("D.StaticRemove", @"
+{
+  // Code size       45 (0x2d)
+  .maxstack  3
+  IL_0000:  ldnull
+  IL_0001:  ldftn      ""void C.Static.remove""
+  IL_0007:  newobj     ""System.Action<System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>..ctor(object, System.IntPtr)""
+  IL_000c:  ldsfld     ""System.Action D.<>O.<0>__Action""
+  IL_0011:  dup
+  IL_0012:  brtrue.s   IL_0027
+  IL_0014:  pop
+  IL_0015:  ldnull
+  IL_0016:  ldftn      ""void D.Action()""
+  IL_001c:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0021:  dup
+  IL_0022:  stsfld     ""System.Action D.<>O.<0>__Action""
+  IL_0027:  call       ""void System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal.RemoveEventHandler<System.Action>(System.Action<System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>, System.Action)""
+  IL_002c:  ret
+}");
+    }
+
+    [Fact]
+    public void WinMdEventFieldAssignment()
+    {
+        var source = @"
+class C
+{
+    public event System.Action Instance;
+    public static event System.Action Static;
+
+    void InstanceAssign()
+    {
+        Instance = Action;
+    }
+
+    static void StaticAssign()
+    {
+        Static = Action;
+    }
+
+    static void Action()
+    {
+    }
+}
+";
+        var verifier = CompileAndVerifyWithWinRt(source, parseOptions: TestOptions.RegularNext, options: TestOptions.ReleaseWinMD);
+
+        verifier.VerifyIL("C.InstanceAssign", @"
+{
+  // Code size       74 (0x4a)
+  .maxstack  4
+  IL_0000:  ldarg.0
+  IL_0001:  ldftn      ""void C.Instance.remove""
+  IL_0007:  newobj     ""System.Action<System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>..ctor(object, System.IntPtr)""
+  IL_000c:  call       ""void System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal.RemoveAllEventHandlers(System.Action<System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>)""
+  IL_0011:  ldarg.0
+  IL_0012:  ldftn      ""System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken C.Instance.add""
+  IL_0018:  newobj     ""System.Func<System.Action, System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>..ctor(object, System.IntPtr)""
+  IL_001d:  ldarg.0
+  IL_001e:  ldftn      ""void C.Instance.remove""
+  IL_0024:  newobj     ""System.Action<System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>..ctor(object, System.IntPtr)""
+  IL_0029:  ldsfld     ""System.Action C.<>O.<0>__Action""
+  IL_002e:  dup
+  IL_002f:  brtrue.s   IL_0044
+  IL_0031:  pop
+  IL_0032:  ldnull
+  IL_0033:  ldftn      ""void C.Action()""
+  IL_0039:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_003e:  dup
+  IL_003f:  stsfld     ""System.Action C.<>O.<0>__Action""
+  IL_0044:  call       ""void System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal.AddEventHandler<System.Action>(System.Func<System.Action, System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>, System.Action<System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>, System.Action)""
+  IL_0049:  ret
+}");
+
+        verifier.VerifyIL("C.StaticAssign", @"
+{
+  // Code size       74 (0x4a)
+  .maxstack  4
+  IL_0000:  ldnull
+  IL_0001:  ldftn      ""void C.Static.remove""
+  IL_0007:  newobj     ""System.Action<System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>..ctor(object, System.IntPtr)""
+  IL_000c:  call       ""void System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal.RemoveAllEventHandlers(System.Action<System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>)""
+  IL_0011:  ldnull
+  IL_0012:  ldftn      ""System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken C.Static.add""
+  IL_0018:  newobj     ""System.Func<System.Action, System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>..ctor(object, System.IntPtr)""
+  IL_001d:  ldnull
+  IL_001e:  ldftn      ""void C.Static.remove""
+  IL_0024:  newobj     ""System.Action<System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>..ctor(object, System.IntPtr)""
+  IL_0029:  ldsfld     ""System.Action C.<>O.<0>__Action""
+  IL_002e:  dup
+  IL_002f:  brtrue.s   IL_0044
+  IL_0031:  pop
+  IL_0032:  ldnull
+  IL_0033:  ldftn      ""void C.Action()""
+  IL_0039:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_003e:  dup
+  IL_003f:  stsfld     ""System.Action C.<>O.<0>__Action""
+  IL_0044:  call       ""void System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal.AddEventHandler<System.Action>(System.Func<System.Action, System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>, System.Action<System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken>, System.Action)""
+  IL_0049:  ret
+}");
+    }
+
+    [Fact]
+    public void LockDelegate()
+    {
+        var text =
+@"
+delegate void D(string p1);
+partial class Test
+{
+    public static void Main()
+    {
+        D d1;
+        lock (d1 = PM)
+        {
+            d1(""PASS"");
+        }
+    }
+    static partial void PM(string p2);
+    static partial void PM(string p2)
+    {
+        System.Console.WriteLine(p2);
+    }
+}
+";
+
+        CompileAndVerify(text, parseOptions: TestOptions.RegularNext, expectedOutput: PASS).VerifyIL("Test.Main", @"
+{
+  // Code size       64 (0x40)
+  .maxstack  2
+  .locals init (D V_0, //d1
+                D V_1,
+                bool V_2)
+  IL_0000:  ldsfld     ""D Test.<>O.<0>__PM""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""void Test.PM(string)""
+  IL_0010:  newobj     ""D..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""D Test.<>O.<0>__PM""
+  IL_001b:  dup
+  IL_001c:  stloc.0
+  IL_001d:  stloc.1
+  IL_001e:  ldc.i4.0
+  IL_001f:  stloc.2
+  .try
+  {
+    IL_0020:  ldloc.1
+    IL_0021:  ldloca.s   V_2
+    IL_0023:  call       ""void System.Threading.Monitor.Enter(object, ref bool)""
+    IL_0028:  ldloc.0
+    IL_0029:  ldstr      ""PASS""
+    IL_002e:  callvirt   ""void D.Invoke(string)""
+    IL_0033:  leave.s    IL_003f
+  }
+  finally
+  {
+    IL_0035:  ldloc.2
+    IL_0036:  brfalse.s  IL_003e
+    IL_0038:  ldloc.1
+    IL_0039:  call       ""void System.Threading.Monitor.Exit(object)""
+    IL_003e:  endfinally
+  }
+  IL_003f:  ret
+}
+");
+    }
+
+    [Fact]
+    public void NullCoalescingAssignmentValidRHS()
+    {
+        CompileAndVerify(@"
+using System;
+public class C
+{
+    public static void Main()
+    {
+        Action a = null;
+        (a ??= TestMethod)();
+        (a ??= () => {})();
+    }
+    static void TestMethod() => Console.WriteLine(""In TestMethod"");
+}
+", parseOptions: TestOptions.RegularNext, expectedOutput: @"
+In TestMethod
+In TestMethod
+").VerifyIL("C.Main()", @"
+{
+  // Code size       85 (0x55)
+  .maxstack  2
+  .locals init (System.Action V_0) //a
+  IL_0000:  ldnull
+  IL_0001:  stloc.0
+  IL_0002:  ldloc.0
+  IL_0003:  dup
+  IL_0004:  brtrue.s   IL_0024
+  IL_0006:  pop
+  IL_0007:  ldsfld     ""System.Action C.<>O.<0>__TestMethod""
+  IL_000c:  dup
+  IL_000d:  brtrue.s   IL_0022
+  IL_000f:  pop
+  IL_0010:  ldnull
+  IL_0011:  ldftn      ""void C.TestMethod()""
+  IL_0017:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_001c:  dup
+  IL_001d:  stsfld     ""System.Action C.<>O.<0>__TestMethod""
+  IL_0022:  dup
+  IL_0023:  stloc.0
+  IL_0024:  callvirt   ""void System.Action.Invoke()""
+  IL_0029:  ldloc.0
+  IL_002a:  dup
+  IL_002b:  brtrue.s   IL_004f
+  IL_002d:  pop
+  IL_002e:  ldsfld     ""System.Action C.<>c.<>9__0_0""
+  IL_0033:  dup
+  IL_0034:  brtrue.s   IL_004d
+  IL_0036:  pop
+  IL_0037:  ldsfld     ""C.<>c C.<>c.<>9""
+  IL_003c:  ldftn      ""void C.<>c.<Main>b__0_0()""
+  IL_0042:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0047:  dup
+  IL_0048:  stsfld     ""System.Action C.<>c.<>9__0_0""
+  IL_004d:  dup
+  IL_004e:  stloc.0
+  IL_004f:  callvirt   ""void System.Action.Invoke()""
+  IL_0054:  ret
+}");
+    }
+
+    [Fact]
+    public void ImplicitlyTypedVariables_01()
+    {
+        var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        var d1 = Main;
+        Report(d1);
+        var d2 = () => { };
+        Report(d2);
+        var d3 = delegate () { };
+        Report(d3);
+    }
+    static void Report(Delegate d) => Console.WriteLine($""{d.GetType().Namespace}.{d.GetType().Name}"");
+}";
+
+        var comp = CreateCompilation(source, parseOptions: TestOptions.RegularNext, options: TestOptions.DebugExe);
+        comp.VerifyDiagnostics();
+
+        var verifier = CompileAndVerify(comp, expectedOutput:
+@"System.Action
+System.Action
+System.Action");
+        verifier.VerifyIL("Program.Main", @"
+{
+  // Code size      115 (0x73)
+  .maxstack  2
+  .locals init (System.Action V_0, //d1
+                System.Action V_1, //d2
+                System.Action V_2) //d3
+  IL_0000:  nop
+  IL_0001:  ldsfld     ""System.Action Program.<>O.<0>__Main""
+  IL_0006:  dup
+  IL_0007:  brtrue.s   IL_001c
+  IL_0009:  pop
+  IL_000a:  ldnull
+  IL_000b:  ldftn      ""void Program.Main()""
+  IL_0011:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0016:  dup
+  IL_0017:  stsfld     ""System.Action Program.<>O.<0>__Main""
+  IL_001c:  stloc.0
+  IL_001d:  ldloc.0
+  IL_001e:  call       ""void Program.Report(System.Delegate)""
+  IL_0023:  nop
+  IL_0024:  ldsfld     ""System.Action Program.<>c.<>9__0_0""
+  IL_0029:  dup
+  IL_002a:  brtrue.s   IL_0043
+  IL_002c:  pop
+  IL_002d:  ldsfld     ""Program.<>c Program.<>c.<>9""
+  IL_0032:  ldftn      ""void Program.<>c.<Main>b__0_0()""
+  IL_0038:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_003d:  dup
+  IL_003e:  stsfld     ""System.Action Program.<>c.<>9__0_0""
+  IL_0043:  stloc.1
+  IL_0044:  ldloc.1
+  IL_0045:  call       ""void Program.Report(System.Delegate)""
+  IL_004a:  nop
+  IL_004b:  ldsfld     ""System.Action Program.<>c.<>9__0_1""
+  IL_0050:  dup
+  IL_0051:  brtrue.s   IL_006a
+  IL_0053:  pop
+  IL_0054:  ldsfld     ""Program.<>c Program.<>c.<>9""
+  IL_0059:  ldftn      ""void Program.<>c.<Main>b__0_1()""
+  IL_005f:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_0064:  dup
+  IL_0065:  stsfld     ""System.Action Program.<>c.<>9__0_1""
+  IL_006a:  stloc.2
+  IL_006b:  ldloc.2
+  IL_006c:  call       ""void Program.Report(System.Delegate)""
+  IL_0071:  nop
+  IL_0072:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CustomModifiers_Method()
+    {
+        var ilSource = @"
+.class public auto ansi beforefieldinit C1`1<T>
+    extends System.Object
+{
+    // Methods
+    .method public hidebysig static 
+        string Method () cil managed 
+    {
+        // Method begins at RVA 0x2050
+        // Code size 6 (0x6)
+        .maxstack 8
+
+        IL_0000: ldstr ""PASS""
+        IL_0005: ret
+    } // end of method C1`1::Method
+
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        // Method begins at RVA 0x2057
+        // Code size 7 (0x7)
+        .maxstack 8
+
+        IL_0000: ldarg.0
+        IL_0001: call instance void System.Object::.ctor()
+        IL_0006: ret
+    } // end of method C1`1::.ctor
+
+} // end of class C1`1
+
+.class public auto ansi beforefieldinit C2`1<T>
+    extends System.Object
+{
+    // Methods
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        // Method begins at RVA 0x2057
+        // Code size 7 (0x7)
+        .maxstack 8
+
+        IL_0000: ldarg.0
+        IL_0001: call instance void System.Object::.ctor()
+        IL_0006: ret
+    } // end of method C2`1::.ctor
+
+} // end of class C2`1
+
+.class public auto ansi beforefieldinit C3`1<T>
+    extends class C1`1<int32 modopt(class C2`1<!T>)>
+{
+    // Methods
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        // Method begins at RVA 0x205f
+        // Code size 7 (0x7)
+        .maxstack 8
+
+        IL_0000: ldarg.0
+        IL_0001: call instance void class C1`1<int32>::.ctor()
+        IL_0006: ret
+    } // end of method C3`1::.ctor
+
+} // end of class C3`1
+";
+        var source = @"
+class Test
+{
+    static void Main()
+    {
+        M<int>();
+    }
+
+    static void M<G>()
+    {
+        System.Func<string> x = C3<G>.Method;
+        System.Console.WriteLine(x());
+    }
+}
+";
+        var compilation = CreateCompilationWithIL(source, ilSource, options: TestOptions.ReleaseExe);
+        var verifier = CompileAndVerify(compilation, expectedOutput: PASS);
+        verifier.VerifyIL("Test.M<G>", @"
+{
+  // Code size       38 (0x26)
+  .maxstack  2
+  IL_0000:  ldsfld     ""System.Func<string> Test.<M>O__1_0<G>.<0>__Method""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_001b
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  ldftn      ""string C1<int>.Method()""
+  IL_0010:  newobj     ""System.Func<string>..ctor(object, System.IntPtr)""
+  IL_0015:  dup
+  IL_0016:  stsfld     ""System.Func<string> Test.<M>O__1_0<G>.<0>__Method""
+  IL_001b:  callvirt   ""string System.Func<string>.Invoke()""
+  IL_0020:  call       ""void System.Console.WriteLine(string)""
+  IL_0025:  ret
+}
+");
+    }
+
+    [Fact]
+    public void CustomModifiers_Delegate()
+    {
+        var ilSource = @"
+.class public auto ansi beforefieldinit C1`1<T>
+	extends [mscorlib]System.Object
+{
+	// Nested Types
+	.class nested public auto ansi sealed F<T>
+		extends [mscorlib]System.MulticastDelegate
+	{
+		// Methods
+		.method public hidebysig specialname rtspecialname 
+			instance void .ctor (
+				object 'object',
+				native int 'method'
+			) runtime managed 
+		{
+		} // end of method F::.ctor
+
+		.method public hidebysig newslot virtual 
+			instance string Invoke () runtime managed 
+		{
+		} // end of method F::Invoke
+
+		.method public hidebysig newslot virtual 
+			instance class [mscorlib]System.IAsyncResult BeginInvoke (
+				class [mscorlib]System.AsyncCallback callback,
+				object 'object'
+			) runtime managed 
+		{
+		} // end of method F::BeginInvoke
+
+		.method public hidebysig newslot virtual 
+			instance string EndInvoke (
+				class [mscorlib]System.IAsyncResult result
+			) runtime managed 
+		{
+		} // end of method F::EndInvoke
+
+	} // end of class F
+
+
+	// Methods
+	.method public hidebysig specialname rtspecialname 
+		instance void .ctor () cil managed 
+	{
+		// Method begins at RVA 0x211f
+		// Code size 8 (0x8)
+		.maxstack 8
+
+		IL_0000: ldarg.0
+		IL_0001: call instance void [mscorlib]System.Object::.ctor()
+		IL_0006: nop
+		IL_0007: ret
+	} // end of method C1`1::.ctor
+
+} // end of class C1`1
+
+.class public auto ansi beforefieldinit C2`1<T>
+    extends System.Object
+{
+    // Methods
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        // Method begins at RVA 0x2057
+        // Code size 7 (0x7)
+        .maxstack 8
+
+        IL_0000: ldarg.0
+        IL_0001: call instance void System.Object::.ctor()
+        IL_0006: ret
+    } // end of method C2`1::.ctor
+
+} // end of class C2`1
+
+.class public auto ansi beforefieldinit C3`1<T>
+    extends class C1`1<int32 modopt(class C2`1<!T>)>
+{
+    // Methods
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        // Method begins at RVA 0x205f
+        // Code size 7 (0x7)
+        .maxstack 8
+
+        IL_0000: ldarg.0
+        IL_0001: call instance void class C1`1<int32>::.ctor()
+        IL_0006: ret
+    } // end of method C3`1::.ctor
+
+} // end of class C3`1
+";
+        var source = @"
+class Test
+{
+    static void Main()
+    {
+        M<int>();
+    }
+
+    static void M<G>()
+    {
+        C3<G>.F x = Method;
+        System.Console.WriteLine(x());
+    }
+
+    static string Method() => ""PASS"";
+}
+";
+        static void containerValidator(ModuleSymbol module)
+        {
+            var container = module.GlobalNamespace.GetMember<NamedTypeSymbol>("Test.<M>O__1_0");
+            var field = Assert.Single(container.GetMembers()) as FieldSymbol;
+            AssertEx.NotNull(field);
+
+            var typeParameters = new List<TypeParameterSymbol>();
+            field.Type.VisitType(static (typeSymbol, typeParameters, _) =>
+            {
+                if (typeSymbol is TypeParameterSymbol typeParameter)
+                {
+                    typeParameters.Add(typeParameter);
+                }
+
+                return false;
+            },
+            typeParameters, visitCustomModifiers: true);
+
+            var typeParameter = Assert.Single(typeParameters);
+            Assert.Equal("G", typeParameter.Name);
+            Assert.Equal("<M>O__1_0", typeParameter.ContainingSymbol.Name);
+        }
+        var compilation = CreateCompilationWithIL(source, ilSource, options: TestOptions.DebugExe);
+        var verifier = CompileAndVerify(compilation, expectedOutput: PASS, symbolValidator: containerValidator);
+        verifier.VerifyIL("Test.M<G>", @"
+{
+  // Code size       42 (0x2a)
+  .maxstack  2
+  .locals init (C1<int>.F V_0) //x
+  IL_0000:  nop
+  IL_0001:  ldsfld     ""C1<int>.F Test.<M>O__1_0<G>.<0>__Method""
+  IL_0006:  dup
+  IL_0007:  brtrue.s   IL_001c
+  IL_0009:  pop
+  IL_000a:  ldnull
+  IL_000b:  ldftn      ""string Test.Method()""
+  IL_0011:  newobj     ""C1<int>.F..ctor(object, System.IntPtr)""
+  IL_0016:  dup
+  IL_0017:  stsfld     ""C1<int>.F Test.<M>O__1_0<G>.<0>__Method""
+  IL_001c:  stloc.0
+  IL_001d:  ldloc.0
+  IL_001e:  callvirt   ""string C1<int>.F.Invoke()""
+  IL_0023:  call       ""void System.Console.WriteLine(string)""
+  IL_0028:  nop
+  IL_0029:  ret
+}
+");
+    }
+
+    private static Action<ModuleSymbol> VerifyCacheContainer(string typeName, int arity, params string[] expectedFields)
+    {
+        return module =>
+        {
+            var container = module.GlobalNamespace.GetMember<NamedTypeSymbol>(typeName);
+            AssertEx.NotNull(container);
+            Assert.Equal(arity, container.Arity);
+
+            var fields = container.GetMembers().OfType<FieldSymbol>().Select(field => $"{field.Type.ToTestDisplayString()} {field.Name}").ToArray();
+            AssertEx.SetEqual(expectedFields, fields);
+        };
+    }
+
+    private static Action<ModuleSymbol> VerifyNoCacheContainersIn(string containingTypeName)
+    {
+        return module =>
+        {
+            var containingType = module.GlobalNamespace.GetMember<NamedTypeSymbol>(containingTypeName);
+            AssertEx.NotNull(containingType);
+
+            var nestedTypes = containingType.GetTypeMembers();
+            Assert.DoesNotContain(nestedTypes, t => t.Name.StartsWith("<") && t.Name.Contains(">O"));
+        };
+    }
+
+}
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs
index 9f9c94f3dded2..b2f4bbe6f5f4b 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs
@@ -6997,7 +6997,7 @@ static void Main()
                 //         var d3 = delegate () { };
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion9, "delegate () { }").WithArguments("inferred delegate type", "10.0").WithLocation(10, 18));
 
-            comp = CreateCompilation(new[] { source, s_utils }, options: TestOptions.DebugExe);
+            comp = CreateCompilation(new[] { source, s_utils }, parseOptions: TestOptions.Regular10, options: TestOptions.DebugExe);
             comp.VerifyDiagnostics();
 
             var verifier = CompileAndVerify(comp, expectedOutput:
@@ -8099,7 +8099,7 @@ static void Main()
     static void Report(Delegate d) => Console.WriteLine(d.GetType());
 }";
 
-            var comp = CreateCompilation(source, options: TestOptions.ReleaseExe);
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular10, options: TestOptions.ReleaseExe);
             comp.VerifyDiagnostics();
 
             var verifier = CompileAndVerify(comp, expectedOutput:
@@ -8320,7 +8320,7 @@ static void Main()
     static void Report(Delegate d) => Console.WriteLine(d.GetType());
 }";
 
-            var comp = CreateCompilation(source, options: TestOptions.ReleaseExe);
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular10, options: TestOptions.ReleaseExe);
             comp.VerifyDiagnostics();
 
             var verifier = CompileAndVerify(comp, expectedOutput:
@@ -8768,7 +8768,7 @@ static void Main()
     static void Report(Delegate d) => Console.WriteLine(d.GetType());
 }";
 
-            var comp = CreateCompilation(source, options: TestOptions.ReleaseExe);
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular10, options: TestOptions.ReleaseExe);
             var verifier = CompileAndVerify(comp, validator: validator, expectedOutput: "D");
 
             static void validator(PEAssembly assembly)
@@ -8809,7 +8809,7 @@ static void Main()
     static void Report(Delegate d) => Console.WriteLine(d.GetType());
 }";
 
-            var comp = CreateCompilation(source, options: TestOptions.ReleaseExe);
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular10, options: TestOptions.ReleaseExe);
             var verifier = CompileAndVerify(comp, validator: validator, expectedOutput:
 @"<>A{00000001}`2[System.Object,System.Object]
 D2
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/ExtensionMethodTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/ExtensionMethodTests.cs
index b55e4e942dc56..685720e450387 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/ExtensionMethodTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/ExtensionMethodTests.cs
@@ -2255,7 +2255,7 @@ .maxstack  3
   IL_0024:  call       ""string System.Linq.Enumerable.Aggregate<string>(System.Collections.Generic.IEnumerable<string>, System.Func<string, string, string>)""
   IL_0029:  ret       
 }";
-            var compilation = CompileAndVerify(source, expectedOutput: "orange, apple");
+            var compilation = CompileAndVerify(source, parseOptions: TestOptions.Regular10, expectedOutput: "orange, apple");
             compilation.VerifyIL("C.F", code);
             compilation.VerifyIL("C.G", code);
         }
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/StaticAbstractMembersInInterfacesTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/StaticAbstractMembersInInterfacesTests.cs
index 8384e21906a84..1c2c2532ba11d 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/StaticAbstractMembersInInterfacesTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/StaticAbstractMembersInInterfacesTests.cs
@@ -12152,18 +12152,24 @@ static System.Action M02<T, U>() where T : U where U : I1
             verifier.VerifyIL("Test.M02<T, U>()",
 @"
 {
-  // Code size       24 (0x18)
+  // Code size       39 (0x27)
   .maxstack  2
   .locals init (System.Action V_0)
   IL_0000:  nop
-  IL_0001:  ldnull
-  IL_0002:  constrained. ""T""
-  IL_0008:  ldftn      ""void I1.M01()""
-  IL_000e:  newobj     ""System.Action..ctor(object, System.IntPtr)""
-  IL_0013:  stloc.0
-  IL_0014:  br.s       IL_0016
-  IL_0016:  ldloc.0
-  IL_0017:  ret
+  IL_0001:  ldsfld     ""System.Action Test.<>O.<0>__M01""
+  IL_0006:  dup
+  IL_0007:  brtrue.s   IL_0022
+  IL_0009:  pop
+  IL_000a:  ldnull
+  IL_000b:  constrained. ""T""
+  IL_0011:  ldftn      ""void I1.M01()""
+  IL_0017:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_001c:  dup
+  IL_001d:  stsfld     ""System.Action Test.<>O.<0>__M01""
+  IL_0022:  stloc.0
+  IL_0023:  br.s       IL_0025
+  IL_0025:  ldloc.0
+  IL_0026:  ret
 }
 ");
 
@@ -12176,13 +12182,19 @@ .locals init (System.Action V_0)
             verifier.VerifyIL("Test.M02<T, U>()",
 @"
 {
-  // Code size       19 (0x13)
+  // Code size       34 (0x22)
   .maxstack  2
-  IL_0000:  ldnull
-  IL_0001:  constrained. ""T""
-  IL_0007:  ldftn      ""void I1.M01()""
-  IL_000d:  newobj     ""System.Action..ctor(object, System.IntPtr)""
-  IL_0012:  ret
+  IL_0000:  ldsfld     ""System.Action Test.<>O.<0>__M01""
+  IL_0005:  dup
+  IL_0006:  brtrue.s   IL_0021
+  IL_0008:  pop
+  IL_0009:  ldnull
+  IL_000a:  constrained. ""T""
+  IL_0010:  ldftn      ""void I1.M01()""
+  IL_0016:  newobj     ""System.Action..ctor(object, System.IntPtr)""
+  IL_001b:  dup
+  IL_001c:  stsfld     ""System.Action Test.<>O.<0>__M01""
+  IL_0021:  ret
 }
 ");
 
diff --git a/src/Compilers/CSharp/Test/WinRT/CodeGen/WinMdEventTests.cs b/src/Compilers/CSharp/Test/WinRT/CodeGen/WinMdEventTests.cs
index 0d9339ad85c34..10b823874e0c7 100644
--- a/src/Compilers/CSharp/Test/WinRT/CodeGen/WinMdEventTests.cs
+++ b/src/Compilers/CSharp/Test/WinRT/CodeGen/WinMdEventTests.cs
@@ -277,7 +277,7 @@ static void Action()
     }
 }
 ";
-            var verifier = CompileAndVerifyWithWinRt(source, options: TestOptions.ReleaseWinMD);
+            var verifier = CompileAndVerifyWithWinRt(source, parseOptions: TestOptions.Regular10, options: TestOptions.ReleaseWinMD);
 
             verifier.VerifyIL("D.InstanceAdd", @"
 {
@@ -370,7 +370,7 @@ static void Action()
     }
 }
 ";
-            var verifier = CompileAndVerifyWithWinRt(source, options: TestOptions.ReleaseWinMD);
+            var verifier = CompileAndVerifyWithWinRt(source, parseOptions: TestOptions.Regular10, options: TestOptions.ReleaseWinMD);
 
             verifier.VerifyIL("C.InstanceAssign", @"
 {
diff --git a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/ExpressionCompilerTests.cs b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/ExpressionCompilerTests.cs
index aac4c63c0c555..deba1106a7a49 100644
--- a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/ExpressionCompilerTests.cs
+++ b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/ExpressionCompilerTests.cs
@@ -1742,7 +1742,7 @@ static void M1()
     static void M2() { }
     static void M2(int i) { }
 }";
-            var compilation0 = CreateCompilation(source, options: TestOptions.DebugDll);
+            var compilation0 = CreateCompilation(source, parseOptions: TestOptions.Regular10, options: TestOptions.DebugDll);
             WithRuntimeInstance(compilation0, runtime =>
             {
                 var context = CreateMethodContext(
@@ -1756,7 +1756,12 @@ static void M2(int i) { }
                     error: out error,
                     testData: testData);
                 Assert.Equal("error CS8917: The delegate type could not be inferred.", error);
+
                 testData = new CompilationTestData();
+
+                // If you see this failing, please fix https://github.com/dotnet/roslyn/issues/58449
+                Assert.Equal(compilation0.LanguageVersion, context.Compilation.LanguageVersion);
+
                 context.CompileAssignment(
                     target: "o",
                     expr: "M1",
@@ -4170,13 +4175,20 @@ static void M()
     {
     }
 }";
-            var testData = Evaluate(
-                source,
-                OutputKind.DynamicallyLinkedLibrary,
-                methodName: "C.M",
-                expr: "G(F)");
-            testData.GetMethodData("<>x.<>m0").VerifyIL(
-@"{
+            var compilation = CreateCompilation(source, parseOptions: TestOptions.Regular10, options: TestOptions.DebugDll);
+            WithRuntimeInstance(compilation, runtime =>
+            {
+                var context = CreateMethodContext(
+                    runtime,
+                    methodName: "C.M");
+                var testData = new CompilationTestData();
+                var result = context.CompileExpression("G(F)", out var error, testData);
+
+                // If you see this failing, please fix https://github.com/dotnet/roslyn/issues/58449
+                Assert.Equal(compilation.LanguageVersion, context.Compilation.LanguageVersion);
+
+                testData.GetMethodData("<>x.<>m0").VerifyIL(@"
+{
   // Code size       18 (0x12)
   .maxstack  2
   IL_0000:  ldnull
@@ -4184,7 +4196,9 @@ .maxstack  2
   IL_0007:  newobj     ""D..ctor(object, System.IntPtr)""
   IL_000c:  call       ""void C.G(D)""
   IL_0011:  ret
-}");
+}
+");
+            });
         }
 
         [Fact]
diff --git a/src/Scripting/CSharpTest/ScriptTests.cs b/src/Scripting/CSharpTest/ScriptTests.cs
index 26a2149230765..290d9a4505eb1 100644
--- a/src/Scripting/CSharpTest/ScriptTests.cs
+++ b/src/Scripting/CSharpTest/ScriptTests.cs
@@ -471,6 +471,31 @@ public async Task TestBranchingSubscripts()
             Assert.Equal(10, state3.ReturnValue);
         }
 
+        [Fact]
+        public async Task StaticDelegate0()
+        {
+            var state0 = await CSharpScript.RunAsync("static int Add(int x, int y) => x + y;", options: ScriptOptions.Default.WithLanguageVersion(LanguageVersion.Preview));
+            var state1 = await state0.ContinueWithAsync("System.Func<int, int, int> adder = Add;");
+            var state2 = await state1.ContinueWithAsync("adder(1, 1)");
+            Assert.Equal(2, state2.ReturnValue);
+        }
+
+        [Fact]
+        public async Task StaticDelegate1()
+        {
+            var state0 = await CSharpScript.RunAsync("class Id<T> { static T Core(T t) => t; public static System.Func<T, T> Get => Core; }");
+            var state1 = await state0.ContinueWithAsync("Id<int>.Get(1)");
+            Assert.Equal(1, state1.ReturnValue);
+        }
+
+        [Fact]
+        public async Task StaticDelegate2()
+        {
+            var state0 = await CSharpScript.RunAsync("class Id { static T Core<T>(T t) => t; public static System.Func<T, T> Get<T>() => Core; }");
+            var state1 = await state0.ContinueWithAsync("Id.Get<int>()(1)");
+            Assert.Equal(1, state1.ReturnValue);
+        }
+
         [Fact]
         public async Task ReturnIntAsObject()
         {

From b2f50a28026caf0dc264ece40c6fe3c782e956de Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Wed, 12 Jan 2022 16:47:56 -0800
Subject: [PATCH 328/444] Remove unnecessary lock access setting UIContexts in
 the workspace

---
 .../VisualStudioProjectFactory.cs             |  4 +-
 .../VisualStudioWorkspaceImpl.cs              | 48 ++++++++++++-------
 2 files changed, 33 insertions(+), 19 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioProjectFactory.cs b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioProjectFactory.cs
index 6ed24981086a0..d7154bd1527a6 100644
--- a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioProjectFactory.cs
+++ b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioProjectFactory.cs
@@ -131,7 +131,9 @@ public async Task<VisualStudioProject> CreateAndAddToWorkspaceAsync(
                 }
             });
 
-            _visualStudioWorkspaceImpl.RefreshProjectExistsUIContextForLanguage(language);
+            // Ensure that other VS contexts get accurate information that the UIContext for this language is now active.
+            // This is not cancellable as we have already mutated the solution.
+            await _visualStudioWorkspaceImpl.RefreshProjectExistsUIContextForLanguageAsync(language, CancellationToken.None).ConfigureAwait(false);
 
             return project;
 
diff --git a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
index 438705020b740..22cc3d0e5f318 100644
--- a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
+++ b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
@@ -91,6 +91,9 @@ internal abstract partial class VisualStudioWorkspaceImpl : VisualStudioWorkspac
 
         private readonly Dictionary<string, List<VisualStudioProject>> _projectSystemNameToProjectsMap = new();
 
+        /// <summary>
+        /// Only safe to use on the UI thread.
+        /// </summary>
         private readonly Dictionary<string, UIContext?> _languageToProjectExistsUIContext = new();
 
         /// <summary>
@@ -1671,12 +1674,17 @@ protected internal override void OnProjectRemoved(ProjectId projectId)
 
             // Try to update the UI context info.  But cancel that work if we're shutting down.
             var listenerProvider = Services.GetRequiredService<IWorkspaceAsynchronousOperationListenerProvider>();
-            var asyncToken = listenerProvider.GetListener().BeginAsyncOperation(nameof(RefreshProjectExistsUIContextForLanguage));
+            var asyncToken = listenerProvider.GetListener().BeginAsyncOperation(nameof(RefreshProjectExistsUIContextForLanguageAsync));
             _threadingContext.RunWithShutdownBlockAsync(async cancellationToken =>
             {
-                await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(alwaysYield: true, cancellationToken);
-                RefreshProjectExistsUIContextForLanguage(languageName);
-                asyncToken.Dispose();
+                try
+                {
+                    await RefreshProjectExistsUIContextForLanguageAsync(languageName, cancellationToken).ConfigureAwait(false);
+                }
+                finally
+                {
+                    asyncToken.Dispose();
+                }
             });
         }
 
@@ -2077,24 +2085,28 @@ internal void SetDependencyNodeTargetIdentifier(ProjectId projectId, string targ
                 (projectId, targetIdentifier));
         }
 
-        internal void RefreshProjectExistsUIContextForLanguage(string language)
+        internal async Task RefreshProjectExistsUIContextForLanguageAsync(string language, CancellationToken cancellationToken)
         {
-            // We must assert the call is on the foreground as setting UIContext.IsActive would otherwise do a COM RPC.
+            await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(alwaysYield: true, cancellationToken);
+
             _foregroundObject.AssertIsForeground();
 
-            using (_gate.DisposableWait())
-            {
-                var uiContext =
-                    _languageToProjectExistsUIContext.GetOrAdd(
-                        language,
-                        l => Services.GetLanguageServices(l).GetService<IProjectExistsUIContextProviderLanguageService>()?.GetUIContext());
+            var uiContext = _languageToProjectExistsUIContext.GetOrAdd(
+                language,
+                l => Services.GetLanguageServices(l).GetService<IProjectExistsUIContextProviderLanguageService>()?.GetUIContext());
 
-                // UIContexts can be "zombied" if UIContexts aren't supported because we're in a command line build or in other scenarios.
-                if (uiContext != null && !uiContext.IsZombie)
-                {
-                    uiContext.IsActive = CurrentSolution.Projects.Any(p => p.Language == language);
-                }
-            }
+            // UIContexts can be "zombied" if UIContexts aren't supported because we're in a command line build or in
+            // other scenarios.
+            if (uiContext == null || uiContext.IsZombie)
+                return;
+
+            // Note: it's safe to read CurrentSolution here outside of any sort of lock.  We do all work here on hte UI
+            // thread, so that acts as a natural ordering mechanism here.  If, say, a BG piece of work was mutating this
+            // solution (either adding or removing a project) then that work will also have enqueued the next refresh
+            // operation on the UI thread.  So we'll always eventually reach a fixed point where the task for that
+            // language will check the latest CurrentSolution we have and will set the IsActive bit accordingly.
+            var solution = this.CurrentSolution;
+            uiContext.IsActive = CurrentSolution.Projects.Any(p => p.Language == language);
         }
     }
 }

From 773c594e100fd9264425102ba4c4cdffa03009b7 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Wed, 12 Jan 2022 16:49:36 -0800
Subject: [PATCH 329/444] Simplify

---
 .../Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs  | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
index 22cc3d0e5f318..5a1d781bff343 100644
--- a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
+++ b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
@@ -2105,8 +2105,7 @@ internal async Task RefreshProjectExistsUIContextForLanguageAsync(string languag
             // solution (either adding or removing a project) then that work will also have enqueued the next refresh
             // operation on the UI thread.  So we'll always eventually reach a fixed point where the task for that
             // language will check the latest CurrentSolution we have and will set the IsActive bit accordingly.
-            var solution = this.CurrentSolution;
-            uiContext.IsActive = CurrentSolution.Projects.Any(p => p.Language == language);
+            uiContext.IsActive = this.CurrentSolution.Projects.Any(p => p.Language == language);
         }
     }
 }

From 779a935e7a4148757936fe9cbec1aabf7f4cb616 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Wed, 12 Jan 2022 16:50:39 -0800
Subject: [PATCH 330/444] Simplify

---
 .../Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
index 5a1d781bff343..1e1f0596024ae 100644
--- a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
+++ b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
@@ -2093,7 +2093,7 @@ internal async Task RefreshProjectExistsUIContextForLanguageAsync(string languag
 
             var uiContext = _languageToProjectExistsUIContext.GetOrAdd(
                 language,
-                l => Services.GetLanguageServices(l).GetService<IProjectExistsUIContextProviderLanguageService>()?.GetUIContext());
+                language => Services.GetLanguageServices(language).GetService<IProjectExistsUIContextProviderLanguageService>()?.GetUIContext());
 
             // UIContexts can be "zombied" if UIContexts aren't supported because we're in a command line build or in
             // other scenarios.

From fa5bb8adef7fb1a93eb3f3ee4bf708eb1055545d Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrus.najmabadi@gmail.com>
Date: Wed, 12 Jan 2022 14:56:12 -1000
Subject: [PATCH 331/444] Update
 src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs

Co-authored-by: Jason Malinowski <jason@jason-m.com>
---
 .../Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
index 1e1f0596024ae..1e8762c6cea87 100644
--- a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
+++ b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
@@ -2100,7 +2100,7 @@ internal async Task RefreshProjectExistsUIContextForLanguageAsync(string languag
             if (uiContext == null || uiContext.IsZombie)
                 return;
 
-            // Note: it's safe to read CurrentSolution here outside of any sort of lock.  We do all work here on hte UI
+            // Note: it's safe to read CurrentSolution here outside of any sort of lock.  We do all work here on the UI
             // thread, so that acts as a natural ordering mechanism here.  If, say, a BG piece of work was mutating this
             // solution (either adding or removing a project) then that work will also have enqueued the next refresh
             // operation on the UI thread.  So we'll always eventually reach a fixed point where the task for that

From 21e4eb21217ed954f4c48faaca131ddf82d4737f Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Wed, 12 Jan 2022 16:57:08 -0800
Subject: [PATCH 332/444] Remove unnecessary assert

---
 .../Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs   | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
index 1e1f0596024ae..ce880749a0efc 100644
--- a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
+++ b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs
@@ -2089,8 +2089,6 @@ internal async Task RefreshProjectExistsUIContextForLanguageAsync(string languag
         {
             await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(alwaysYield: true, cancellationToken);
 
-            _foregroundObject.AssertIsForeground();
-
             var uiContext = _languageToProjectExistsUIContext.GetOrAdd(
                 language,
                 language => Services.GetLanguageServices(language).GetService<IProjectExistsUIContextProviderLanguageService>()?.GetUIContext());

From 775af691928d38f20ff5ae19670391a6218aa924 Mon Sep 17 00:00:00 2001
From: Andrew Hall <andrha@microsoft.com>
Date: Wed, 12 Jan 2022 18:50:02 -0800
Subject: [PATCH 333/444] Reduce Stack Trace Explorer automatic open behavior
 scope (#58819)

Fix so that the stack trace explorer only automatically activates on focus if the clipboard has "at" trivia in the frame.

Fixes #58746
---
 .../StackTraceExplorer/IgnoredFrame.cs        |  2 --
 .../StackTraceExplorer/ParsedFrame.cs         |  2 --
 .../StackTraceExplorer/ParsedStackFrame.cs    |  2 --
 .../StackTraceExplorerCommandHandler.cs       |  2 ++
 .../StackTraceExplorerToolWindow.cs           | 32 ++++++++++++++++++-
 .../Compiler/Core/Log/FunctionId.cs           |  2 ++
 6 files changed, 35 insertions(+), 7 deletions(-)

diff --git a/src/Features/Core/Portable/StackTraceExplorer/IgnoredFrame.cs b/src/Features/Core/Portable/StackTraceExplorer/IgnoredFrame.cs
index 2ec8d7ad929cd..246a4443bba9e 100644
--- a/src/Features/Core/Portable/StackTraceExplorer/IgnoredFrame.cs
+++ b/src/Features/Core/Portable/StackTraceExplorer/IgnoredFrame.cs
@@ -13,8 +13,6 @@ public IgnoredFrame(string originalText)
             _originalText = originalText;
         }
 
-        public override bool IsStackFrame => false;
-
         public override string ToString()
         {
             return _originalText;
diff --git a/src/Features/Core/Portable/StackTraceExplorer/ParsedFrame.cs b/src/Features/Core/Portable/StackTraceExplorer/ParsedFrame.cs
index 9d6ee17438a04..9e65a78a3290b 100644
--- a/src/Features/Core/Portable/StackTraceExplorer/ParsedFrame.cs
+++ b/src/Features/Core/Portable/StackTraceExplorer/ParsedFrame.cs
@@ -9,7 +9,5 @@ internal abstract class ParsedFrame
         public ParsedFrame()
         {
         }
-
-        public abstract bool IsStackFrame { get; }
     }
 }
diff --git a/src/Features/Core/Portable/StackTraceExplorer/ParsedStackFrame.cs b/src/Features/Core/Portable/StackTraceExplorer/ParsedStackFrame.cs
index 4d971c5792925..5b464fc65d575 100644
--- a/src/Features/Core/Portable/StackTraceExplorer/ParsedStackFrame.cs
+++ b/src/Features/Core/Portable/StackTraceExplorer/ParsedStackFrame.cs
@@ -32,8 +32,6 @@ public ParsedStackFrame(
 
         public StackFrameCompilationUnit Root => Tree.Root;
 
-        public override bool IsStackFrame => true;
-
         public override string ToString()
         {
             return Tree.Text.CreateString();
diff --git a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerCommandHandler.cs b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerCommandHandler.cs
index 414b2775983b8..b077db9185a0a 100644
--- a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerCommandHandler.cs
+++ b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerCommandHandler.cs
@@ -6,6 +6,7 @@
 using System.ComponentModel.Design;
 using System.IO.Packaging;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.StackTraceExplorer;
 using Microsoft.VisualStudio.LanguageServices.Setup;
@@ -63,6 +64,7 @@ public int OnBroadcastMessage(uint msg, IntPtr wParam, IntPtr lParam)
                     await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync();
                     var windowFrame = (IVsWindowFrame)window.Frame;
                     ErrorHandler.ThrowOnFailure(windowFrame.Show());
+                    Logger.Log(FunctionId.StackTraceToolWindow_ShowOnActivated, logLevel: LogLevel.Information);
                 }
             });
 
diff --git a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerToolWindow.cs b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerToolWindow.cs
index 8edc39cd79434..85c5a6cf01673 100644
--- a/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerToolWindow.cs
+++ b/src/VisualStudio/Core/Def/StackTraceExplorer/StackTraceExplorerToolWindow.cs
@@ -12,6 +12,7 @@
 using System.Windows.Controls;
 using System.Windows.Input;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.EmbeddedLanguages.StackFrame;
 using Microsoft.CodeAnalysis.StackTraceExplorer;
 using Microsoft.VisualStudio.Imaging;
 using Microsoft.VisualStudio.LanguageServices.Setup;
@@ -72,7 +73,7 @@ public async Task<bool> ShouldShowOnActivatedAsync(CancellationToken cancellatio
             }
 
             var result = await StackTraceAnalyzer.AnalyzeAsync(text, cancellationToken).ConfigureAwait(false);
-            if (result.ParsedFrames.Any(static frame => frame.IsStackFrame))
+            if (result.ParsedFrames.Any(static frame => FrameTriggersActivate(frame)))
             {
                 await Root.ViewModel.AddNewTabAsync(result, text, cancellationToken).ConfigureAwait(false);
                 return true;
@@ -81,6 +82,35 @@ public async Task<bool> ShouldShowOnActivatedAsync(CancellationToken cancellatio
             return false;
         }
 
+        private static bool FrameTriggersActivate(ParsedFrame frame)
+        {
+            if (frame is not ParsedStackFrame parsedFrame)
+            {
+                return false;
+            }
+
+            var methodDeclaration = parsedFrame.Root.MethodDeclaration;
+
+            // Find the first token
+            var firstNodeOrToken = methodDeclaration.ChildAt(0);
+            while (firstNodeOrToken.IsNode)
+            {
+                firstNodeOrToken = firstNodeOrToken.Node.ChildAt(0);
+            }
+
+            if (firstNodeOrToken.Token.LeadingTrivia.IsDefault)
+            {
+                return false;
+            }
+
+            // If the stack frame starts with "at" we consider it a well formed stack frame and 
+            // want to automatically open the window. This helps avoids some false positive cases 
+            // where the window shows on code that parses as a stack frame but may not be. The explorer
+            // should still handle those cases if explicitly pasted in, but can lead to false positives 
+            // when automatically opening.
+            return firstNodeOrToken.Token.LeadingTrivia.Any(t => t.Kind == StackFrameKind.AtTrivia);
+        }
+
         public void InitializeIfNeeded(RoslynPackage roslynPackage)
         {
             if (_initialized)
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/FunctionId.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/FunctionId.cs
index 103dd5f50ea7e..20787130a313c 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/FunctionId.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/FunctionId.cs
@@ -537,5 +537,7 @@ internal enum FunctionId
 
         Inline_Hints_DoubleClick = 530,
         NavigateToExternalSources = 531,
+
+        StackTraceToolWindow_ShowOnActivated = 540,
     }
 }

From fa9926dbc9d6b6677f96efc5b47e72037562ae1b Mon Sep 17 00:00:00 2001
From: David Wengier <david.wengier@microsoft.com>
Date: Thu, 13 Jan 2022 13:51:30 +1100
Subject: [PATCH 334/444] Handle synthesized delegates without refKinds
 (#58802)

Co-authored-by: Charles Stoner <10732005+cston@users.noreply.github.com>
---
 .../Symbols/Synthesized/GeneratedNames.cs     | 47 ++++++++++------
 .../EditAndContinue/EditAndContinueTests.cs   | 55 +++++++++++++++++++
 .../Test/Emit/Emit/GeneratedNamesTests.cs     | 55 +++++++++++++++++++
 3 files changed, 140 insertions(+), 17 deletions(-)
 create mode 100644 src/Compilers/CSharp/Test/Emit/Emit/GeneratedNamesTests.cs

diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNames.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNames.cs
index a50b9ccb9b9f6..bb89a163099c0 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNames.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNames.cs
@@ -359,6 +359,9 @@ internal static string MakeDynamicCallSiteFieldName(int uniqueId)
         /// Produces name of the synthesized delegate symbol that encodes the parameter byref-ness and return type of the delegate.
         /// The arity is appended via `N suffix in MetadataName calculation since the delegate is generic.
         /// </summary>
+        /// <remarks>
+        /// Logic here should match <see cref="TryParseSynthesizedDelegateName" />.
+        /// </remarks>
         internal static string MakeSynthesizedDelegateName(RefKindVector byRefs, bool returnsVoid, int generation)
         {
             var pooledBuilder = PooledStringBuilder.GetInstance();
@@ -375,6 +378,12 @@ internal static string MakeSynthesizedDelegateName(RefKindVector byRefs, bool re
             return pooledBuilder.ToStringAndFree();
         }
 
+        /// <summary>
+        /// Parses the name of a synthesized delegate out into the things it represents.
+        /// </summary>
+        /// <remarks>
+        /// Logic here should match <see cref="MakeSynthesizedDelegateName" />.
+        /// </remarks>
         internal static bool TryParseSynthesizedDelegateName(string name, out RefKindVector byRefs, out bool returnsVoid, out int generation, out int parameterCount)
         {
             byRefs = default;
@@ -390,39 +399,43 @@ internal static bool TryParseSynthesizedDelegateName(string name, out RefKindVec
                 return false;
             }
 
-            // The character after the prefix should be an open brace
-            if (name[DelegateNamePrefixLength] != '{')
-            {
-                return false;
-            }
-
             parameterCount = arity - (returnsVoid ? 0 : 1);
 
-            var lastBraceIndex = name.LastIndexOf('}');
-            if (lastBraceIndex < 0)
+            // If there are no ref kinds encoded
+            // (and therefore no braces), use the end of the prefix instead.
+            var nameEndIndex = name.LastIndexOf('}');
+            if (nameEndIndex < 0)
             {
-                return false;
+                nameEndIndex = DelegateNamePrefixLength - 1;
             }
+            else
+            {
+                // There should be a character after the prefix, and it should be an open brace
+                if (name.Length <= DelegateNamePrefixLength || name[DelegateNamePrefixLength] != '{')
+                {
+                    return false;
+                }
 
-            // The ref kind string is between the two braces
-            var refKindString = name[DelegateNamePrefixLengthWithOpenBrace..lastBraceIndex];
+                // If there are braces, then the ref kind string is encoded between them
+                var refKindString = name[DelegateNamePrefixLengthWithOpenBrace..nameEndIndex];
 
-            if (!RefKindVector.TryParse(refKindString, arity, out byRefs))
-            {
-                return false;
+                if (!RefKindVector.TryParse(refKindString, arity, out byRefs))
+                {
+                    return false;
+                }
             }
 
             // If there is a generation index it will be directly after the brace, otherwise the brace
             // is the last character
-            if (lastBraceIndex < name.Length - 1)
+            if (nameEndIndex < name.Length - 1)
             {
                 // Format is a '#' followed by the generation number
-                if (name[lastBraceIndex + 1] != '#')
+                if (name[nameEndIndex + 1] != '#')
                 {
                     return false;
                 }
 
-                if (!int.TryParse(name[(lastBraceIndex + 2)..], out generation))
+                if (!int.TryParse(name[(nameEndIndex + 2)..], out generation))
                 {
                     return false;
                 }
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs
index 9414c65a5e97c..f8bfbce3e268f 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs
@@ -1621,6 +1621,61 @@ static unsafe void F<U>() where U : unmanaged
                 Diagnostic(ErrorCode.ERR_EncUpdateFailedDelegateTypeChanged).WithLocation(1, 1));
         }
 
+        [Fact]
+        public void Lambda_SynthesizedDeletage_06()
+        {
+            var source0 = MarkedSource(
+@"class C
+{
+    void F()
+    {
+        var x = <N:0>(int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8, int p9, int p10, int p11, int p12, int p13, int p14, int p15, int p16, int p17) => 1</N:0>;
+    }
+}");
+            var source1 = MarkedSource(
+@"class C
+{
+    void F()
+    {
+        var x = <N:0>(int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8, int p9, int p10, int p11, int p12, int p13, int p14, int p15, int p16, int p17) => 1</N:0>;
+
+        System.Console.WriteLine(1);
+    }
+}");
+
+            var compilation0 = CreateCompilation(source0.Tree, options: ComSafeDebugDll.WithMetadataImportOptions(MetadataImportOptions.All));
+            var compilation1 = compilation0.WithSource(source1.Tree);
+
+            var v0 = CompileAndVerify(compilation0, verify: Verification.Skipped);
+            var md0 = ModuleMetadata.CreateFromImage(v0.EmittedAssemblyData);
+            var reader0 = md0.MetadataReader;
+
+            var method0 = compilation0.GetMember<MethodSymbol>("C.F");
+            var method1 = compilation1.GetMember<MethodSymbol>("C.F");
+            var generation0 = EmitBaseline.CreateInitialBaseline(md0, v0.CreateSymReader().GetEncMethodDebugInfo);
+
+            CheckNames(reader0, reader0.GetTypeDefNames(), "<Module>", "<>F`18", "C", "<>c");
+            CheckNames(reader0, reader0.GetMethodDefNames(), ".ctor", "Invoke", "F", ".ctor", ".cctor", ".ctor", "<F>b__0_0");
+
+            var diff1 = compilation1.EmitDifference(
+                generation0,
+                ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1), preserveLocalVariables: true)));
+
+            // Verify delta metadata contains expected rows.
+            using var md1 = diff1.GetMetadata();
+            var reader1 = md1.Reader;
+            var readers = new[] { reader0, reader1 };
+
+            EncValidation.VerifyModuleMvid(1, reader0, reader1);
+
+            CheckNames(readers, reader1.GetTypeDefNames());
+            CheckNames(readers, reader1.GetMethodDefNames(), "F", "<F>b__0_0");
+
+            diff1.VerifySynthesizedMembers(
+                "C.<>c: {<>9__0_0, <F>b__0_0}",
+                "C: {<>c}");
+        }
+
         [WorkItem(962219, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/962219")]
         [Fact]
         public void PartialMethod()
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/GeneratedNamesTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/GeneratedNamesTests.cs
new file mode 100644
index 0000000000000..f9f2183894ea9
--- /dev/null
+++ b/src/Compilers/CSharp/Test/Emit/Emit/GeneratedNamesTests.cs
@@ -0,0 +1,55 @@
+// 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.CSharp.Symbols;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.CSharp.UnitTests.Emit
+{
+    public class GeneratedNamesTests
+    {
+        [Theory]
+        [InlineData("<>A", true, 0, 0)]
+        [InlineData("<>A{00010000}`8", true, 0, 8)]
+        [InlineData("<>A{00010000}#2`8", true, 2, 8)]
+        [InlineData("<>A{00010000,00000000}`16", true, 0, 16)]
+        [InlineData("<>A{00010000,00000000}#4`16", true, 4, 16)]
+        [InlineData("<>A`5", true, 0, 5)]
+        [InlineData("<>A`18", true, 0, 18)]
+        [InlineData("<>F`1", false, 0, 0)]
+        [InlineData("<>F`6", false, 0, 5)]
+        [InlineData("<>F`19", false, 0, 18)]
+        [InlineData("<>F#3`19", false, 3, 18)]
+        public void TryParseSynthesizedDelegateName_Success(string name, bool returnsVoid, int generation, int parameterCount)
+        {
+            Assert.True(GeneratedNames.TryParseSynthesizedDelegateName(name, out var actualByRefs, out var actualReturnsVoid, out var actualGeneration, out var actualParameterCount));
+
+            Assert.Equal(returnsVoid, actualReturnsVoid);
+            Assert.Equal(generation, actualGeneration);
+            Assert.Equal(parameterCount, actualParameterCount);
+
+
+            // We need to strip arity in order to validate round-tripping
+            name = MetadataHelpers.InferTypeArityAndUnmangleMetadataName(name, out _);
+            Assert.Equal(name, GeneratedNames.MakeSynthesizedDelegateName(actualByRefs, actualReturnsVoid, actualGeneration));
+        }
+
+        [Theory]
+        [InlineData("<>D")]
+        [InlineData("<>A{")]
+        [InlineData("<>A00}")]
+        [InlineData("<>ABCDEF")]
+        [InlineData("<>A{Z}")]
+        [InlineData("<>A#F")]
+        [InlineData("<>A{}")]
+        [InlineData("<>A{,}")]
+        [InlineData("<>A#")]
+        [InlineData("<>A{0,}")]
+        [InlineData("<>A{,1}")]
+        public void TryParseSynthesizedDelegateName_Failure(string name)
+        {
+            Assert.False(GeneratedNames.TryParseSynthesizedDelegateName(name, out _, out _, out _, out _));
+        }
+    }
+}

From 5fe579daafa077a7b4ac7fbaab50693951584ac0 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Wed, 12 Jan 2022 20:30:50 -0800
Subject: [PATCH 335/444] Fix nrt annotations and impl in syntaxfacts

---
 .../AbstractGoToDefinitionService.cs              |  2 +-
 .../SnippetCompletionProvider.cs                  |  5 +++--
 .../Services/SyntaxFacts/CSharpSyntaxFacts.cs     | 15 ++++-----------
 .../Core/Services/SyntaxFacts/ISyntaxFacts.cs     |  4 ++--
 .../SyntaxFacts/VisualBasicSyntaxFacts.vb         |  9 ++-------
 5 files changed, 12 insertions(+), 23 deletions(-)

diff --git a/src/EditorFeatures/Core/GoToDefinition/AbstractGoToDefinitionService.cs b/src/EditorFeatures/Core/GoToDefinition/AbstractGoToDefinitionService.cs
index aab0063b8d5c7..9e1b403d1edb0 100644
--- a/src/EditorFeatures/Core/GoToDefinition/AbstractGoToDefinitionService.cs
+++ b/src/EditorFeatures/Core/GoToDefinition/AbstractGoToDefinitionService.cs
@@ -137,7 +137,7 @@ private bool TryGoToAlternativeLocationIfAlreadyOnDefinition(
 
         private static bool IsThirdPartyNavigationAllowed(ISymbol symbolToNavigateTo, int caretPosition, Document document, CancellationToken cancellationToken)
         {
-            var syntaxRoot = document.GetSyntaxRootSynchronously(cancellationToken);
+            var syntaxRoot = document.GetRequiredSyntaxRootSynchronously(cancellationToken);
             var syntaxFactsService = document.GetRequiredLanguageService<ISyntaxFactsService>();
             var containingTypeDeclaration = syntaxFactsService.GetContainingTypeDeclaration(syntaxRoot, caretPosition);
 
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/SnippetCompletionProvider.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/SnippetCompletionProvider.cs
index 3ffb2b6c6a304..194784d9bffde 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/SnippetCompletionProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/SnippetCompletionProvider.cs
@@ -81,12 +81,13 @@ private static async Task<ImmutableArray<CompletionItem>> GetSnippetsForDocument
             var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
             var semanticFacts = document.GetRequiredLanguageService<ISemanticFactsService>();
 
-            var leftToken = syntaxTree.GetRoot(cancellationToken).FindTokenOnLeftOfPosition(position, includeDirectives: true);
+            var root = syntaxTree.GetRoot(cancellationToken);
+            var leftToken = root.FindTokenOnLeftOfPosition(position, includeDirectives: true);
             var targetToken = leftToken.GetPreviousTokenIfTouchingWord(position);
 
             if (syntaxFacts.IsInNonUserCode(syntaxTree, position, cancellationToken) ||
                 syntaxTree.IsRightOfDotOrArrowOrColonColon(position, targetToken, cancellationToken) ||
-                syntaxFacts.GetContainingTypeDeclaration(await syntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false), position) is EnumDeclarationSyntax)
+                syntaxFacts.GetContainingTypeDeclaration(root, position) is EnumDeclarationSyntax)
             {
                 return ImmutableArray<CompletionItem>.Empty;
             }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs
index 4a92df38a4c9f..547c092084f75 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs
@@ -591,17 +591,10 @@ public SyntaxNode GetNameOfAttribute(SyntaxNode node)
         public bool IsAttributeNamedArgumentIdentifier([NotNullWhen(true)] SyntaxNode? node)
             => (node as IdentifierNameSyntax).IsAttributeNamedArgumentIdentifier();
 
-        public SyntaxNode? GetContainingTypeDeclaration(SyntaxNode? root, int position)
+        public SyntaxNode? GetContainingTypeDeclaration(SyntaxNode root, int position)
         {
-            if (root == null)
-            {
-                throw new ArgumentNullException(nameof(root));
-            }
-
-            if (position < 0 || position > root.Span.End)
-            {
-                throw new ArgumentOutOfRangeException(nameof(position));
-            }
+            Contract.ThrowIfNull(root, "root");
+            Contract.ThrowIfTrue(position < 0 || position > root.FullSpan.End, "position");
 
             return root
                 .FindToken(position)
@@ -665,7 +658,7 @@ public bool IsElementAccessExpression(SyntaxNode? node)
         public bool IsIndexerMemberCRef(SyntaxNode? node)
             => node.IsKind(SyntaxKind.IndexerMemberCref);
 
-        public SyntaxNode? GetContainingMemberDeclaration(SyntaxNode? root, int position, bool useFullSpan = true)
+        public SyntaxNode? GetContainingMemberDeclaration(SyntaxNode root, int position, bool useFullSpan = true)
         {
             Contract.ThrowIfNull(root, "root");
             Contract.ThrowIfTrue(position < 0 || position > root.FullSpan.End, "position");
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxFacts.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxFacts.cs
index 6183f4dae3816..05a345018bc82 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxFacts.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxFacts.cs
@@ -427,8 +427,8 @@ void GetPartsOfInterpolationExpression(SyntaxNode node,
         string GetDisplayName(SyntaxNode? node, DisplayNameOptions options, string? rootNamespace = null);
 
         // Violation.  This is a feature level API.  How 'position' relates to 'containment' is not defined.
-        SyntaxNode? GetContainingTypeDeclaration(SyntaxNode? root, int position);
-        SyntaxNode? GetContainingMemberDeclaration(SyntaxNode? root, int position, bool useFullSpan = true);
+        SyntaxNode? GetContainingTypeDeclaration(SyntaxNode root, int position);
+        SyntaxNode? GetContainingMemberDeclaration(SyntaxNode root, int position, bool useFullSpan = true);
         SyntaxNode? GetContainingVariableDeclaratorOfFieldDeclaration(SyntaxNode? node);
 
         [return: NotNullIfNotNull("node")]
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxFacts.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxFacts.vb
index 95e8641486765..cc12a7e47b84c 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxFacts.vb
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxFacts.vb
@@ -630,13 +630,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.LanguageServices
         End Function
 
         Public Function GetContainingTypeDeclaration(root As SyntaxNode, position As Integer) As SyntaxNode Implements ISyntaxFacts.GetContainingTypeDeclaration
-            If root Is Nothing Then
-                Throw New ArgumentNullException(NameOf(root))
-            End If
-
-            If position < 0 OrElse position > root.Span.End Then
-                Throw New ArgumentOutOfRangeException(NameOf(position))
-            End If
+            Contract.ThrowIfNull(root, NameOf(root))
+            Contract.ThrowIfTrue(position < 0 OrElse position > root.FullSpan.End, NameOf(position))
 
             Return root.
                 FindToken(position).

From 18721c7dcea6f7f5ff3d37e682b067ad8ef1bfb0 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Wed, 12 Jan 2022 20:45:41 -0800
Subject: [PATCH 336/444] Capture information to help track down a crash seen
 in the wild.

---
 ...tInitializeParameterCodeRefactoringProvider.cs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/src/Features/Core/Portable/InitializeParameter/AbstractInitializeParameterCodeRefactoringProvider.cs b/src/Features/Core/Portable/InitializeParameter/AbstractInitializeParameterCodeRefactoringProvider.cs
index 9046a16c44144..e5bb8311f9134 100644
--- a/src/Features/Core/Portable/InitializeParameter/AbstractInitializeParameterCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/InitializeParameter/AbstractInitializeParameterCodeRefactoringProvider.cs
@@ -11,6 +11,7 @@
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeRefactorings;
 using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.Operations;
 using Microsoft.CodeAnalysis.PooledObjects;
@@ -82,6 +83,20 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
                 return;
             }
 
+            // https://github.com/dotnet/roslyn/issues/58811
+            // We had a parameter that we couldn't round trip using its span.
+            var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var foundNode = root.FindNode(selectedParameter.Span);
+            if (foundNode is not TParameterSyntax)
+            {
+                var message = $@"Could not roundtrip parameter '{selectedParameter}'@{selectedParameter.Span}
+Found: '{foundNode}'@{foundNode?.Span}
+In:
+{selectedParameter?.Parent?.Parent}";
+                FatalError.ReportWithDumpAndCatch(new InvalidOperationException(message), ErrorSeverity.Critical);
+                return;
+            }
+
             var generator = SyntaxGenerator.GetGenerator(document);
             var parameterNodes = generator.GetParameters(functionDeclaration);
             var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);

From 6e10cd5ef02878f8c0502783304a3cd6aa450d29 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Wed, 12 Jan 2022 22:07:03 -0800
Subject: [PATCH 337/444] Remove contract calls

---
 .../CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs        | 6 ------
 .../Services/SyntaxFacts/VisualBasicSyntaxFacts.vb          | 6 ------
 2 files changed, 12 deletions(-)

diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs
index 547c092084f75..c84b60696c5cd 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs
@@ -593,9 +593,6 @@ public bool IsAttributeNamedArgumentIdentifier([NotNullWhen(true)] SyntaxNode? n
 
         public SyntaxNode? GetContainingTypeDeclaration(SyntaxNode root, int position)
         {
-            Contract.ThrowIfNull(root, "root");
-            Contract.ThrowIfTrue(position < 0 || position > root.FullSpan.End, "position");
-
             return root
                 .FindToken(position)
                 .GetAncestors<SyntaxNode>()
@@ -660,9 +657,6 @@ public bool IsIndexerMemberCRef(SyntaxNode? node)
 
         public SyntaxNode? GetContainingMemberDeclaration(SyntaxNode root, int position, bool useFullSpan = true)
         {
-            Contract.ThrowIfNull(root, "root");
-            Contract.ThrowIfTrue(position < 0 || position > root.FullSpan.End, "position");
-
             var end = root.FullSpan.End;
             if (end == 0)
             {
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxFacts.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxFacts.vb
index cc12a7e47b84c..f08235c4a4a44 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxFacts.vb
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxFacts.vb
@@ -630,9 +630,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.LanguageServices
         End Function
 
         Public Function GetContainingTypeDeclaration(root As SyntaxNode, position As Integer) As SyntaxNode Implements ISyntaxFacts.GetContainingTypeDeclaration
-            Contract.ThrowIfNull(root, NameOf(root))
-            Contract.ThrowIfTrue(position < 0 OrElse position > root.FullSpan.End, NameOf(position))
-
             Return root.
                 FindToken(position).
                 GetAncestors(Of SyntaxNode)().
@@ -697,9 +694,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.LanguageServices
         End Function
 
         Public Function GetContainingMemberDeclaration(root As SyntaxNode, position As Integer, Optional useFullSpan As Boolean = True) As SyntaxNode Implements ISyntaxFacts.GetContainingMemberDeclaration
-            Contract.ThrowIfNull(root, NameOf(root))
-            Contract.ThrowIfTrue(position < 0 OrElse position > root.FullSpan.End, NameOf(position))
-
             Dim [end] = root.FullSpan.End
             If [end] = 0 Then
                 ' empty file

From f7bea7fd7aee0465332e643de53353a9fedb9734 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Wed, 12 Jan 2022 22:57:57 -0800
Subject: [PATCH 338/444] Avoid setting MICROSOFT_DIASYMREADER_NATIVE_ env
 variables in tests (#58808)

---
 src/Compilers/Test/Core/ModuleInitializer.cs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/Compilers/Test/Core/ModuleInitializer.cs b/src/Compilers/Test/Core/ModuleInitializer.cs
index 6e592c35225c8..2b1bcb4d22081 100644
--- a/src/Compilers/Test/Core/ModuleInitializer.cs
+++ b/src/Compilers/Test/Core/ModuleInitializer.cs
@@ -17,10 +17,6 @@ internal static void Initialize()
         {
             Trace.Listeners.Clear();
             Trace.Listeners.Add(new ThrowingTraceListener());
-
-            // Make sure we load DSRN from the directory containing the unit tests and not from a runtime directory on .NET 5+.
-            Environment.SetEnvironmentVariable("MICROSOFT_DIASYMREADER_NATIVE_ALT_LOAD_PATH", Path.GetDirectoryName(typeof(ModuleInitializer).Assembly.Location));
-            Environment.SetEnvironmentVariable("MICROSOFT_DIASYMREADER_NATIVE_USE_ALT_LOAD_PATH_ONLY", "1");
         }
     }
 }

From 456baf2b10c04543add06adec49d452f75d4e8d9 Mon Sep 17 00:00:00 2001
From: "dotnet-maestro[bot]"
 <42748379+dotnet-maestro[bot]@users.noreply.github.com>
Date: Thu, 13 Jan 2022 15:01:24 +0000
Subject: [PATCH 339/444] [main] Update dependencies from dotnet/arcade
 (#58635)

[main] Update dependencies from dotnet/arcade
---
 eng/Version.Details.xml                       |   8 +-
 eng/common/generate-graph-files.ps1           |  86 ---
 eng/common/sdl/configure-sdl-tool.ps1         |   9 +-
 eng/common/sdl/execute-all-sdl-tools.ps1      |   4 +-
 .../templates/job/generate-graph-files.yml    |  48 --
 eng/common/templates/jobs/codeql-build.yml    |  31 +
 eng/common/templates/jobs/jobs.yml            |  10 -
 .../channels/generic-internal-channel.yml     | 190 ------
 .../channels/generic-public-channel.yml       | 192 -------
 .../templates/post-build/post-build.yml       | 539 ++++--------------
 eng/common/templates/steps/execute-codeql.yml |  32 ++
 global.json                                   |   4 +-
 12 files changed, 189 insertions(+), 964 deletions(-)
 delete mode 100644 eng/common/generate-graph-files.ps1
 delete mode 100644 eng/common/templates/job/generate-graph-files.yml
 create mode 100644 eng/common/templates/jobs/codeql-build.yml
 delete mode 100644 eng/common/templates/post-build/channels/generic-internal-channel.yml
 delete mode 100644 eng/common/templates/post-build/channels/generic-public-channel.yml
 create mode 100644 eng/common/templates/steps/execute-codeql.yml

diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index ebb6fdb7f29e5..ce5700e572d70 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -13,18 +13,18 @@
     </Dependency>
   </ProductDependencies>
   <ToolsetDependencies>
-    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="7.0.0-beta.22053.2">
+    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="7.0.0-beta.22063.1">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>a0f6d2432ce3d1bb30ee747bb534f477c75fd667</Sha>
+      <Sha>7a7ba506eed201288d4182fce8b380b22bdd73cb</Sha>
       <SourceBuild RepoName="arcade" ManagedOnly="true" />
     </Dependency>
     <Dependency Name="Microsoft.Net.Compilers.Toolset" Version="4.1.0-2.21609.7">
       <Uri>https://github.com/dotnet/roslyn</Uri>
       <Sha>818313426323d979747781a17c78860c833776da</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="7.0.0-beta.22053.2">
+    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="7.0.0-beta.22063.1">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>a0f6d2432ce3d1bb30ee747bb534f477c75fd667</Sha>
+      <Sha>7a7ba506eed201288d4182fce8b380b22bdd73cb</Sha>
     </Dependency>
   </ToolsetDependencies>
 </Dependencies>
diff --git a/eng/common/generate-graph-files.ps1 b/eng/common/generate-graph-files.ps1
deleted file mode 100644
index 0728b1a8b570d..0000000000000
--- a/eng/common/generate-graph-files.ps1
+++ /dev/null
@@ -1,86 +0,0 @@
-Param(
-  [Parameter(Mandatory=$true)][string] $barToken,       # Token generated at https://maestro-prod.westus2.cloudapp.azure.com/Account/Tokens
-  [Parameter(Mandatory=$true)][string] $gitHubPat,      # GitHub personal access token from https://github.com/settings/tokens (no auth scopes needed)
-  [Parameter(Mandatory=$true)][string] $azdoPat,        # Azure Dev Ops tokens from https://dev.azure.com/dnceng/_details/security/tokens (code read scope needed)
-  [Parameter(Mandatory=$true)][string] $outputFolder,   # Where the graphviz.txt file will be created
-  [string] $darcVersion,                                # darc's version
-  [string] $graphvizVersion = '2.38',                   # GraphViz version
-  [switch] $includeToolset                              # Whether the graph should include toolset dependencies or not. i.e. arcade, optimization. For more about
-                                                        # toolset dependencies see https://github.com/dotnet/arcade/blob/master/Documentation/Darc.md#toolset-vs-product-dependencies
-)
-
-function CheckExitCode ([string]$stage)
-{
-  $exitCode = $LASTEXITCODE
-  if ($exitCode  -ne 0) {
-    Write-PipelineTelemetryError -Category 'Arcade' -Message "Something failed in stage: '$stage'. Check for errors above. Exiting now..."
-    ExitWithExitCode $exitCode
-  }
-}
-
-try {
-  $ErrorActionPreference = 'Stop'
-  . $PSScriptRoot\tools.ps1
-  
-  Import-Module -Name (Join-Path $PSScriptRoot 'native\CommonLibrary.psm1')
-
-  Push-Location $PSScriptRoot
-
-  Write-Host 'Installing darc...'
-  . .\darc-init.ps1 -darcVersion $darcVersion
-  CheckExitCode 'Running darc-init'
-
-  $engCommonBaseDir = Join-Path $PSScriptRoot 'native\'
-  $graphvizInstallDir = CommonLibrary\Get-NativeInstallDirectory
-  $nativeToolBaseUri = 'https://netcorenativeassets.blob.core.windows.net/resource-packages/external'
-  $installBin = Join-Path $graphvizInstallDir 'bin'
-
-  Write-Host 'Installing dot...'
-  .\native\install-tool.ps1 -ToolName graphviz -InstallPath $installBin -BaseUri $nativeToolBaseUri -CommonLibraryDirectory $engCommonBaseDir -Version $graphvizVersion -Verbose
-
-  $darcExe = "$env:USERPROFILE\.dotnet\tools"
-  $darcExe = Resolve-Path "$darcExe\darc.exe"
-
-  Create-Directory $outputFolder
-
-  # Generate 3 graph descriptions:
-  # 1. Flat with coherency information
-  # 2. Graphviz (dot) file
-  # 3. Standard dependency graph
-  $graphVizFilePath = "$outputFolder\graphviz.txt"
-  $graphVizImageFilePath = "$outputFolder\graph.png"
-  $normalGraphFilePath = "$outputFolder\graph-full.txt"
-  $flatGraphFilePath = "$outputFolder\graph-flat.txt"
-  $baseOptions = @( '--github-pat', "$gitHubPat", '--azdev-pat', "$azdoPat", '--password', "$barToken" )
-
-  if ($includeToolset) {
-    Write-Host 'Toolsets will be included in the graph...'
-    $baseOptions += @( '--include-toolset' )
-  }
-
-  Write-Host 'Generating standard dependency graph...'
-  & "$darcExe" get-dependency-graph @baseOptions --output-file $normalGraphFilePath
-  CheckExitCode 'Generating normal dependency graph'
-
-  Write-Host 'Generating flat dependency graph and graphviz file...'
-  & "$darcExe" get-dependency-graph @baseOptions --flat --coherency --graphviz $graphVizFilePath --output-file $flatGraphFilePath
-  CheckExitCode 'Generating flat and graphviz dependency graph'
-
-  Write-Host "Generating graph image $graphVizFilePath"
-  $dotFilePath = Join-Path $installBin "graphviz\$graphvizVersion\release\bin\dot.exe"
-  & "$dotFilePath" -Tpng -o"$graphVizImageFilePath" "$graphVizFilePath"
-  CheckExitCode 'Generating graphviz image'
-
-  Write-Host "'$graphVizFilePath', '$flatGraphFilePath', '$normalGraphFilePath' and '$graphVizImageFilePath' created!"
-}
-catch {
-  if (!$includeToolset) {
-    Write-Host 'This might be a toolset repo which includes only toolset dependencies. ' -NoNewline -ForegroundColor Yellow
-    Write-Host 'Since -includeToolset is not set there is no graph to create. Include -includeToolset and try again...' -ForegroundColor Yellow
-  }
-  Write-Host $_.ScriptStackTrace
-  Write-PipelineTelemetryError -Category 'Arcade' -Message $_
-  ExitWithExitCode 1
-} finally {
-  Pop-Location
-}
\ No newline at end of file
diff --git a/eng/common/sdl/configure-sdl-tool.ps1 b/eng/common/sdl/configure-sdl-tool.ps1
index 8a68fc24b11b0..bdbf49e6c71de 100644
--- a/eng/common/sdl/configure-sdl-tool.ps1
+++ b/eng/common/sdl/configure-sdl-tool.ps1
@@ -15,7 +15,9 @@ Param(
   # Optional: Additional params to add to any tool using CredScan.
   [string[]] $CrScanAdditionalRunConfigParams,
   # Optional: Additional params to add to any tool using PoliCheck.
-  [string[]] $PoliCheckAdditionalRunConfigParams
+  [string[]] $PoliCheckAdditionalRunConfigParams,
+  # Optional: Additional params to add to any tool using CodeQL/Semmle.
+  [string[]] $CodeQLAdditionalRunConfigParams
 )
 
 $ErrorActionPreference = 'Stop'
@@ -78,6 +80,11 @@ try {
         $tool.Args += "`"Target < $TargetDirectory`""
       }
       $tool.Args += $PoliCheckAdditionalRunConfigParams
+    } elseif ($tool.Name -eq 'semmle' -or $tool.Name -eq 'codeql') {
+      if ($targetDirectory) {
+        $tool.Args += "`"SourceCodeDirectory < $TargetDirectory`""
+      }
+      $tool.Args += $CodeQLAdditionalRunConfigParams
     }
 
     # Create variable pointing to the args array directly so we can use splat syntax later.
diff --git a/eng/common/sdl/execute-all-sdl-tools.ps1 b/eng/common/sdl/execute-all-sdl-tools.ps1
index e5bef8ebd3a3b..4797e012c7d2f 100644
--- a/eng/common/sdl/execute-all-sdl-tools.ps1
+++ b/eng/common/sdl/execute-all-sdl-tools.ps1
@@ -34,6 +34,7 @@ Param(
   [string] $GuardianLoggerLevel='Standard',                                                      # Optional: the logger level for the Guardian CLI; options are Trace, Verbose, Standard, Warning, and Error
   [string[]] $CrScanAdditionalRunConfigParams,                                                   # Optional: Additional Params to custom build a CredScan run config in the format @("xyz:abc","sdf:1")
   [string[]] $PoliCheckAdditionalRunConfigParams,                                                # Optional: Additional Params to custom build a Policheck run config in the format @("xyz:abc","sdf:1")
+  [string[]] $CodeQLAdditionalRunConfigParams,                                                   # Optional: Additional Params to custom build a Semmle/CodeQL run config in the format @("xyz < abc","sdf < 1")
   [bool] $BreakOnFailure=$False                                                                  # Optional: Fail the build if there were errors during the run
 )
 
@@ -105,7 +106,8 @@ try {
           -AzureDevOpsAccessToken $AzureDevOpsAccessToken `
           -GuardianLoggerLevel $GuardianLoggerLevel `
           -CrScanAdditionalRunConfigParams $CrScanAdditionalRunConfigParams `
-          -PoliCheckAdditionalRunConfigParams $PoliCheckAdditionalRunConfigParams
+          -PoliCheckAdditionalRunConfigParams $PoliCheckAdditionalRunConfigParams `
+          -CodeQLAdditionalRunConfigParams $CodeQLAdditionalRunConfigParams
         if ($BreakOnFailure) {
           Exit-IfNZEC "Sdl"
         }
diff --git a/eng/common/templates/job/generate-graph-files.yml b/eng/common/templates/job/generate-graph-files.yml
deleted file mode 100644
index e54ce956f9088..0000000000000
--- a/eng/common/templates/job/generate-graph-files.yml
+++ /dev/null
@@ -1,48 +0,0 @@
-parameters:
-  # Optional: dependencies of the job
-  dependsOn: ''
-
-  # Optional: A defined YAML pool - https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=vsts&tabs=schema#pool
-  pool: {}
-
-  # Optional: Include toolset dependencies in the generated graph files
-  includeToolset: false
-  
-jobs:
-- job: Generate_Graph_Files
-
-  dependsOn: ${{ parameters.dependsOn }}
-
-  displayName: Generate Graph Files
-
-  pool: ${{ parameters.pool }}
-
-  variables:
-    # Publish-Build-Assets provides: MaestroAccessToken, BotAccount-dotnet-maestro-bot-PAT
-    # DotNet-AllOrgs-Darc-Pats provides: dn-bot-devdiv-dnceng-rw-code-pat
-    - group: Publish-Build-Assets
-    - group: DotNet-AllOrgs-Darc-Pats
-    - name: _GraphArguments
-      value: -gitHubPat $(BotAccount-dotnet-maestro-bot-PAT) 
-        -azdoPat $(dn-bot-devdiv-dnceng-rw-code-pat) 
-        -barToken $(MaestroAccessToken) 
-        -outputFolder '$(Build.StagingDirectory)/GraphFiles/'
-    - ${{ if ne(parameters.includeToolset, 'false') }}:
-      - name: _GraphArguments
-        value: ${{ variables._GraphArguments }} -includeToolset
-
-  steps:
-    - task: PowerShell@2
-      displayName: Generate Graph Files
-      inputs:
-        filePath: eng\common\generate-graph-files.ps1 
-        arguments: $(_GraphArguments)
-      continueOnError: true
-    - task: PublishBuildArtifacts@1
-      displayName: Publish Graph to Artifacts
-      inputs:
-        PathtoPublish: '$(Build.StagingDirectory)/GraphFiles'
-        PublishLocation: Container
-        ArtifactName: GraphFiles
-      continueOnError: true
-      condition: always()      
diff --git a/eng/common/templates/jobs/codeql-build.yml b/eng/common/templates/jobs/codeql-build.yml
new file mode 100644
index 0000000000000..f7dc5ea4aaa63
--- /dev/null
+++ b/eng/common/templates/jobs/codeql-build.yml
@@ -0,0 +1,31 @@
+parameters:
+  # See schema documentation in /Documentation/AzureDevOps/TemplateSchema.md
+  continueOnError: false
+  # Required: A collection of jobs to run - https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=vsts&tabs=schema#job
+  jobs: []
+  # Optional: if specified, restore and use this version of Guardian instead of the default.
+  overrideGuardianVersion: ''
+
+jobs:
+- template: /eng/common/templates/jobs/jobs.yml
+  parameters:
+    enableMicrobuild: false
+    enablePublishBuildArtifacts: false
+    enablePublishTestResults: false
+    enablePublishBuildAssets: false
+    enablePublishUsingPipelines: false
+    enableTelemetry: true
+
+    variables:
+      - group: Publish-Build-Assets
+      # The Guardian version specified in 'eng/common/sdl/packages.config'. This value must be kept in
+      # sync with the packages.config file.
+      - name: DefaultGuardianVersion
+        value: 0.109.0
+      - name: GuardianPackagesConfigFile
+        value: $(Build.SourcesDirectory)\eng\common\sdl\packages.config
+      - name: GuardianVersion
+        value: ${{ coalesce(parameters.overrideGuardianVersion, '$(DefaultGuardianVersion)') }}
+  
+    jobs: ${{ parameters.jobs }}
+        
diff --git a/eng/common/templates/jobs/jobs.yml b/eng/common/templates/jobs/jobs.yml
index 8dd1fdbd144a0..ff4ab75c886dc 100644
--- a/eng/common/templates/jobs/jobs.yml
+++ b/eng/common/templates/jobs/jobs.yml
@@ -87,13 +87,3 @@ jobs:
         runAsPublic: ${{ parameters.runAsPublic }}
         publishUsingPipelines: ${{ parameters.enablePublishUsingPipelines }}
         enablePublishBuildArtifacts: ${{ parameters.enablePublishBuildArtifacts }}
-
-  - ${{ if eq(parameters.graphFileGeneration.enabled, true) }}:
-    - template: ../job/generate-graph-files.yml
-      parameters:
-        continueOnError: ${{ parameters.continueOnError }}
-        includeToolset: ${{ parameters.graphFileGeneration.includeToolset }}
-        dependsOn:
-          - Asset_Registry_Publish
-        pool:
-          vmImage: 'windows-2019'
diff --git a/eng/common/templates/post-build/channels/generic-internal-channel.yml b/eng/common/templates/post-build/channels/generic-internal-channel.yml
deleted file mode 100644
index 8990dfc8c87cc..0000000000000
--- a/eng/common/templates/post-build/channels/generic-internal-channel.yml
+++ /dev/null
@@ -1,190 +0,0 @@
-parameters:
-  BARBuildId: ''
-  PromoteToChannelIds: ''
-  artifactsPublishingAdditionalParameters: ''
-  dependsOn:
-  - Validate
-  publishInstallersAndChecksums: true
-  symbolPublishingAdditionalParameters: ''
-  stageName: ''
-  channelName: ''
-  channelId: ''
-  transportFeed: ''
-  shippingFeed: ''
-  symbolsFeed: ''
-
-stages:
-- stage: ${{ parameters.stageName }}
-  dependsOn: ${{ parameters.dependsOn }}
-  variables:
-    - template: ../common-variables.yml
-  displayName: ${{ parameters.channelName }} Publishing
-  jobs:
-  - template: ../setup-maestro-vars.yml
-    parameters:
-      BARBuildId: ${{ parameters.BARBuildId }}
-      PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}
-
-  - job: publish_symbols
-    displayName: Symbol Publishing
-    dependsOn: setupMaestroVars
-    condition: contains(dependencies.setupMaestroVars.outputs['setReleaseVars.TargetChannels'], format('[{0}]', ${{ parameters.channelId }} ))
-    variables:
-      - group: DotNet-Symbol-Server-Pats
-      - name: AzDOProjectName
-        value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOProjectName'] ]
-      - name: AzDOPipelineId
-        value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOPipelineId'] ]
-      - name: AzDOBuildId
-        value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOBuildId'] ]
-    pool:
-      vmImage: 'windows-2019'
-    steps:
-      - script: echo "##vso[task.logissue type=warning]Going forward, v2 Arcade publishing is no longer supported. Please read https://github.com/dotnet/arcade/blob/main/Documentation/CorePackages/Publishing.md for details, then contact dnceng if you have further questions."
-        displayName: Warn about v2 Arcade Publishing Usage
-
-      # This is necessary whenever we want to publish/restore to an AzDO private feed
-      - task: NuGetAuthenticate@0
-        displayName: 'Authenticate to AzDO Feeds'
-
-      - task: DownloadBuildArtifacts@0
-        displayName: Download Build Assets
-        continueOnError: true
-        inputs:
-          buildType: specific
-          buildVersionToDownload: specific
-          project: $(AzDOProjectName)
-          pipeline: $(AzDOPipelineId)
-          buildId: $(AzDOBuildId)
-          downloadType: 'specific'
-          itemPattern: |
-            PdbArtifacts/**
-            BlobArtifacts/**
-          downloadPath: '$(Build.ArtifactStagingDirectory)'
-          checkDownloadedFiles: true
-
-      # This is necessary whenever we want to publish/restore to an AzDO private feed
-      # Since sdk-task.ps1 tries to restore packages we need to do this authentication here
-      # otherwise it'll complain about accessing a private feed.
-      - task: NuGetAuthenticate@0
-        displayName: 'Authenticate to AzDO Feeds'
-
-      - task: PowerShell@2
-        displayName: Enable cross-org publishing
-        inputs:
-          filePath: eng\common\enable-cross-org-publishing.ps1
-          arguments: -token $(dn-bot-dnceng-artifact-feeds-rw)
-
-      - task: PowerShell@2
-        displayName: Publish
-        inputs:
-          filePath: eng\common\sdk-task.ps1
-          arguments: -task PublishToSymbolServers -restore -msbuildEngine dotnet
-            /p:DotNetSymbolServerTokenMsdl=$(microsoft-symbol-server-pat)
-            /p:DotNetSymbolServerTokenSymWeb=$(symweb-symbol-server-pat)
-            /p:PDBArtifactsDirectory='$(Build.ArtifactStagingDirectory)/PDBArtifacts/'
-            /p:BlobBasePath='$(Build.ArtifactStagingDirectory)/BlobArtifacts/'
-            /p:SymbolPublishingExclusionsFile='$(Build.SourcesDirectory)/eng/SymbolPublishingExclusionsFile.txt'
-            /p:Configuration=Release
-            /p:PublishToMSDL=false
-            ${{ parameters.symbolPublishingAdditionalParameters }}
-
-      - template: ../../steps/publish-logs.yml
-        parameters:
-          StageLabel: '${{ parameters.stageName }}'
-          JobLabel: 'SymbolPublishing'
-
-  - job: publish_assets
-    displayName: Publish Assets
-    dependsOn: setupMaestroVars
-    timeoutInMinutes: 120
-    variables:
-      - name: BARBuildId
-        value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.BARBuildId'] ]
-      - name: IsStableBuild
-        value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.IsStableBuild'] ]
-      - name: AzDOProjectName
-        value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOProjectName'] ]
-      - name: AzDOPipelineId
-        value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOPipelineId'] ]
-      - name: AzDOBuildId
-        value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOBuildId'] ]
-    condition: contains(dependencies.setupMaestroVars.outputs['setReleaseVars.TargetChannels'], format('[{0}]', ${{ parameters.channelId }} ))
-    pool:
-      vmImage: 'windows-2019'
-    steps:
-      - script: echo "##vso[task.logissue type=warning]Going forward, v2 Arcade publishing is no longer supported. Please read https://github.com/dotnet/arcade/blob/main/Documentation/CorePackages/Publishing.md for details, then contact dnceng if you have further questions."
-        displayName: Warn about v2 Arcade Publishing Usage
-
-      - task: DownloadBuildArtifacts@0
-        displayName: Download Build Assets
-        continueOnError: true
-        inputs:
-          buildType: specific
-          buildVersionToDownload: specific
-          project: $(AzDOProjectName)
-          pipeline: $(AzDOPipelineId)
-          buildId: $(AzDOBuildId)
-          downloadType: 'specific'
-          itemPattern: |
-            PackageArtifacts/**
-            BlobArtifacts/**
-            AssetManifests/**
-          downloadPath: '$(Build.ArtifactStagingDirectory)'
-          checkDownloadedFiles: true
-
-      - task: NuGetToolInstaller@1
-        displayName: 'Install NuGet.exe'
-
-      # This is necessary whenever we want to publish/restore to an AzDO private feed
-      - task: NuGetAuthenticate@0
-        displayName: 'Authenticate to AzDO Feeds'
-
-      - task: PowerShell@2
-        displayName: Enable cross-org publishing
-        inputs:
-          filePath: eng\common\enable-cross-org-publishing.ps1
-          arguments: -token $(dn-bot-dnceng-artifact-feeds-rw)
-
-      - task: PowerShell@2
-        displayName: Publish Assets
-        inputs:
-          filePath: eng\common\sdk-task.ps1
-          arguments: -task PublishArtifactsInManifest -restore -msbuildEngine dotnet
-            /p:PublishingInfraVersion=2
-            /p:IsStableBuild=$(IsStableBuild)
-            /p:IsInternalBuild=$(IsInternalBuild)
-            /p:RepositoryName=$(Build.Repository.Name)
-            /p:CommitSha=$(Build.SourceVersion)
-            /p:NugetPath=$(NuGetExeToolPath)
-            /p:AzdoTargetFeedPAT='$(dn-bot-dnceng-universal-packages-rw)'
-            /p:AzureStorageTargetFeedPAT='$(dotnetfeed-storage-access-key-1)'
-            /p:BARBuildId=$(BARBuildId)
-            /p:MaestroApiEndpoint='$(MaestroApiEndPoint)'
-            /p:BuildAssetRegistryToken='$(MaestroApiAccessToken)'
-            /p:ManifestsBasePath='$(Build.ArtifactStagingDirectory)/AssetManifests/'
-            /p:BlobBasePath='$(Build.ArtifactStagingDirectory)/BlobArtifacts/'
-            /p:PackageBasePath='$(Build.ArtifactStagingDirectory)/PackageArtifacts/'
-            /p:Configuration=Release
-            /p:PublishInstallersAndChecksums=${{ parameters.publishInstallersAndChecksums }}
-            /p:ChecksumsTargetStaticFeed=$(InternalChecksumsBlobFeedUrl)
-            /p:ChecksumsAzureAccountKey=$(InternalChecksumsBlobFeedKey)
-            /p:InstallersTargetStaticFeed=$(InternalInstallersBlobFeedUrl)
-            /p:InstallersAzureAccountKey=$(InternalInstallersBlobFeedKey)
-            /p:AzureDevOpsStaticShippingFeed='${{ parameters.shippingFeed }}'
-            /p:AzureDevOpsStaticShippingFeedKey='$(dn-bot-dnceng-artifact-feeds-rw)'
-            /p:AzureDevOpsStaticTransportFeed='${{ parameters.transportFeed }}'
-            /p:AzureDevOpsStaticTransportFeedKey='$(dn-bot-dnceng-artifact-feeds-rw)'
-            /p:AzureDevOpsStaticSymbolsFeed='${{ parameters.symbolsFeed }}'
-            /p:AzureDevOpsStaticSymbolsFeedKey='$(dn-bot-dnceng-artifact-feeds-rw)'
-            /p:PublishToMSDL=false
-            ${{ parameters.artifactsPublishingAdditionalParameters }}
-
-      - template: ../../steps/publish-logs.yml
-        parameters:
-          StageLabel: '${{ parameters.stageName }}'
-          JobLabel: 'AssetsPublishing'
-
-      - template: ../../steps/add-build-to-channel.yml
-        parameters:
-          ChannelId: ${{ parameters.channelId }}
diff --git a/eng/common/templates/post-build/channels/generic-public-channel.yml b/eng/common/templates/post-build/channels/generic-public-channel.yml
deleted file mode 100644
index 3220c6a4f92ff..0000000000000
--- a/eng/common/templates/post-build/channels/generic-public-channel.yml
+++ /dev/null
@@ -1,192 +0,0 @@
-parameters:
-  BARBuildId: ''
-  PromoteToChannelIds: ''
-  artifactsPublishingAdditionalParameters: ''
-  dependsOn:
-  - Validate
-  publishInstallersAndChecksums: true
-  symbolPublishingAdditionalParameters: ''
-  stageName: ''
-  channelName: ''
-  channelId: ''
-  transportFeed: ''
-  shippingFeed: ''
-  symbolsFeed: ''
-  # If the channel name is empty, no links will be generated
-  akaMSChannelName: ''
-
-stages:
-- stage: ${{ parameters.stageName }}
-  dependsOn: ${{ parameters.dependsOn }}
-  variables:
-    - template: ../common-variables.yml
-  displayName: ${{ parameters.channelName }} Publishing
-  jobs:
-  - template: ../setup-maestro-vars.yml
-    parameters:
-      BARBuildId: ${{ parameters.BARBuildId }}
-      PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}
-
-  - job: publish_symbols
-    displayName: Symbol Publishing
-    dependsOn: setupMaestroVars
-    condition: contains(dependencies.setupMaestroVars.outputs['setReleaseVars.TargetChannels'], format('[{0}]', ${{ parameters.channelId }} ))
-    variables:
-      - group: DotNet-Symbol-Server-Pats
-      - name: AzDOProjectName
-        value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOProjectName'] ]
-      - name: AzDOPipelineId
-        value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOPipelineId'] ]
-      - name: AzDOBuildId
-        value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOBuildId'] ]
-    pool:
-      vmImage: 'windows-2019'
-    steps:
-      - script: echo "##vso[task.logissue type=warning]Going forward, v2 Arcade publishing is no longer supported. Please read https://github.com/dotnet/arcade/blob/main/Documentation/CorePackages/Publishing.md for details, then contact dnceng if you have further questions."
-        displayName: Warn about v2 Arcade Publishing Usage
-
-      - task: DownloadBuildArtifacts@0
-        displayName: Download Build Assets
-        continueOnError: true
-        inputs:
-          buildType: specific
-          buildVersionToDownload: specific
-          project: $(AzDOProjectName)
-          pipeline: $(AzDOPipelineId)
-          buildId: $(AzDOBuildId)
-          downloadType: 'specific'
-          itemPattern: |
-            PdbArtifacts/**
-            BlobArtifacts/**
-          downloadPath: '$(Build.ArtifactStagingDirectory)'
-          checkDownloadedFiles: true
-
-      # This is necessary whenever we want to publish/restore to an AzDO private feed
-      # Since sdk-task.ps1 tries to restore packages we need to do this authentication here
-      # otherwise it'll complain about accessing a private feed.
-      - task: NuGetAuthenticate@0
-        displayName: 'Authenticate to AzDO Feeds'
-
-      - task: PowerShell@2
-        displayName: Enable cross-org publishing
-        inputs:
-          filePath: eng\common\enable-cross-org-publishing.ps1
-          arguments: -token $(dn-bot-dnceng-artifact-feeds-rw)
-
-      - task: PowerShell@2
-        displayName: Publish
-        inputs:
-          filePath: eng\common\sdk-task.ps1
-          arguments: -task PublishToSymbolServers -restore -msbuildEngine dotnet
-            /p:DotNetSymbolServerTokenMsdl=$(microsoft-symbol-server-pat)
-            /p:DotNetSymbolServerTokenSymWeb=$(symweb-symbol-server-pat)
-            /p:PDBArtifactsDirectory='$(Build.ArtifactStagingDirectory)/PDBArtifacts/'
-            /p:BlobBasePath='$(Build.ArtifactStagingDirectory)/BlobArtifacts/'
-            /p:SymbolPublishingExclusionsFile='$(Build.SourcesDirectory)/eng/SymbolPublishingExclusionsFile.txt'
-            /p:Configuration=Release
-            ${{ parameters.symbolPublishingAdditionalParameters }}
-
-      - template: ../../steps/publish-logs.yml
-        parameters:
-          StageLabel: '${{ parameters.stageName }}'
-          JobLabel: 'SymbolPublishing'
-
-  - job: publish_assets
-    displayName: Publish Assets
-    dependsOn: setupMaestroVars
-    timeoutInMinutes: 120
-    variables:
-      - name: BARBuildId
-        value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.BARBuildId'] ]
-      - name: IsStableBuild
-        value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.IsStableBuild'] ]
-      - name: AzDOProjectName
-        value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOProjectName'] ]
-      - name: AzDOPipelineId
-        value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOPipelineId'] ]
-      - name: AzDOBuildId
-        value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOBuildId'] ]
-      - name: ArtifactsCategory
-        value: ${{ coalesce(variables._DotNetArtifactsCategory, '.NETCore') }}
-    condition: contains(dependencies.setupMaestroVars.outputs['setReleaseVars.TargetChannels'], format('[{0}]', ${{ parameters.channelId }} ))
-    pool:
-      vmImage: 'windows-2019'
-    steps:
-      - script: echo "##vso[task.logissue type=warning]Going forward, v2 Arcade publishing is no longer supported. Please read https://github.com/dotnet/arcade/blob/main/Documentation/CorePackages/Publishing.md for details, then contact dnceng if you have further questions."
-        displayName: Warn about v2 Arcade Publishing Usage
-
-      - task: DownloadBuildArtifacts@0
-        displayName: Download Build Assets
-        continueOnError: true
-        inputs:
-          buildType: specific
-          buildVersionToDownload: specific
-          project: $(AzDOProjectName)
-          pipeline: $(AzDOPipelineId)
-          buildId: $(AzDOBuildId)
-          downloadType: 'specific'
-          itemPattern: |
-            PackageArtifacts/**
-            BlobArtifacts/**
-            AssetManifests/**
-          downloadPath: '$(Build.ArtifactStagingDirectory)'
-          checkDownloadedFiles: true
-
-      - task: NuGetToolInstaller@1
-        displayName: 'Install NuGet.exe'
-
-      # This is necessary whenever we want to publish/restore to an AzDO private feed
-      - task: NuGetAuthenticate@0
-        displayName: 'Authenticate to AzDO Feeds'
-
-      - task: PowerShell@2
-        displayName: Enable cross-org publishing
-        inputs:
-          filePath: eng\common\enable-cross-org-publishing.ps1
-          arguments: -token $(dn-bot-dnceng-artifact-feeds-rw)
-
-      - task: PowerShell@2
-        displayName: Publish Assets
-        inputs:
-          filePath: eng\common\sdk-task.ps1
-          arguments: -task PublishArtifactsInManifest -restore -msbuildEngine dotnet
-            /p:PublishingInfraVersion=2
-            /p:ArtifactsCategory=$(ArtifactsCategory)
-            /p:IsStableBuild=$(IsStableBuild)
-            /p:IsInternalBuild=$(IsInternalBuild)
-            /p:RepositoryName=$(Build.Repository.Name)
-            /p:CommitSha=$(Build.SourceVersion)
-            /p:NugetPath=$(NuGetExeToolPath)
-            /p:AzdoTargetFeedPAT='$(dn-bot-dnceng-universal-packages-rw)'
-            /p:AzureStorageTargetFeedPAT='$(dotnetfeed-storage-access-key-1)'
-            /p:BARBuildId=$(BARBuildId)
-            /p:MaestroApiEndpoint='$(MaestroApiEndPoint)'
-            /p:BuildAssetRegistryToken='$(MaestroApiAccessToken)'
-            /p:ManifestsBasePath='$(Build.ArtifactStagingDirectory)/AssetManifests/'
-            /p:BlobBasePath='$(Build.ArtifactStagingDirectory)/BlobArtifacts/'
-            /p:PackageBasePath='$(Build.ArtifactStagingDirectory)/PackageArtifacts/'
-            /p:Configuration=Release
-            /p:PublishInstallersAndChecksums=${{ parameters.publishInstallersAndChecksums }}
-            /p:InstallersTargetStaticFeed=$(InstallersBlobFeedUrl)
-            /p:InstallersAzureAccountKey=$(dotnetcli-storage-key)
-            /p:ChecksumsTargetStaticFeed=$(ChecksumsBlobFeedUrl)
-            /p:ChecksumsAzureAccountKey=$(dotnetclichecksums-storage-key)
-            /p:AzureDevOpsStaticShippingFeed='${{ parameters.shippingFeed }}'
-            /p:AzureDevOpsStaticShippingFeedKey='$(dn-bot-dnceng-artifact-feeds-rw)'
-            /p:AzureDevOpsStaticTransportFeed='${{ parameters.transportFeed }}'
-            /p:AzureDevOpsStaticTransportFeedKey='$(dn-bot-dnceng-artifact-feeds-rw)'
-            /p:AzureDevOpsStaticSymbolsFeed='${{ parameters.symbolsFeed }}'
-            /p:AzureDevOpsStaticSymbolsFeedKey='$(dn-bot-dnceng-artifact-feeds-rw)'
-            /p:LatestLinkShortUrlPrefix=dotnet/'${{ parameters.akaMSChannelName }}'
-            /p:AkaMSClientId=$(akams-client-id)
-            /p:AkaMSClientSecret=$(akams-client-secret)
-            ${{ parameters.artifactsPublishingAdditionalParameters }}
-
-      - template: ../../steps/publish-logs.yml
-        parameters:
-          StageLabel: '${{ parameters.stageName }}'
-          JobLabel: 'AssetsPublishing'
-
-      - template: ../../steps/add-build-to-channel.yml
-        parameters:
-          ChannelId: ${{ parameters.channelId }}
diff --git a/eng/common/templates/post-build/post-build.yml b/eng/common/templates/post-build/post-build.yml
index 4f79cf0f33703..d1759337abe6a 100644
--- a/eng/common/templates/post-build/post-build.yml
+++ b/eng/common/templates/post-build/post-build.yml
@@ -1,71 +1,89 @@
 parameters:
- # Which publishing infra should be used. THIS SHOULD MATCH THE VERSION ON THE BUILD MANIFEST.
-  # Publishing V2 accepts optionally outlining the publishing stages - default is inline.
-  # Publishing V3 DOES NOT accept inlining the publishing stages.
-  publishingInfraVersion: 2
-  # When set to true the publishing templates from the repo will be used
-  # otherwise Darc add-build-to-channel will be used to trigger the promotion pipeline
-  inline: true
-
-  # Only used if inline==false. When set to true will stall the current build until
-  # the Promotion Pipeline build finishes. Otherwise, the current build will continue 
-  # execution concurrently with the promotion build.
-  waitPublishingFinish: true
-
-  BARBuildId: ''
-  PromoteToChannelIds: ''
-
-  enableSourceLinkValidation: false
-  enableSigningValidation: true
-  enableSymbolValidation: false
-  enableNugetValidation: true
-  publishInstallersAndChecksums: true
-  SDLValidationParameters:
-    enable: false
-    continueOnError: false
-    params: ''
-    artifactNames: ''
-    downloadArtifacts: true
+  # Which publishing infra should be used. THIS SHOULD MATCH THE VERSION ON THE BUILD MANIFEST.
+  # Publishing V1 is no longer supported
+  # Publishing V2 is no longer supported
+  # Publishing V3 is the default
+  - name: publishingInfraVersion
+    displayName: Which version of publishing should be used to promote the build definition?
+    type: number
+    default: 3
+    values:
+    - 3
+
+  - name: BARBuildId
+    displayName: BAR Build Id
+    type: number
+    default: 0
+
+  - name: PromoteToChannelIds
+    displayName: Channel to promote BARBuildId to
+    type: string
+    default: ''
+
+  - name: enableSourceLinkValidation
+    displayName: Enable SourceLink validation
+    type: boolean
+    default: false
+
+  - name: enableSigningValidation
+    displayName: Enable signing validation
+    type: boolean
+    default: true
+
+  - name: enableSymbolValidation
+    displayName: Enable symbol validation
+    type: boolean
+    default: false
+
+  - name: enableNugetValidation
+    displayName: Enable NuGet validation
+    type: boolean
+    default: true
+    
+  - name: publishInstallersAndChecksums
+    displayName: Publish installers and checksums
+    type: boolean
+    default: true
+
+  - name: SDLValidationParameters
+    type: object
+    default:
+      enable: false
+      continueOnError: false
+      params: ''
+      artifactNames: ''
+      downloadArtifacts: true
 
   # These parameters let the user customize the call to sdk-task.ps1 for publishing
   # symbols & general artifacts as well as for signing validation
-  symbolPublishingAdditionalParameters: ''
-  artifactsPublishingAdditionalParameters: ''
-  signingValidationAdditionalParameters: ''
+  - name: symbolPublishingAdditionalParameters
+    displayName: Symbol publishing additional parameters
+    type: string
+    default: ''
+
+  - name: artifactsPublishingAdditionalParameters
+    displayName: Artifact publishing additional parameters
+    type: string
+    default: ''
+
+  - name: signingValidationAdditionalParameters
+    displayName: Signing validation additional parameters
+    type: string
+    default: ''
 
   # Which stages should finish execution before post-build stages start
-  validateDependsOn:
-  - build
-  publishDependsOn: 
-  - Validate
+  - name: validateDependsOn
+    type: object
+    default:
+    - build
 
-  # Channel ID's instantiated in this file.
-  # When adding a new channel implementation the call to `check-channel-consistency.ps1` 
-  # needs to be updated with the new channel ID
-  NetEngLatestChannelId: 2
-  NetEngValidationChannelId: 9
-  NetDev5ChannelId: 131
-  NetDev6ChannelId: 1296
-  GeneralTestingChannelId: 529
-  NETCoreToolingDevChannelId: 548
-  NETCoreToolingReleaseChannelId: 549
-  NETInternalToolingChannelId: 551
-  NETCoreExperimentalChannelId: 562
-  NetEngServicesIntChannelId: 678
-  NetEngServicesProdChannelId: 679
-  NetCoreSDK313xxChannelId: 759
-  NetCoreSDK313xxInternalChannelId: 760
-  NetCoreSDK314xxChannelId: 921
-  NetCoreSDK314xxInternalChannelId: 922
-  VS166ChannelId: 1010
-  VS167ChannelId: 1011
-  VS168ChannelId: 1154
-  VSMasterChannelId: 1012
-  VS169ChannelId: 1473
-  VS1610ChannelId: 1692
+  - name: publishDependsOn
+    type: object
+    default:
+    - Validate
 
 stages:
-- ${{ if or(and(le(parameters.publishingInfraVersion, 2), eq(parameters.inline, 'true')), eq( parameters.enableNugetValidation, 'true'), eq(parameters.enableSigningValidation, 'true'), eq(parameters.enableSourceLinkValidation, 'true'), eq(parameters.SDLValidationParameters.enable, 'true')) }}:
+- ${{ if or(eq( parameters.enableNugetValidation, 'true'), eq(parameters.enableSigningValidation, 'true'), eq(parameters.enableSourceLinkValidation, 'true'), eq(parameters.SDLValidationParameters.enable, 'true')) }}:
   - stage: Validate
     dependsOn: ${{ parameters.validateDependsOn }}
     displayName: Validate Build Assets
@@ -77,23 +95,6 @@ stages:
         BARBuildId: ${{ parameters.BARBuildId }}
         PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}
 
-    - ${{ if and(le(parameters.publishingInfraVersion, 2), eq(parameters.inline, 'true')) }}:
-      - job:
-        displayName: Post-build Checks
-        dependsOn: setupMaestroVars
-        variables:
-          - name: TargetChannels
-            value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.TargetChannels'] ]
-        pool:
-          vmImage: 'windows-2019'
-        steps:
-          - task: PowerShell@2
-            displayName: Maestro Channels Consistency
-            inputs:
-              filePath: $(Build.SourcesDirectory)/eng/common/post-build/check-channel-consistency.ps1
-              arguments: -PromoteToChannels "$(TargetChannels)"
-                -AvailableChannelIds ${{parameters.NetEngLatestChannelId}},${{parameters.NetEngValidationChannelId}},${{parameters.NetDev5ChannelId}},${{parameters.NetDev6ChannelId}},${{parameters.GeneralTestingChannelId}},${{parameters.NETCoreToolingDevChannelId}},${{parameters.NETCoreToolingReleaseChannelId}},${{parameters.NETInternalToolingChannelId}},${{parameters.NETCoreExperimentalChannelId}},${{parameters.NetEngServicesIntChannelId}},${{parameters.NetEngServicesProdChannelId}},${{parameters.NetCoreSDK313xxChannelId}},${{parameters.NetCoreSDK313xxInternalChannelId}},${{parameters.NetCoreSDK314xxChannelId}},${{parameters.NetCoreSDK314xxInternalChannelId}},${{parameters.VS166ChannelId}},${{parameters.VS167ChannelId}},${{parameters.VS168ChannelId}},${{parameters.VSMasterChannelId}},${{parameters.VS169ChannelId}},${{parameters.VS1610ChannelId}}
-
     - job:
       displayName: NuGet Validation
       dependsOn: setupMaestroVars
@@ -229,361 +230,39 @@ stages:
         artifactNames: ${{ parameters.SDLValidationParameters.artifactNames }}
         downloadArtifacts: ${{ parameters.SDLValidationParameters.downloadArtifacts }}
 
-- ${{ if or(ge(parameters.publishingInfraVersion, 3), eq(parameters.inline, 'false')) }}:
-  - stage: publish_using_darc
-    ${{ if or(eq(parameters.enableNugetValidation, 'true'), eq(parameters.enableSigningValidation, 'true'), eq(parameters.enableSourceLinkValidation, 'true'), eq(parameters.SDLValidationParameters.enable, 'true')) }}:
-      dependsOn: ${{ parameters.publishDependsOn }}
-    ${{ if and(ne(parameters.enableNugetValidation, 'true'), ne(parameters.enableSigningValidation, 'true'), ne(parameters.enableSourceLinkValidation, 'true'), ne(parameters.SDLValidationParameters.enable, 'true')) }}:
-      dependsOn: ${{ parameters.validateDependsOn }}
-    displayName: Publish using Darc
-    variables:
-      - template: common-variables.yml
-    jobs:
-    - template: setup-maestro-vars.yml
-      parameters:
-        BARBuildId: ${{ parameters.BARBuildId }}
-        PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}
-
-    - job:
-      displayName: Publish Using Darc
-      dependsOn: setupMaestroVars
-      timeoutInMinutes: 120
-      variables:
-        - name: BARBuildId
-          value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.BARBuildId'] ]
-      pool:
-        vmImage: 'windows-2019'
-      steps:
-        - task: PowerShell@2
-          displayName: Publish Using Darc
-          inputs:
-            filePath: $(Build.SourcesDirectory)/eng/common/post-build/publish-using-darc.ps1
-            arguments: -BuildId $(BARBuildId) 
-              -PublishingInfraVersion ${{ parameters.PublishingInfraVersion }}
-              -AzdoToken '$(publishing-dnceng-devdiv-code-r-build-re)'
-              -MaestroToken '$(MaestroApiAccessToken)'
-              -WaitPublishingFinish ${{ parameters.waitPublishingFinish }}
-              -PublishInstallersAndChecksums ${{ parameters.publishInstallersAndChecksums }}
-              -ArtifactsPublishingAdditionalParameters '${{ parameters.artifactsPublishingAdditionalParameters }}'
-              -SymbolPublishingAdditionalParameters '${{ parameters.symbolPublishingAdditionalParameters }}'
-
-- ${{ if and(le(parameters.publishingInfraVersion, 2), eq(parameters.inline, 'true')) }}:
-  - template: \eng\common\templates\post-build\channels\generic-public-channel.yml
-    parameters:
-      BARBuildId: ${{ parameters.BARBuildId }}
-      PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}    
-      artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
-      dependsOn: ${{ parameters.publishDependsOn }}
-      publishInstallersAndChecksums: ${{ parameters.publishInstallersAndChecksums }}
-      symbolPublishingAdditionalParameters: ${{ parameters.symbolPublishingAdditionalParameters }}
-      stageName: 'NetCore_Dev5_Publish'
-      channelName: '.NET 5 Dev'
-      akaMSChannelName: 'net5/dev'
-      channelId: ${{ parameters.NetDev5ChannelId }}
-      transportFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet5-transport/nuget/v3/index.json'
-      shippingFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet5/nuget/v3/index.json'
-      symbolsFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet5-symbols/nuget/v3/index.json'
-
-  - template: \eng\common\templates\post-build\channels\generic-public-channel.yml
-    parameters:
-      BARBuildId: ${{ parameters.BARBuildId }}
-      PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}
-      artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
-      dependsOn: ${{ parameters.publishDependsOn }}
-      publishInstallersAndChecksums: ${{ parameters.publishInstallersAndChecksums }}
-      symbolPublishingAdditionalParameters: ${{ parameters.symbolPublishingAdditionalParameters }}
-      stageName: 'NetCore_Dev6_Publish'
-      channelName: '.NET 6 Dev'
-      akaMSChannelName: 'net6/dev'
-      channelId: ${{ parameters.NetDev6ChannelId }}
-      transportFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet6-transport/nuget/v3/index.json'
-      shippingFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet6/nuget/v3/index.json'
-      symbolsFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet6-symbols/nuget/v3/index.json'
-
-  - template: \eng\common\templates\post-build\channels\generic-public-channel.yml
+- stage: publish_using_darc
+  ${{ if or(eq(parameters.enableNugetValidation, 'true'), eq(parameters.enableSigningValidation, 'true'), eq(parameters.enableSourceLinkValidation, 'true'), eq(parameters.SDLValidationParameters.enable, 'true')) }}:
+    dependsOn: ${{ parameters.publishDependsOn }}
+  ${{ if and(ne(parameters.enableNugetValidation, 'true'), ne(parameters.enableSigningValidation, 'true'), ne(parameters.enableSourceLinkValidation, 'true'), ne(parameters.SDLValidationParameters.enable, 'true')) }}:
+    dependsOn: ${{ parameters.validateDependsOn }}
+  displayName: Publish using Darc
+  variables:
+    - template: common-variables.yml
+  jobs:
+  - template: setup-maestro-vars.yml
     parameters:
       BARBuildId: ${{ parameters.BARBuildId }}
       PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}
-      artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
-      dependsOn: ${{ parameters.publishDependsOn }}
-      publishInstallersAndChecksums: ${{ parameters.publishInstallersAndChecksums }}
-      symbolPublishingAdditionalParameters: ${{ parameters.symbolPublishingAdditionalParameters }}
-      stageName: 'Net_Eng_Latest_Publish'
-      channelName: '.NET Eng - Latest'
-      akaMSChannelName: 'eng/daily'
-      channelId: ${{ parameters.NetEngLatestChannelId }}
-      transportFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-eng/nuget/v3/index.json'
-      shippingFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-eng/nuget/v3/index.json'
-      symbolsFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-eng-symbols/nuget/v3/index.json'
 
-  - template: \eng\common\templates\post-build\channels\generic-public-channel.yml
-    parameters:
-      BARBuildId: ${{ parameters.BARBuildId }}
-      PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}    
-      artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
-      dependsOn: ${{ parameters.publishDependsOn }}
-      publishInstallersAndChecksums: ${{ parameters.publishInstallersAndChecksums }}
-      symbolPublishingAdditionalParameters: ${{ parameters.symbolPublishingAdditionalParameters }}
-      stageName: 'Net_Eng_Validation_Publish'
-      channelName: '.NET Eng - Validation'
-      akaMSChannelName: 'eng/validation'
-      channelId: ${{ parameters.NetEngValidationChannelId }}
-      transportFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-eng/nuget/v3/index.json'
-      shippingFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-eng/nuget/v3/index.json'
-      symbolsFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-eng-symbols/nuget/v3/index.json'
-
-  - template: \eng\common\templates\post-build\channels\generic-public-channel.yml
-    parameters:
-      BARBuildId: ${{ parameters.BARBuildId }}
-      PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}    
-      artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
-      dependsOn: ${{ parameters.publishDependsOn }}
-      publishInstallersAndChecksums: ${{ parameters.publishInstallersAndChecksums }}
-      symbolPublishingAdditionalParameters: ${{ parameters.symbolPublishingAdditionalParameters }}
-      stageName: 'General_Testing_Publish'
-      channelName: 'General Testing'
-      akaMSChannelName: 'generaltesting'
-      channelId: ${{ parameters.GeneralTestingChannelId }}
-      transportFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/general-testing/nuget/v3/index.json'
-      shippingFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/general-testing/nuget/v3/index.json'
-      symbolsFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/general-testing-symbols/nuget/v3/index.json'
-
-  - template: \eng\common\templates\post-build\channels\generic-public-channel.yml
-    parameters:
-      BARBuildId: ${{ parameters.BARBuildId }}
-      PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}    
-      artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
-      dependsOn: ${{ parameters.publishDependsOn }}
-      publishInstallersAndChecksums: ${{ parameters.publishInstallersAndChecksums }}
-      symbolPublishingAdditionalParameters: ${{ parameters.symbolPublishingAdditionalParameters }}
-      stageName: 'NETCore_Tooling_Dev_Publishing'
-      channelName: '.NET Core Tooling Dev'
-      channelId: ${{ parameters.NETCoreToolingDevChannelId }}
-      transportFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools/nuget/v3/index.json'
-      shippingFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools/nuget/v3/index.json'
-      symbolsFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools-symbols/nuget/v3/index.json'
-
-  - template: \eng\common\templates\post-build\channels\generic-public-channel.yml
-    parameters:
-      BARBuildId: ${{ parameters.BARBuildId }}
-      PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}    
-      artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
-      dependsOn: ${{ parameters.publishDependsOn }}
-      publishInstallersAndChecksums: ${{ parameters.publishInstallersAndChecksums }}
-      symbolPublishingAdditionalParameters: ${{ parameters.symbolPublishingAdditionalParameters }}
-      stageName: 'NETCore_Tooling_Release_Publishing'
-      channelName: '.NET Core Tooling Release'
-      channelId: ${{ parameters.NETCoreToolingReleaseChannelId }}
-      transportFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools/nuget/v3/index.json'
-      shippingFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools/nuget/v3/index.json'
-      symbolsFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools-symbols/nuget/v3/index.json'
-
-  - template: \eng\common\templates\post-build\channels\generic-internal-channel.yml
-    parameters:
-      BARBuildId: ${{ parameters.BARBuildId }}
-      PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}    
-      artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
-      dependsOn: ${{ parameters.publishDependsOn }}
-      publishInstallersAndChecksums: ${{ parameters.publishInstallersAndChecksums }}
-      symbolPublishingAdditionalParameters: ${{ parameters.symbolPublishingAdditionalParameters }}
-      stageName: 'NET_Internal_Tooling_Publishing'
-      channelName: '.NET Internal Tooling'
-      channelId: ${{ parameters.NETInternalToolingChannelId }}
-      transportFeed: 'https://pkgs.dev.azure.com/dnceng/internal/_packaging/dotnet-tools-internal/nuget/v3/index.json'
-      shippingFeed: 'https://pkgs.dev.azure.com/dnceng/internal/_packaging/dotnet-tools-internal/nuget/v3/index.json'
-      symbolsFeed: 'https://pkgs.dev.azure.com/dnceng/internal/_packaging/dotnet-tools-internal-symbols/nuget/v3/index.json'
-
-  - template: \eng\common\templates\post-build\channels\generic-public-channel.yml
-    parameters:
-      BARBuildId: ${{ parameters.BARBuildId }}
-      PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}    
-      artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
-      dependsOn: ${{ parameters.publishDependsOn }}
-      publishInstallersAndChecksums: ${{ parameters.publishInstallersAndChecksums }}
-      symbolPublishingAdditionalParameters: ${{ parameters.symbolPublishingAdditionalParameters }}
-      stageName: 'NETCore_Experimental_Publishing'
-      channelName: '.NET Core Experimental'
-      channelId: ${{ parameters.NETCoreExperimentalChannelId }}
-      transportFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-experimental/nuget/v3/index.json'
-      shippingFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-experimental/nuget/v3/index.json'
-      symbolsFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-experimental-symbols/nuget/v3/index.json'
-
-  - template: \eng\common\templates\post-build\channels\generic-public-channel.yml
-    parameters:
-      BARBuildId: ${{ parameters.BARBuildId }}
-      PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}    
-      artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
-      dependsOn: ${{ parameters.publishDependsOn }}
-      publishInstallersAndChecksums: ${{ parameters.publishInstallersAndChecksums }}
-      symbolPublishingAdditionalParameters: ${{ parameters.symbolPublishingAdditionalParameters }}
-      stageName: 'Net_Eng_Services_Int_Publish'
-      channelName: '.NET Eng Services - Int'
-      channelId: ${{ parameters.NetEngServicesIntChannelId }}
-      transportFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-eng/nuget/v3/index.json'
-      shippingFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-eng/nuget/v3/index.json'
-      symbolsFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-eng-symbols/nuget/v3/index.json'
-
-  - template: \eng\common\templates\post-build\channels\generic-public-channel.yml
-    parameters:
-      BARBuildId: ${{ parameters.BARBuildId }}
-      PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}    
-      artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
-      dependsOn: ${{ parameters.publishDependsOn }}
-      publishInstallersAndChecksums: ${{ parameters.publishInstallersAndChecksums }}
-      symbolPublishingAdditionalParameters: ${{ parameters.symbolPublishingAdditionalParameters }}
-      stageName: 'Net_Eng_Services_Prod_Publish'
-      channelName: '.NET Eng Services - Prod'
-      channelId: ${{ parameters.NetEngServicesProdChannelId }}
-      transportFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-eng/nuget/v3/index.json'
-      shippingFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-eng/nuget/v3/index.json'
-      symbolsFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-eng-symbols/nuget/v3/index.json'
-
-  - template: \eng\common\templates\post-build\channels\generic-public-channel.yml
-    parameters:
-      BARBuildId: ${{ parameters.BARBuildId }}
-      PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}    
-      artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
-      dependsOn: ${{ parameters.publishDependsOn }}
-      publishInstallersAndChecksums: ${{ parameters.publishInstallersAndChecksums }}
-      symbolPublishingAdditionalParameters: ${{ parameters.symbolPublishingAdditionalParameters }}
-      stageName: 'NETCore_SDK_314xx_Publishing'
-      channelName: '.NET Core SDK 3.1.4xx'
-      channelId: ${{ parameters.NetCoreSDK314xxChannelId }}
-      transportFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet3.1-transport/nuget/v3/index.json'
-      shippingFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet3.1/nuget/v3/index.json'
-      symbolsFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet3.1-symbols/nuget/v3/index.json'
-
-  - template: \eng\common\templates\post-build\channels\generic-internal-channel.yml
-    parameters:
-      BARBuildId: ${{ parameters.BARBuildId }}
-      PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}    
-      artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
-      dependsOn: ${{ parameters.publishDependsOn }}
-      publishInstallersAndChecksums: ${{ parameters.publishInstallersAndChecksums }}
-      symbolPublishingAdditionalParameters: ${{ parameters.symbolPublishingAdditionalParameters }}
-      stageName: 'NETCore_SDK_314xx_Internal_Publishing'
-      channelName: '.NET Core SDK 3.1.4xx Internal'
-      channelId: ${{ parameters.NetCoreSDK314xxInternalChannelId }}
-      transportFeed: 'https://pkgs.dev.azure.com/dnceng/_packaging/dotnet3.1-internal-transport/nuget/v3/index.json'
-      shippingFeed: 'https://pkgs.dev.azure.com/dnceng/_packaging/dotnet3.1-internal/nuget/v3/index.json'
-      symbolsFeed: 'https://pkgs.dev.azure.com/dnceng/_packaging/dotnet3.1-internal-symbols/nuget/v3/index.json' 
-
-  - template: \eng\common\templates\post-build\channels\generic-public-channel.yml
-    parameters:
-      BARBuildId: ${{ parameters.BARBuildId }}
-      PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}    
-      artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
-      dependsOn: ${{ parameters.publishDependsOn }}
-      publishInstallersAndChecksums: ${{ parameters.publishInstallersAndChecksums }}
-      symbolPublishingAdditionalParameters: ${{ parameters.symbolPublishingAdditionalParameters }}
-      stageName: 'NETCore_SDK_313xx_Publishing'
-      channelName: '.NET Core SDK 3.1.3xx'
-      channelId: ${{ parameters.NetCoreSDK313xxChannelId }}
-      transportFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet3.1-transport/nuget/v3/index.json'
-      shippingFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet3.1/nuget/v3/index.json'
-      symbolsFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet3.1-symbols/nuget/v3/index.json'
-
-  - template: \eng\common\templates\post-build\channels\generic-internal-channel.yml
-    parameters:
-      BARBuildId: ${{ parameters.BARBuildId }}
-      PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}    
-      artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
-      dependsOn: ${{ parameters.publishDependsOn }}
-      publishInstallersAndChecksums: ${{ parameters.publishInstallersAndChecksums }}
-      symbolPublishingAdditionalParameters: ${{ parameters.symbolPublishingAdditionalParameters }}
-      stageName: 'NETCore_SDK_313xx_Internal_Publishing'
-      channelName: '.NET Core SDK 3.1.3xx Internal'
-      channelId: ${{ parameters.NetCoreSDK313xxInternalChannelId }}
-      transportFeed: 'https://pkgs.dev.azure.com/dnceng/_packaging/dotnet3.1-internal-transport/nuget/v3/index.json'
-      shippingFeed: 'https://pkgs.dev.azure.com/dnceng/_packaging/dotnet3.1-internal/nuget/v3/index.json'
-      symbolsFeed: 'https://pkgs.dev.azure.com/dnceng/_packaging/dotnet3.1-internal-symbols/nuget/v3/index.json' 
-
-  - template: \eng\common\templates\post-build\channels\generic-public-channel.yml
-    parameters:
-      BARBuildId: ${{ parameters.BARBuildId }}
-      PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}    
-      artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
-      dependsOn: ${{ parameters.publishDependsOn }}
-      publishInstallersAndChecksums: ${{ parameters.publishInstallersAndChecksums }}
-      symbolPublishingAdditionalParameters: ${{ parameters.symbolPublishingAdditionalParameters }}
-      stageName: 'VS16_6_Publishing'
-      channelName: 'VS 16.6'
-      channelId: ${{ parameters.VS166ChannelId }}
-      transportFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools-transport/nuget/v3/index.json'
-      shippingFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools/nuget/v3/index.json'
-      symbolsFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools-symbols/nuget/v3/index.json'
-
-  - template: \eng\common\templates\post-build\channels\generic-public-channel.yml
-    parameters:
-      BARBuildId: ${{ parameters.BARBuildId }}
-      PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}    
-      artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
-      dependsOn: ${{ parameters.publishDependsOn }}
-      publishInstallersAndChecksums: ${{ parameters.publishInstallersAndChecksums }}
-      symbolPublishingAdditionalParameters: ${{ parameters.symbolPublishingAdditionalParameters }}
-      stageName: 'VS16_7_Publishing'
-      channelName: 'VS 16.7'
-      channelId: ${{ parameters.VS167ChannelId }}
-      transportFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools-transport/nuget/v3/index.json'
-      shippingFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools/nuget/v3/index.json'
-      symbolsFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools-symbols/nuget/v3/index.json'
-      
-  - template: \eng\common\templates\post-build\channels\generic-public-channel.yml
-    parameters:
-      BARBuildId: ${{ parameters.BARBuildId }}
-      PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}    
-      artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
-      dependsOn: ${{ parameters.publishDependsOn }}
-      publishInstallersAndChecksums: ${{ parameters.publishInstallersAndChecksums }}
-      symbolPublishingAdditionalParameters: ${{ parameters.symbolPublishingAdditionalParameters }}
-      stageName: 'VS16_8_Publishing'
-      channelName: 'VS 16.8'
-      channelId: ${{ parameters.VS168ChannelId }}
-      transportFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools-transport/nuget/v3/index.json'
-      shippingFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools/nuget/v3/index.json'
-      symbolsFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools-symbols/nuget/v3/index.json'
-
-  - template: \eng\common\templates\post-build\channels\generic-public-channel.yml
-    parameters:
-      BARBuildId: ${{ parameters.BARBuildId }}
-      PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}    
-      artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
-      dependsOn: ${{ parameters.publishDependsOn }}
-      publishInstallersAndChecksums: ${{ parameters.publishInstallersAndChecksums }}
-      symbolPublishingAdditionalParameters: ${{ parameters.symbolPublishingAdditionalParameters }}
-      stageName: 'VS_Master_Publishing'
-      channelName: 'VS Master'
-      channelId: ${{ parameters.VSMasterChannelId }}
-      transportFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools-transport/nuget/v3/index.json'
-      shippingFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools/nuget/v3/index.json'
-      symbolsFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools-symbols/nuget/v3/index.json'
-
-  - template: \eng\common\templates\post-build\channels\generic-public-channel.yml
-    parameters:
-      BARBuildId: ${{ parameters.BARBuildId }}
-      PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}    
-      artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
-      dependsOn: ${{ parameters.publishDependsOn }}
-      publishInstallersAndChecksums: ${{ parameters.publishInstallersAndChecksums }}
-      symbolPublishingAdditionalParameters: ${{ parameters.symbolPublishingAdditionalParameters }}
-      stageName: 'VS_16_9_Publishing'
-      channelName: 'VS 16.9'
-      channelId: ${{ parameters.VS169ChannelId }}
-      transportFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools-transport/nuget/v3/index.json'
-      shippingFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools/nuget/v3/index.json'
-      symbolsFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools-symbols/nuget/v3/index.json'
-
-  - template: \eng\common\templates\post-build\channels\generic-public-channel.yml
-    parameters:
-      BARBuildId: ${{ parameters.BARBuildId }}
-      PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}    
-      artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
-      dependsOn: ${{ parameters.publishDependsOn }}
-      publishInstallersAndChecksums: ${{ parameters.publishInstallersAndChecksums }}
-      symbolPublishingAdditionalParameters: ${{ parameters.symbolPublishingAdditionalParameters }}
-      stageName: 'VS_16_10_Publishing'
-      channelName: 'VS 16.10'
-      channelId: ${{ parameters.VS1610ChannelId }}
-      transportFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools-transport/nuget/v3/index.json'
-      shippingFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools/nuget/v3/index.json'
-      symbolsFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools-symbols/nuget/v3/index.json'
+  - job:
+    displayName: Publish Using Darc
+    dependsOn: setupMaestroVars
+    timeoutInMinutes: 120
+    variables:
+      - name: BARBuildId
+        value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.BARBuildId'] ]
+    pool:
+      vmImage: 'windows-2019'
+    steps:
+      - task: PowerShell@2
+        displayName: Publish Using Darc
+        inputs:
+          filePath: $(Build.SourcesDirectory)/eng/common/post-build/publish-using-darc.ps1
+          arguments: -BuildId $(BARBuildId) 
+            -PublishingInfraVersion ${{ parameters.publishingInfraVersion }}
+            -AzdoToken '$(publishing-dnceng-devdiv-code-r-build-re)'
+            -MaestroToken '$(MaestroApiAccessToken)'
+            -WaitPublishingFinish true
+            -PublishInstallersAndChecksums ${{ parameters.publishInstallersAndChecksums }}
+            -ArtifactsPublishingAdditionalParameters '${{ parameters.artifactsPublishingAdditionalParameters }}'
+            -SymbolPublishingAdditionalParameters '${{ parameters.symbolPublishingAdditionalParameters }}'
\ No newline at end of file
diff --git a/eng/common/templates/steps/execute-codeql.yml b/eng/common/templates/steps/execute-codeql.yml
new file mode 100644
index 0000000000000..3930b1630214b
--- /dev/null
+++ b/eng/common/templates/steps/execute-codeql.yml
@@ -0,0 +1,32 @@
+parameters:
+  # Language that should be analyzed. Defaults to csharp
+  language: csharp
+  # Build Commands
+  buildCommands: ''
+  overrideParameters: ''                                       # Optional: to override values for parameters.
+  additionalParameters: ''                                     # Optional: parameters that need user specific values eg: '-SourceToolsList @("abc","def") -ArtifactToolsList @("ghi","jkl")'
+  # Optional: if specified, restore and use this version of Guardian instead of the default.
+  overrideGuardianVersion: ''
+  # Optional: if true, publish the '.gdn' folder as a pipeline artifact. This can help with in-depth
+  # diagnosis of problems with specific tool configurations.
+  publishGuardianDirectoryToPipeline: false
+  # The script to run to execute all SDL tools. Use this if you want to use a script to define SDL
+  # parameters rather than relying on YAML. It may be better to use a local script, because you can
+  # reproduce results locally without piecing together a command based on the YAML.
+  executeAllSdlToolsScript: 'eng/common/sdl/execute-all-sdl-tools.ps1'
+  # There is some sort of bug (has been reported) in Azure DevOps where if this parameter is named
+  # 'continueOnError', the parameter value is not correctly picked up.
+  # This can also be remedied by the caller (post-build.yml) if it does not use a nested parameter
+  # optional: determines whether to continue the build if the step errors;
+  sdlContinueOnError: false
+
+steps:
+- template: /eng/common/templates/steps/execute-sdl.yml
+  parameters:
+    overrideGuardianVersion: ${{ parameters.overrideGuardianVersion }}
+    executeAllSdlToolsScript: ${{ parameters.executeAllSdlToolsScript }}
+    overrideParameters: ${{ parameters.overrideParameters }}
+    additionalParameters: '${{ parameters.additionalParameters }}
+      -CodeQLAdditionalRunConfigParams @("BuildCommands < ${{ parameters.buildCommands }}", "Language < ${{ parameters.language }}")'
+    publishGuardianDirectoryToPipeline: ${{ parameters.publishGuardianDirectoryToPipeline }}
+    sdlContinueOnError: ${{ parameters.sdlContinueOnError }}
\ No newline at end of file
diff --git a/global.json b/global.json
index 3321e0dc9261a..133b313ed80bc 100644
--- a/global.json
+++ b/global.json
@@ -12,7 +12,7 @@
     "xcopy-msbuild": "16.10.0-preview2"
   },
   "msbuild-sdks": {
-    "Microsoft.DotNet.Arcade.Sdk": "7.0.0-beta.22053.2",
-    "Microsoft.DotNet.Helix.Sdk": "7.0.0-beta.22053.2"
+    "Microsoft.DotNet.Arcade.Sdk": "7.0.0-beta.22063.1",
+    "Microsoft.DotNet.Helix.Sdk": "7.0.0-beta.22063.1"
   }
 }

From 0cf8be316f8c86627d0598ebc4e69bbaf70273d4 Mon Sep 17 00:00:00 2001
From: Shen Chen <shech@microsoft.com>
Date: Thu, 13 Jan 2022 11:01:20 -0800
Subject: [PATCH 340/444] Update the insertion instruction

---
 eng/config/PublishData.json | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/eng/config/PublishData.json b/eng/config/PublishData.json
index 10cb84b7ec43b..14499e77c8539 100644
--- a/eng/config/PublishData.json
+++ b/eng/config/PublishData.json
@@ -210,7 +210,7 @@
       "channels": [],
       "vsBranch": "rel/d17.1",
       "vsMajorVersion": 17,
-      "insertionCreateDraftPR": true,
+      "insertionCreateDraftPR": false,
       "insertionTitlePrefix": "[d17.1p3]"
     },
     "main": {
@@ -223,7 +223,8 @@
       "channels": [],
       "vsBranch": "main",
       "vsMajorVersion": 17,
-      "insertionTitlePrefix": "[Validation]"
+      "insertionCreateDraftPR": false,
+      "insertionTitlePrefix": "[d17.2p1]"
     },
     "features/NullableReferenceTypes": {
       "nugetKind": "PerBuildPreRelease",

From 0ff0e5916ee4eaf708729101180b38c2ccc28eda Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Thu, 13 Jan 2022 12:05:03 -0800
Subject: [PATCH 341/444] Do not return empty nodes from teh
 CodeRefactoringHelpers

---
 .../AddParameterCheckTests.cs                 | 64 +++++++++++++++++++
 .../AbstractRefactoringHelpersService.cs      | 19 +++---
 ...tializeParameterCodeRefactoringProvider.cs | 14 ----
 3 files changed, 75 insertions(+), 22 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/InitializeParameter/AddParameterCheckTests.cs b/src/EditorFeatures/CSharpTest/InitializeParameter/AddParameterCheckTests.cs
index 5a7a43b86ad35..bc510b2c65bb2 100644
--- a/src/EditorFeatures/CSharpTest/InitializeParameter/AddParameterCheckTests.cs
+++ b/src/EditorFeatures/CSharpTest/InitializeParameter/AddParameterCheckTests.cs
@@ -2743,5 +2743,69 @@ public C(object a, object b, object c)
                 CodeActionEquivalenceKey = nameof(FeaturesResources.Add_null_checks_for_all_parameters)
             }.RunAsync();
         }
+
+        [WorkItem(58811, "https://github.com/dotnet/roslyn/issues/58811")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInitializeParameter)]
+        public async Task TestMissingParameter1()
+        {
+            var source = @"
+using System;
+
+class C
+{
+    public C(string s,[||]{|CS1031:{|CS1001:)|}|}
+    {
+    }
+}";
+            await VerifyCS.VerifyRefactoringAsync(source, source);
+        }
+
+        [WorkItem(58811, "https://github.com/dotnet/roslyn/issues/58811")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInitializeParameter)]
+        public async Task TestMissingParameter2()
+        {
+            var source = @"
+using System;
+
+class C
+{
+    public C(string s,[||] {|CS1031:{|CS1001:)|}|}
+    {
+    }
+}";
+            await VerifyCS.VerifyRefactoringAsync(source, source);
+        }
+
+        [WorkItem(58811, "https://github.com/dotnet/roslyn/issues/58811")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInitializeParameter)]
+        public async Task TestMissingParameter3()
+        {
+            var source = @"
+using System;
+
+class C
+{
+    public C(string s, [||]{|CS1031:{|CS1001:)|}|}
+    {
+    }
+}";
+            await VerifyCS.VerifyRefactoringAsync(source, source);
+        }
+
+        [WorkItem(58811, "https://github.com/dotnet/roslyn/issues/58811")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInitializeParameter)]
+        public async Task TestMissingParameter4()
+        {
+            var source = @"
+using System;
+
+class C
+{
+    public C(string s, [||] {|CS1031:{|CS1001:)|}|}
+    {
+    }
+}";
+            await VerifyCS.VerifyRefactoringAsync(source, source);
+        }
     }
 }
diff --git a/src/Features/Core/Portable/CodeRefactorings/AbstractRefactoringHelpersService.cs b/src/Features/Core/Portable/CodeRefactorings/AbstractRefactoringHelpersService.cs
index 9520492d8f040..5e7c26b0936bc 100644
--- a/src/Features/Core/Portable/CodeRefactorings/AbstractRefactoringHelpersService.cs
+++ b/src/Features/Core/Portable/CodeRefactorings/AbstractRefactoringHelpersService.cs
@@ -34,11 +34,7 @@ public async Task<ImmutableArray<TSyntaxNode>> GetRelevantNodesAsync<TSyntaxNode
             // block's Node. That is because in addition to LocalFunctionStatement the selection would also contain trailing trivia 
             // (whitespace) of following statement.
 
-            var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-            if (root == null)
-            {
-                return ImmutableArray<TSyntaxNode>.Empty;
-            }
+            var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
             var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
             var headerFacts = document.GetRequiredLanguageService<IHeaderFactsService>();
@@ -315,7 +311,7 @@ private void AddRelevantNodesForSelection<TSyntaxNode>(ISyntaxFactsService synta
                         break;
                     }
 
-                    relevantNodesBuilder.Add(nonHiddenExtractedNode);
+                    AddIfNotMissing(relevantNodesBuilder, nonHiddenExtractedNode);
                 }
 
                 prevNode = selectionNode;
@@ -324,6 +320,13 @@ private void AddRelevantNodesForSelection<TSyntaxNode>(ISyntaxFactsService synta
             while (selectionNode != null && prevNode.FullWidth() == selectionNode.FullWidth());
         }
 
+        private static void AddIfNotMissing<TSyntaxNode>(
+            ArrayBuilder<TSyntaxNode> relevantNodesBuilder, TSyntaxNode node) where TSyntaxNode : SyntaxNode
+        {
+            if (node.Span.Length > 0)
+                relevantNodesBuilder.Add(node);
+        }
+
         /// <summary>
         /// Extractor function that retrieves all nodes that should be considered for extraction of given current node. 
         /// <para>
@@ -483,7 +486,7 @@ protected virtual async Task AddNodesDeepInAsync<TSyntaxNode>(
 
                     if (argumentStartLine == caretLine && !correctTypeNode.OverlapsHiddenPosition(cancellationToken))
                     {
-                        relevantNodesBuilder.Add(correctTypeNode);
+                        AddIfNotMissing(relevantNodesBuilder, correctTypeNode);
                     }
                     else if (argumentStartLine < caretLine)
                     {
@@ -502,7 +505,7 @@ private static void AddNonHiddenCorrectTypeNodes<TSyntaxNode>(IEnumerable<Syntax
             var correctTypeNonHiddenNodes = nodes.OfType<TSyntaxNode>().Where(n => !n.OverlapsHiddenPosition(cancellationToken));
             foreach (var nodeToBeAdded in correctTypeNonHiddenNodes)
             {
-                resultBuilder.Add(nodeToBeAdded);
+                AddIfNotMissing(resultBuilder, nodeToBeAdded);
             }
         }
 
diff --git a/src/Features/Core/Portable/InitializeParameter/AbstractInitializeParameterCodeRefactoringProvider.cs b/src/Features/Core/Portable/InitializeParameter/AbstractInitializeParameterCodeRefactoringProvider.cs
index e5bb8311f9134..bd78e93f09d40 100644
--- a/src/Features/Core/Portable/InitializeParameter/AbstractInitializeParameterCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/InitializeParameter/AbstractInitializeParameterCodeRefactoringProvider.cs
@@ -83,20 +83,6 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
                 return;
             }
 
-            // https://github.com/dotnet/roslyn/issues/58811
-            // We had a parameter that we couldn't round trip using its span.
-            var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-            var foundNode = root.FindNode(selectedParameter.Span);
-            if (foundNode is not TParameterSyntax)
-            {
-                var message = $@"Could not roundtrip parameter '{selectedParameter}'@{selectedParameter.Span}
-Found: '{foundNode}'@{foundNode?.Span}
-In:
-{selectedParameter?.Parent?.Parent}";
-                FatalError.ReportWithDumpAndCatch(new InvalidOperationException(message), ErrorSeverity.Critical);
-                return;
-            }
-
             var generator = SyntaxGenerator.GetGenerator(document);
             var parameterNodes = generator.GetParameters(functionDeclaration);
             var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);

From 56f30440408c8c0c6e914a06f639a0a5c0c7c0d1 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Thu, 13 Jan 2022 12:05:38 -0800
Subject: [PATCH 342/444] Update comment

---
 .../IRefactoringHelpersService.cs             | 32 +++++++++++--------
 1 file changed, 18 insertions(+), 14 deletions(-)

diff --git a/src/Features/Core/Portable/CodeRefactorings/IRefactoringHelpersService.cs b/src/Features/Core/Portable/CodeRefactorings/IRefactoringHelpersService.cs
index 48365e2ba30d5..69eb4ede0fde1 100644
--- a/src/Features/Core/Portable/CodeRefactorings/IRefactoringHelpersService.cs
+++ b/src/Features/Core/Portable/CodeRefactorings/IRefactoringHelpersService.cs
@@ -26,26 +26,30 @@ internal interface IRefactoringHelpersService : IHeaderFactsService, ILanguageSe
 
         /// <summary>
         /// <para>
-        /// Returns an array of <typeparamref name="TSyntaxNode"/> instances for refactoring given specified selection in document.
+        /// Returns an array of <typeparamref name="TSyntaxNode"/> instances for refactoring given specified selection
+        /// in document. The nodes returned will all have non-empty spans.
         /// </para>
         /// <para>
-        /// A <typeparamref name="TSyntaxNode"/> instance is returned if:
-        /// - Selection is zero-width and inside/touching a Token with direct parent of type <typeparamref name="TSyntaxNode"/>.
-        /// - Selection is zero-width and touching a Token whose ancestor of type <typeparamref name="TSyntaxNode"/> ends/starts precisely on current selection.
-        /// - Selection is zero-width and in whitespace that corresponds to a Token whose direct ancestor is of type of type <typeparamref name="TSyntaxNode"/>.
-        /// - Selection is zero-width and in a header (defined by ISyntaxFacts helpers) of an node of type of type <typeparamref name="TSyntaxNode"/>.
-        /// - Token whose direct parent of type <typeparamref name="TSyntaxNode"/> is selected.
-        /// - Selection is zero-width and wanted node is an expression / argument with selection within such syntax node (arbitrarily deep) on its first line.
-        /// - Whole node of a type <typeparamref name="TSyntaxNode"/> is selected.
+        /// A <typeparamref name="TSyntaxNode"/> instance is returned if: - Selection is zero-width and inside/touching
+        /// a Token with direct parent of type <typeparamref name="TSyntaxNode"/>. - Selection is zero-width and
+        /// touching a Token whose ancestor of type <typeparamref name="TSyntaxNode"/> ends/starts precisely on current
+        /// selection. - Selection is zero-width and in whitespace that corresponds to a Token whose direct ancestor is
+        /// of type of type <typeparamref name="TSyntaxNode"/>. - Selection is zero-width and in a header (defined by
+        /// ISyntaxFacts helpers) of an node of type of type <typeparamref name="TSyntaxNode"/>. - Token whose direct
+        /// parent of type <typeparamref name="TSyntaxNode"/> is selected. - Selection is zero-width and wanted node is
+        /// an expression / argument with selection within such syntax node (arbitrarily deep) on its first line. -
+        /// Whole node of a type <typeparamref name="TSyntaxNode"/> is selected.
         /// </para>
         /// <para>
-        /// Attempts extracting a Node of type <typeparamref name="TSyntaxNode"/> for each Node it considers (see above).
-        /// E.g. extracts initializer expressions from declarations and assignments, Property declaration from any header node, etc.
+        /// Attempts extracting a Node of type <typeparamref name="TSyntaxNode"/> for each Node it considers (see
+        /// above). E.g. extracts initializer expressions from declarations and assignments, Property declaration from
+        /// any header node, etc.
         /// </para>
         /// <para>
-        /// Note: this function trims all whitespace from both the beginning and the end of given <paramref name="selection"/>.
-        /// The trimmed version is then used to determine relevant <see cref="SyntaxNode"/>. It also handles incomplete selections
-        /// of tokens gracefully. Over-selection containing leading comments is also handled correctly. 
+        /// Note: this function trims all whitespace from both the beginning and the end of given <paramref
+        /// name="selection"/>. The trimmed version is then used to determine relevant <see cref="SyntaxNode"/>. It also
+        /// handles incomplete selections of tokens gracefully. Over-selection containing leading comments is also
+        /// handled correctly. 
         /// </para>
         /// </summary>
         Task<ImmutableArray<TSyntaxNode>> GetRelevantNodesAsync<TSyntaxNode>(Document document, TextSpan selection, CancellationToken cancellationToken) where TSyntaxNode : SyntaxNode;

From a20b4e250d19fd7f1ccae2a9854f25c910b23462 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Thu, 13 Jan 2022 12:09:17 -0800
Subject: [PATCH 343/444] Revert

---
 .../AbstractInitializeParameterCodeRefactoringProvider.cs        | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Features/Core/Portable/InitializeParameter/AbstractInitializeParameterCodeRefactoringProvider.cs b/src/Features/Core/Portable/InitializeParameter/AbstractInitializeParameterCodeRefactoringProvider.cs
index bd78e93f09d40..9046a16c44144 100644
--- a/src/Features/Core/Portable/InitializeParameter/AbstractInitializeParameterCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/InitializeParameter/AbstractInitializeParameterCodeRefactoringProvider.cs
@@ -11,7 +11,6 @@
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeRefactorings;
 using Microsoft.CodeAnalysis.Editing;
-using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.Operations;
 using Microsoft.CodeAnalysis.PooledObjects;

From 2abc7bb77ead392b1cba1be52282f13f5e938f9e Mon Sep 17 00:00:00 2001
From: Shen Chen <cos_ifne@hotmail.com>
Date: Thu, 13 Jan 2022 12:26:38 -0800
Subject: [PATCH 344/444] Update VisualStudioCacheVersion

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

diff --git a/eng/Versions.props b/eng/Versions.props
index ac7ff9e44210f..286220e11990b 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -119,7 +119,7 @@
     <MicrosoftServiceHubFrameworkVersion>3.1.4</MicrosoftServiceHubFrameworkVersion>
     <MicrosoftSourceLinkToolsVersion>1.1.1-beta-21566-01</MicrosoftSourceLinkToolsVersion>
     <MicrosoftVisualBasicVersion>10.1.0</MicrosoftVisualBasicVersion>
-    <MicrosoftVisualStudioCacheVersion>17.0.13-alpha</MicrosoftVisualStudioCacheVersion>
+    <MicrosoftVisualStudioCacheVersion>17.0.42</MicrosoftVisualStudioCacheVersion>
     <MicrosoftVisualStudioCallHierarchyPackageDefinitionsVersion>15.8.27812-alpha</MicrosoftVisualStudioCallHierarchyPackageDefinitionsVersion>
     <MicrosoftVisualStudioCodeAnalysisSdkUIVersion>15.8.27812-alpha</MicrosoftVisualStudioCodeAnalysisSdkUIVersion>
     <MicrosoftVisualStudioComponentModelHostVersion>$(VisualStudioEditorNewPackagesVersion)</MicrosoftVisualStudioComponentModelHostVersion>

From 940a7ea96292890afc40a9b07af5c40f2e9dff9c 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: Thu, 13 Jan 2022 13:24:46 -0800
Subject: [PATCH 345/444] Add VSTypeScriptFormattingService to external access
 (#58817)

* Add VSTypeScriptFormattingService to external access

* Exclude TypeScript language services from the code style layer

Fixes #58841

Co-authored-by: Sam Harwell <Sam.Harwell@microsoft.com>
---
 .../Mef/CodeStyleHostLanguageServices.cs.cs   | 86 ++++++++++++++++---
 ...peScriptFormattingServiceImplementation.cs | 21 +++++
 .../VSTypeScriptFormattingService.cs          | 38 ++++++++
 .../Formatting/AbstractFormattingService.cs   |  2 +-
 .../Core/Portable/Formatting/Formatter.cs     | 12 ++-
 .../Portable/Formatting/IFormattingService.cs |  6 +-
 6 files changed, 145 insertions(+), 20 deletions(-)
 create mode 100644 src/Features/Core/Portable/ExternalAccess/VSTypeScript/Api/IVSTypeScriptFormattingServiceImplementation.cs
 create mode 100644 src/Features/Core/Portable/ExternalAccess/VSTypeScript/VSTypeScriptFormattingService.cs

diff --git a/src/CodeStyle/Core/CodeFixes/Host/Mef/CodeStyleHostLanguageServices.cs.cs b/src/CodeStyle/Core/CodeFixes/Host/Mef/CodeStyleHostLanguageServices.cs.cs
index 9c77274388f71..fc8555e468e05 100644
--- a/src/CodeStyle/Core/CodeFixes/Host/Mef/CodeStyleHostLanguageServices.cs.cs
+++ b/src/CodeStyle/Core/CodeFixes/Host/Mef/CodeStyleHostLanguageServices.cs.cs
@@ -2,17 +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.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.Composition;
+using System.Composition.Convention;
 using System.Composition.Hosting;
 using System.Linq;
 using System.Reflection;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.PooledObjects;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Host
 {
@@ -28,7 +27,7 @@ private MefHostExportProvider(CompositionHost compositionContext)
             public static MefHostExportProvider Create(string languageName)
             {
                 var assemblies = CreateAssemblies(languageName);
-                var compositionConfiguration = new ContainerConfiguration().WithAssemblies(assemblies);
+                var compositionConfiguration = new ContainerConfiguration().WithAssemblies(assemblies, CodeStyleAttributedModelProvider.Instance);
                 return new MefHostExportProvider(compositionConfiguration.CreateContainer());
             }
 
@@ -56,16 +55,79 @@ IEnumerable<Lazy<TExtension>> IMefHostExportProvider.GetExports<TExtension>()
                 => _compositionContext.GetExports<TExtension>().Select(e => new Lazy<TExtension>(() => e));
 
             IEnumerable<Lazy<TExtension, TMetadata>> IMefHostExportProvider.GetExports<TExtension, TMetadata>()
-            {
-                var importer = new WithMetadataImporter<TExtension, TMetadata>();
-                _compositionContext.SatisfyImports(importer);
-                return importer.Exports;
-            }
+                => _compositionContext.GetExports<Lazy<TExtension, TMetadata>>();
 
-            private class WithMetadataImporter<TExtension, TMetadata>
+            /// <summary>
+            /// Custom implementation of <see cref="AttributedModelProvider"/> which excludes MEF parts intended for
+            /// languages not supported by the code style layer (only C# and Visual Basic are supported here). This is a
+            /// workaround for the fact that MEF 2 does not silently reject MEF parts with missing required imports,
+            /// which differs from MEF 1 and VS-MEF which are used elsewhere in the product.
+            /// </summary>
+            /// <seealso href="https://github.com/dotnet/roslyn/issues/58841"/>
+            private sealed class CodeStyleAttributedModelProvider : AttributedModelProvider
             {
-                [ImportMany]
-                public IEnumerable<Lazy<TExtension, TMetadata>> Exports { get; set; }
+                public static readonly CodeStyleAttributedModelProvider Instance = new();
+
+                public override IEnumerable<Attribute> GetCustomAttributes(Type reflectedType, MemberInfo member)
+                {
+                    _ = reflectedType ?? throw new ArgumentNullException(nameof(reflectedType));
+                    _ = member ?? throw new ArgumentNullException(nameof(member));
+
+                    if (member is not System.Reflection.TypeInfo && (object)member.DeclaringType != reflectedType)
+                        return Array.Empty<Attribute>();
+
+                    return FilterCustomAttributes(CustomAttributeExtensions.GetCustomAttributes(member, inherit: false));
+                }
+
+                public override IEnumerable<Attribute> GetCustomAttributes(Type reflectedType, ParameterInfo parameter)
+                {
+                    _ = reflectedType ?? throw new ArgumentNullException(nameof(reflectedType));
+                    _ = parameter ?? throw new ArgumentNullException(nameof(parameter));
+
+                    return FilterCustomAttributes(CustomAttributeExtensions.GetCustomAttributes(parameter, inherit: false));
+                }
+
+                private static IEnumerable<Attribute> FilterCustomAttributes(IEnumerable<Attribute> attributes)
+                {
+                    var inputArray = attributes.AsArray();
+                    List<Attribute>? outputArray = null;
+                    for (var i = 0; i < inputArray.Length; i++)
+                    {
+                        if (IsExcluded(inputArray[i]))
+                        {
+                            if (outputArray is null)
+                            {
+                                if (i == 0 && inputArray.Length == 1)
+                                {
+                                    return Array.Empty<Attribute>();
+                                }
+
+                                outputArray = new List<Attribute>(inputArray.Length - 1);
+                                for (var j = 0; j < i; j++)
+                                {
+                                    outputArray.Add(inputArray[i]);
+                                }
+                            }
+
+                            // Don't add the current item to the output array
+                            continue;
+                        }
+
+                        outputArray?.Add(inputArray[i]);
+                    }
+
+                    return outputArray?.ToArray() ?? inputArray;
+
+                    static bool IsExcluded(Attribute attribute)
+                    {
+                        // Exclude language service exports that don't apply to C# or Visual Basic
+                        if (attribute is ExportLanguageServiceAttribute { Language: not (LanguageNames.CSharp or LanguageNames.VisualBasic) })
+                            return true;
+
+                        // Include this attribute
+                        return false;
+                    }
+                }
             }
         }
     }
diff --git a/src/Features/Core/Portable/ExternalAccess/VSTypeScript/Api/IVSTypeScriptFormattingServiceImplementation.cs b/src/Features/Core/Portable/ExternalAccess/VSTypeScript/Api/IVSTypeScriptFormattingServiceImplementation.cs
new file mode 100644
index 0000000000000..4564645390534
--- /dev/null
+++ b/src/Features/Core/Portable/ExternalAccess/VSTypeScript/Api/IVSTypeScriptFormattingServiceImplementation.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.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.VSTypeScript.Api
+{
+    internal readonly record struct VSTypeScriptIndentationOptions(
+        bool UseSpaces,
+        int TabSize,
+        int IndentSize);
+
+    internal interface IVSTypeScriptFormattingServiceImplementation
+    {
+        Task<Document> FormatAsync(Document document, IEnumerable<TextSpan>? spans, VSTypeScriptIndentationOptions options, CancellationToken cancellationToken);
+    }
+}
diff --git a/src/Features/Core/Portable/ExternalAccess/VSTypeScript/VSTypeScriptFormattingService.cs b/src/Features/Core/Portable/ExternalAccess/VSTypeScript/VSTypeScriptFormattingService.cs
new file mode 100644
index 0000000000000..97849af74d3b9
--- /dev/null
+++ b/src/Features/Core/Portable/ExternalAccess/VSTypeScript/VSTypeScriptFormattingService.cs
@@ -0,0 +1,38 @@
+// 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.Composition;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.ExternalAccess.VSTypeScript.Api;
+using Microsoft.CodeAnalysis.Formatting;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.VSTypeScript
+{
+    [ExportLanguageService(typeof(IFormattingService), InternalLanguageNames.TypeScript), Shared]
+    internal sealed class VSTypeScriptFormattingService : IFormattingService
+    {
+        private readonly IVSTypeScriptFormattingServiceImplementation _impl;
+
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public VSTypeScriptFormattingService(IVSTypeScriptFormattingServiceImplementation impl)
+            => _impl = impl;
+
+        public Task<Document> FormatAsync(Document document, IEnumerable<TextSpan>? spans, OptionSet options, CancellationToken cancellationToken)
+        {
+            var tsOptions = new VSTypeScriptIndentationOptions(
+                UseSpaces: !options.GetOption(FormattingOptions.UseTabs, InternalLanguageNames.TypeScript),
+                TabSize: options.GetOption(FormattingOptions.TabSize, InternalLanguageNames.TypeScript),
+                IndentSize: options.GetOption(FormattingOptions.IndentationSize, InternalLanguageNames.TypeScript));
+
+            return _impl.FormatAsync(document, spans, tsOptions, cancellationToken);
+        }
+    }
+}
diff --git a/src/Workspaces/Core/Portable/Formatting/AbstractFormattingService.cs b/src/Workspaces/Core/Portable/Formatting/AbstractFormattingService.cs
index deef1a8571eca..f1968be47a0e8 100644
--- a/src/Workspaces/Core/Portable/Formatting/AbstractFormattingService.cs
+++ b/src/Workspaces/Core/Portable/Formatting/AbstractFormattingService.cs
@@ -15,7 +15,7 @@ namespace Microsoft.CodeAnalysis.Formatting
     /// </summary>
     internal abstract class AbstractFormattingService : IFormattingService
     {
-        public Task<Document> FormatAsync(Document document, IEnumerable<TextSpan>? spans, OptionSet? options, CancellationToken cancellationToken)
+        public Task<Document> FormatAsync(Document document, IEnumerable<TextSpan>? spans, OptionSet options, CancellationToken cancellationToken)
             => Formatter.FormatAsync(document, spans, options, rules: null, cancellationToken: cancellationToken);
     }
 }
diff --git a/src/Workspaces/Core/Portable/Formatting/Formatter.cs b/src/Workspaces/Core/Portable/Formatting/Formatter.cs
index 45e503cbc6d46..55b488c8b56a5 100644
--- a/src/Workspaces/Core/Portable/Formatting/Formatter.cs
+++ b/src/Workspaces/Core/Portable/Formatting/Formatter.cs
@@ -102,12 +102,16 @@ public static Task<Document> FormatAsync(Document document, TextSpan span, Optio
         /// <param name="options">An optional set of formatting options. If these options are not supplied the current set of options from the document's workspace will be used.</param>
         /// <param name="cancellationToken">An optional cancellation token.</param>
         /// <returns>The formatted document.</returns>
-        public static Task<Document> FormatAsync(Document document, IEnumerable<TextSpan>? spans, OptionSet? options = null, CancellationToken cancellationToken = default)
+        public static async Task<Document> FormatAsync(Document document, IEnumerable<TextSpan>? spans, OptionSet? options = null, CancellationToken cancellationToken = default)
         {
             var formattingService = document.GetLanguageService<IFormattingService>();
-            return formattingService == null
-                ? SpecializedTasks.FromResult(document)
-                : formattingService.FormatAsync(document, spans, options, cancellationToken);
+            if (formattingService == null)
+            {
+                return document;
+            }
+
+            options ??= await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
+            return await formattingService.FormatAsync(document, spans, options, cancellationToken).ConfigureAwait(false);
         }
 
         internal static async Task<Document> FormatAsync(Document document, IEnumerable<TextSpan>? spans, OptionSet? options, IEnumerable<AbstractFormattingRule>? rules, CancellationToken cancellationToken)
diff --git a/src/Workspaces/Core/Portable/Formatting/IFormattingService.cs b/src/Workspaces/Core/Portable/Formatting/IFormattingService.cs
index d70f1c400ffe5..0136a47b46824 100644
--- a/src/Workspaces/Core/Portable/Formatting/IFormattingService.cs
+++ b/src/Workspaces/Core/Portable/Formatting/IFormattingService.cs
@@ -18,9 +18,9 @@ internal interface IFormattingService : ILanguageService
         /// </summary>
         /// <param name="document">The document to format.</param>
         /// <param name="spans">The spans of the document's text to format. If null, the entire document should be formatted.</param>
-        /// <param name="options">An optional set of formatting options. If these options are not supplied the current set of options from the document's workspace will be used.</param>
-        /// <param name="cancellationToken">An optional cancellation token.</param>
+        /// <param name="options">Set of formatting options.</param>
+        /// <param name="cancellationToken">Cancellation token.</param>
         /// <returns>The formatted document.</returns>
-        Task<Document> FormatAsync(Document document, IEnumerable<TextSpan>? spans, OptionSet? options, CancellationToken cancellationToken);
+        Task<Document> FormatAsync(Document document, IEnumerable<TextSpan>? spans, OptionSet options, CancellationToken cancellationToken);
     }
 }

From 5d9a1d9bd9255c14dd122e67987264369097efa9 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Thu, 13 Jan 2022 14:20:40 -0800
Subject: [PATCH 346/444] Allow configurable behavior

---
 .../RefactoringHelpersTests.cs                | 62 +++++++++++++++-
 .../RefactoringHelpersTestBase.cs             | 19 +++--
 .../AbstractRefactoringHelpersService.cs      | 74 ++++++++++++-------
 .../CodeRefactoringContextExtensions.cs       | 41 +++++-----
 .../IRefactoringHelpersService.cs             | 14 +++-
 ...seNamedArgumentsCodeRefactoringProvider.cs |  5 +-
 6 files changed, 156 insertions(+), 59 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/RefactoringHelpers/RefactoringHelpersTests.cs b/src/EditorFeatures/CSharpTest/RefactoringHelpers/RefactoringHelpersTests.cs
index a583e38874a3f..e065307d0b7d3 100644
--- a/src/EditorFeatures/CSharpTest/RefactoringHelpers/RefactoringHelpersTests.cs
+++ b/src/EditorFeatures/CSharpTest/RefactoringHelpers/RefactoringHelpersTests.cs
@@ -323,7 +323,26 @@ C LocalFunction(C c)
 
         [Fact]
         [WorkItem(35525, "https://github.com/dotnet/roslyn/issues/35525")]
-        public async Task TestInEmptySyntaxNode()
+        public async Task TestInEmptySyntaxNode_AllowEmptyNodesTrue1()
+        {
+            var testText = @"
+class C
+{
+    void M()
+    {
+        N(0, [||]{|result:|}); 
+    }
+
+    int N(int a, int b, int c)
+    {
+    }
+}";
+            await TestAsync<ArgumentSyntax>(testText, allowEmptyNodes: true);
+        }
+
+        [Fact]
+        [WorkItem(35525, "https://github.com/dotnet/roslyn/issues/35525")]
+        public async Task TestInEmptySyntaxNode_AllowEmptyNodesTrue2()
         {
             var testText = @"
 class C
@@ -337,8 +356,47 @@ int N(int a, int b, int c)
     {
     }
 }";
-            await TestAsync<ArgumentSyntax>(testText);
+            await TestAsync<ArgumentSyntax>(testText, allowEmptyNodes: true);
+        }
+
+        [Fact]
+        [WorkItem(35525, "https://github.com/dotnet/roslyn/issues/35525")]
+        public async Task TestInEmptySyntaxNode_AllowEmptyNodesFalse1()
+        {
+            var testText = @"
+class C
+{
+    void M()
+    {
+        N(0, [||], 0)); 
+    }
+
+    int N(int a, int b, int c)
+    {
+    }
+}";
+            await TestMissingAsync<ArgumentSyntax>(testText, allowEmptyNodes: false);
         }
+
+        [Fact]
+        [WorkItem(35525, "https://github.com/dotnet/roslyn/issues/35525")]
+        public async Task TestInEmptySyntaxNode_AllowEmptyNodesFalse2()
+        {
+            var testText = @"
+class C
+{
+    void M()
+    {
+        N(0, {|result:N(0, [||], 0)|}); 
+    }
+
+    int N(int a, int b, int c)
+    {
+    }
+}";
+            await TestAsync<ArgumentSyntax>(testText, allowEmptyNodes: false);
+        }
+
         #endregion
 
         #region Selections
diff --git a/src/EditorFeatures/TestUtilities/RefactoringHelpers/RefactoringHelpersTestBase.cs b/src/EditorFeatures/TestUtilities/RefactoringHelpers/RefactoringHelpersTestBase.cs
index a4da85d5e80a7..773257df73479 100644
--- a/src/EditorFeatures/TestUtilities/RefactoringHelpers/RefactoringHelpersTestBase.cs
+++ b/src/EditorFeatures/TestUtilities/RefactoringHelpers/RefactoringHelpersTestBase.cs
@@ -29,12 +29,13 @@ public abstract class RefactoringHelpersTestBase<TWorkspaceFixture> : TestBase
         private protected ReferenceCountedDisposable<TWorkspaceFixture> GetOrCreateWorkspaceFixture()
             => _fixtureHelper.GetOrCreateFixture();
 
-        protected Task TestAsync<TNode>(string text) where TNode : SyntaxNode => TestAsync<TNode>(text, Functions<TNode>.True);
+        protected Task TestAsync<TNode>(string text, bool allowEmptyNodes = false) where TNode : SyntaxNode
+            => TestAsync(text, Functions<TNode>.True, allowEmptyNodes);
 
-        protected async Task TestAsync<TNode>(string text, Func<TNode, bool> predicate) where TNode : SyntaxNode
+        protected async Task TestAsync<TNode>(string text, Func<TNode, bool> predicate, bool allowEmptyNodes = false) where TNode : SyntaxNode
         {
             text = GetSelectionAndResultSpans(text, out var selection, out var result);
-            var resultNode = await GetNodeForSelectionAsync<TNode>(text, selection, predicate).ConfigureAwait(false);
+            var resultNode = await GetNodeForSelectionAsync(text, selection, predicate, allowEmptyNodes).ConfigureAwait(false);
 
             Assert.NotNull(resultNode);
             Assert.Equal(result, resultNode.Span);
@@ -58,12 +59,14 @@ protected async Task TestNotUnderselectedAsync<TNode>(string text) where TNode :
             Assert.False(CodeRefactoringHelpers.IsNodeUnderselected(resultNode, selection));
         }
 
-        protected Task TestMissingAsync<TNode>(string text) where TNode : SyntaxNode => TestMissingAsync<TNode>(text, Functions<TNode>.True);
-        protected async Task TestMissingAsync<TNode>(string text, Func<TNode, bool> predicate) where TNode : SyntaxNode
+        protected Task TestMissingAsync<TNode>(string text, bool allowEmptyNodes = false) where TNode : SyntaxNode
+            => TestMissingAsync(text, Functions<TNode>.True, allowEmptyNodes);
+
+        protected async Task TestMissingAsync<TNode>(string text, Func<TNode, bool> predicate, bool allowEmptyNodes = false) where TNode : SyntaxNode
         {
             text = GetSelectionSpan(text, out var selection);
 
-            var resultNode = await GetNodeForSelectionAsync<TNode>(text, selection, predicate).ConfigureAwait(false);
+            var resultNode = await GetNodeForSelectionAsync<TNode>(text, selection, predicate, allowEmptyNodes).ConfigureAwait(false);
             Assert.Null(resultNode);
         }
 
@@ -98,12 +101,12 @@ private static string GetSelectionAndResultSpans(string text, out TextSpan selec
             return text;
         }
 
-        private async Task<TNode> GetNodeForSelectionAsync<TNode>(string text, TextSpan selection, Func<TNode, bool> predicate) where TNode : SyntaxNode
+        private async Task<TNode> GetNodeForSelectionAsync<TNode>(string text, TextSpan selection, Func<TNode, bool> predicate, bool allowEmptyNodes = false) where TNode : SyntaxNode
         {
             using var workspaceFixture = GetOrCreateWorkspaceFixture();
 
             var document = workspaceFixture.Target.UpdateDocument(text, SourceCodeKind.Regular);
-            var relevantNodes = await document.GetRelevantNodesAsync<TNode>(selection, CancellationToken.None).ConfigureAwait(false);
+            var relevantNodes = await document.GetRelevantNodesAsync<TNode>(selection, allowEmptyNodes, CancellationToken.None).ConfigureAwait(false);
 
             return relevantNodes.FirstOrDefault(predicate);
         }
diff --git a/src/Features/Core/Portable/CodeRefactorings/AbstractRefactoringHelpersService.cs b/src/Features/Core/Portable/CodeRefactorings/AbstractRefactoringHelpersService.cs
index 5e7c26b0936bc..63e32dbb7ac74 100644
--- a/src/Features/Core/Portable/CodeRefactorings/AbstractRefactoringHelpersService.cs
+++ b/src/Features/Core/Portable/CodeRefactorings/AbstractRefactoringHelpersService.cs
@@ -26,8 +26,26 @@ internal abstract class AbstractRefactoringHelpersService<TExpressionSyntax, TAr
         public abstract bool IsBetweenTypeMembers(SourceText sourceText, SyntaxNode root, int position, [NotNullWhen(true)] out SyntaxNode? typeDeclaration);
 
         public async Task<ImmutableArray<TSyntaxNode>> GetRelevantNodesAsync<TSyntaxNode>(
-            Document document, TextSpan selectionRaw,
-            CancellationToken cancellationToken) where TSyntaxNode : SyntaxNode
+            Document document, TextSpan selectionRaw, bool allowEmptyNodes, CancellationToken cancellationToken) where TSyntaxNode : SyntaxNode
+        {
+            using var _1 = ArrayBuilder<TSyntaxNode>.GetInstance(out var relevantNodesBuilder);
+            await AddRelevantNodesAsync<TSyntaxNode>(document, selectionRaw, relevantNodesBuilder, cancellationToken).ConfigureAwait(false);
+
+            if (allowEmptyNodes)
+                return relevantNodesBuilder.ToImmutable();
+
+            using var _2 = ArrayBuilder<TSyntaxNode>.GetInstance(out var nonEmptyNodes);
+            foreach (var node in relevantNodesBuilder)
+            {
+                if (node.Span.Length > 0)
+                    nonEmptyNodes.Add(node);
+            }
+
+            return nonEmptyNodes.ToImmutable();
+        }
+
+        private async Task AddRelevantNodesAsync<TSyntaxNode>(
+            Document document, TextSpan selectionRaw, ArrayBuilder<TSyntaxNode> relevantNodesBuilder, CancellationToken cancellationToken) where TSyntaxNode : SyntaxNode
         {
             // Given selection is trimmed first to enable over-selection that spans multiple lines. Since trailing whitespace ends
             // at newline boundary over-selection to e.g. a line after LocalFunctionStatement would cause FindNode to find enclosing
@@ -46,11 +64,7 @@ public async Task<ImmutableArray<TSyntaxNode>> GetRelevantNodesAsync<TSyntaxNode
             // Option 1) can't be used all the time and 2) can be confusing for users. Therefore bailing out is the
             // most consistent option.
             if (selectionTrimmed.IsEmpty && !selectionRaw.IsEmpty)
-            {
-                return ImmutableArray<TSyntaxNode>.Empty;
-            }
-
-            using var relevantNodesBuilderDisposer = ArrayBuilder<TSyntaxNode>.GetInstance(out var relevantNodesBuilder);
+                return;
 
             // Every time a Node is considered an extractNodes method is called to add all nodes around the original one
             // that should also be considered.
@@ -120,8 +134,6 @@ public async Task<ImmutableArray<TSyntaxNode>> GetRelevantNodesAsync<TSyntaxNode
                     await AddNodesDeepInAsync(document, location, relevantNodesBuilder, cancellationToken).ConfigureAwait(false);
                 }
             }
-
-            return relevantNodesBuilder.ToImmutable();
         }
 
         private static bool IsWantedTypeExpressionLike<TSyntaxNode>() where TSyntaxNode : SyntaxNode
@@ -226,7 +238,12 @@ static bool IsAcceptableLineDistanceAway(
             }
         }
 
-        private void AddNodesForTokenToLeft<TSyntaxNode>(ISyntaxFactsService syntaxFacts, ArrayBuilder<TSyntaxNode> relevantNodesBuilder, int location, SyntaxToken tokenToLeft, CancellationToken cancellationToken) where TSyntaxNode : SyntaxNode
+        private void AddNodesForTokenToLeft<TSyntaxNode>(
+            ISyntaxFactsService syntaxFacts,
+            ArrayBuilder<TSyntaxNode> relevantNodesBuilder,
+            int location,
+            SyntaxToken tokenToLeft,
+            CancellationToken cancellationToken) where TSyntaxNode : SyntaxNode
         {
             // there could be multiple (n) tokens to the left if first n-1 are Empty -> iterate over all of them
             while (tokenToLeft != default)
@@ -253,7 +270,13 @@ private void AddNodesForTokenToLeft<TSyntaxNode>(ISyntaxFactsService syntaxFacts
             }
         }
 
-        private void AddNodesForTokenToRightOrIn<TSyntaxNode>(ISyntaxFactsService syntaxFacts, SyntaxNode root, ArrayBuilder<TSyntaxNode> relevantNodesBuilder, int location, SyntaxToken tokenToRightOrIn, CancellationToken cancellationToken) where TSyntaxNode : SyntaxNode
+        private void AddNodesForTokenToRightOrIn<TSyntaxNode>(
+            ISyntaxFactsService syntaxFacts,
+            SyntaxNode root,
+            ArrayBuilder<TSyntaxNode> relevantNodesBuilder,
+            int location,
+            SyntaxToken tokenToRightOrIn,
+            CancellationToken cancellationToken) where TSyntaxNode : SyntaxNode
         {
             if (tokenToRightOrIn != default)
             {
@@ -291,7 +314,12 @@ private void AddNodesForTokenToRightOrIn<TSyntaxNode>(ISyntaxFactsService syntax
             }
         }
 
-        private void AddRelevantNodesForSelection<TSyntaxNode>(ISyntaxFactsService syntaxFacts, SyntaxNode root, TextSpan selectionTrimmed, ArrayBuilder<TSyntaxNode> relevantNodesBuilder, CancellationToken cancellationToken) where TSyntaxNode : SyntaxNode
+        private void AddRelevantNodesForSelection<TSyntaxNode>(
+            ISyntaxFactsService syntaxFacts,
+            SyntaxNode root,
+            TextSpan selectionTrimmed,
+            ArrayBuilder<TSyntaxNode> relevantNodesBuilder,
+            CancellationToken cancellationToken) where TSyntaxNode : SyntaxNode
         {
             var selectionNode = root.FindNode(selectionTrimmed, getInnermostNodeForTie: true);
             var prevNode = selectionNode;
@@ -311,7 +339,7 @@ private void AddRelevantNodesForSelection<TSyntaxNode>(ISyntaxFactsService synta
                         break;
                     }
 
-                    AddIfNotMissing(relevantNodesBuilder, nonHiddenExtractedNode);
+                    relevantNodesBuilder.Add(nonHiddenExtractedNode);
                 }
 
                 prevNode = selectionNode;
@@ -320,13 +348,6 @@ private void AddRelevantNodesForSelection<TSyntaxNode>(ISyntaxFactsService synta
             while (selectionNode != null && prevNode.FullWidth() == selectionNode.FullWidth());
         }
 
-        private static void AddIfNotMissing<TSyntaxNode>(
-            ArrayBuilder<TSyntaxNode> relevantNodesBuilder, TSyntaxNode node) where TSyntaxNode : SyntaxNode
-        {
-            if (node.Span.Length > 0)
-                relevantNodesBuilder.Add(node);
-        }
-
         /// <summary>
         /// Extractor function that retrieves all nodes that should be considered for extraction of given current node. 
         /// <para>
@@ -459,7 +480,8 @@ protected virtual IEnumerable<SyntaxNode> ExtractNodesInHeader(SyntaxNode root,
         }
 
         protected virtual async Task AddNodesDeepInAsync<TSyntaxNode>(
-            Document document, int position,
+            Document document,
+            int position,
             ArrayBuilder<TSyntaxNode> relevantNodesBuilder,
             CancellationToken cancellationToken) where TSyntaxNode : SyntaxNode
         {
@@ -486,7 +508,7 @@ protected virtual async Task AddNodesDeepInAsync<TSyntaxNode>(
 
                     if (argumentStartLine == caretLine && !correctTypeNode.OverlapsHiddenPosition(cancellationToken))
                     {
-                        AddIfNotMissing(relevantNodesBuilder, correctTypeNode);
+                        relevantNodesBuilder.Add(correctTypeNode);
                     }
                     else if (argumentStartLine < caretLine)
                     {
@@ -499,14 +521,12 @@ protected virtual async Task AddNodesDeepInAsync<TSyntaxNode>(
             }
         }
 
-        private static void AddNonHiddenCorrectTypeNodes<TSyntaxNode>(IEnumerable<SyntaxNode> nodes, ArrayBuilder<TSyntaxNode> resultBuilder, CancellationToken cancellationToken)
-            where TSyntaxNode : SyntaxNode
+        private static void AddNonHiddenCorrectTypeNodes<TSyntaxNode>(
+            IEnumerable<SyntaxNode> nodes, ArrayBuilder<TSyntaxNode> resultBuilder, CancellationToken cancellationToken) where TSyntaxNode : SyntaxNode
         {
             var correctTypeNonHiddenNodes = nodes.OfType<TSyntaxNode>().Where(n => !n.OverlapsHiddenPosition(cancellationToken));
             foreach (var nodeToBeAdded in correctTypeNonHiddenNodes)
-            {
-                AddIfNotMissing(resultBuilder, nodeToBeAdded);
-            }
+                resultBuilder.Add(nodeToBeAdded);
         }
 
         public bool IsOnTypeHeader(SyntaxNode root, int position, bool fullHeader, [NotNullWhen(true)] out SyntaxNode? typeDeclaration)
diff --git a/src/Features/Core/Portable/CodeRefactorings/CodeRefactoringContextExtensions.cs b/src/Features/Core/Portable/CodeRefactorings/CodeRefactoringContextExtensions.cs
index aab79cb1b7829..5d9d1afd2bfa9 100644
--- a/src/Features/Core/Portable/CodeRefactorings/CodeRefactoringContextExtensions.cs
+++ b/src/Features/Core/Portable/CodeRefactorings/CodeRefactoringContextExtensions.cs
@@ -18,7 +18,7 @@ internal static class CodeRefactoringContextExtensions
         /// <summary>
         /// Use this helper to register multiple refactorings (<paramref name="actions"/>).
         /// </summary>
-        internal static void RegisterRefactorings<TCodeAction>(
+        public static void RegisterRefactorings<TCodeAction>(
             this CodeRefactoringContext context, ImmutableArray<TCodeAction> actions, TextSpan? applicableToSpan = null)
             where TCodeAction : CodeAction
         {
@@ -38,31 +38,36 @@ internal static void RegisterRefactorings<TCodeAction>(
             }
         }
 
-        internal static Task<TSyntaxNode?> TryGetRelevantNodeAsync<TSyntaxNode>(this CodeRefactoringContext context)
-            where TSyntaxNode : SyntaxNode
-            => TryGetRelevantNodeAsync<TSyntaxNode>(context.Document, context.Span, context.CancellationToken);
+        public static Task<TSyntaxNode?> TryGetRelevantNodeAsync<TSyntaxNode>(this CodeRefactoringContext context) where TSyntaxNode : SyntaxNode
+            => TryGetRelevantNodeAsync<TSyntaxNode>(context, allowEmptyNode: false);
 
-        internal static Task<ImmutableArray<TSyntaxNode>> GetRelevantNodesAsync<TSyntaxNode>(this CodeRefactoringContext context)
-            where TSyntaxNode : SyntaxNode
-            => GetRelevantNodesAsync<TSyntaxNode>(context.Document, context.Span, context.CancellationToken);
+        public static Task<TSyntaxNode?> TryGetRelevantNodeAsync<TSyntaxNode>(this CodeRefactoringContext context, bool allowEmptyNode) where TSyntaxNode : SyntaxNode
+            => TryGetRelevantNodeAsync<TSyntaxNode>(context.Document, context.Span, allowEmptyNode, context.CancellationToken);
 
-        internal static async Task<TSyntaxNode?> TryGetRelevantNodeAsync<TSyntaxNode>(
-            this Document document,
-            TextSpan span,
-            CancellationToken cancellationToken)
-            where TSyntaxNode : SyntaxNode
+        public static Task<ImmutableArray<TSyntaxNode>> GetRelevantNodesAsync<TSyntaxNode>(this CodeRefactoringContext context) where TSyntaxNode : SyntaxNode
+            => GetRelevantNodesAsync<TSyntaxNode>(context, allowEmptyNodes: false);
+
+        public static Task<ImmutableArray<TSyntaxNode>> GetRelevantNodesAsync<TSyntaxNode>(this CodeRefactoringContext context, bool allowEmptyNodes) where TSyntaxNode : SyntaxNode
+            => GetRelevantNodesAsync<TSyntaxNode>(context.Document, context.Span, allowEmptyNodes, context.CancellationToken);
+
+        public static Task<TSyntaxNode?> TryGetRelevantNodeAsync<TSyntaxNode>(this Document document, TextSpan span, CancellationToken cancellationToken) where TSyntaxNode : SyntaxNode
+            => TryGetRelevantNodeAsync<TSyntaxNode>(document, span, allowEmptyNode: false, cancellationToken);
+
+        public static async Task<TSyntaxNode?> TryGetRelevantNodeAsync<TSyntaxNode>(this Document document, TextSpan span, bool allowEmptyNode, CancellationToken cancellationToken) where TSyntaxNode : SyntaxNode
         {
-            var potentialNodes = await GetRelevantNodesAsync<TSyntaxNode>(document, span, cancellationToken).ConfigureAwait(false);
+            var potentialNodes = await GetRelevantNodesAsync<TSyntaxNode>(document, span, allowEmptyNode, cancellationToken).ConfigureAwait(false);
             return potentialNodes.FirstOrDefault();
         }
 
-        internal static Task<ImmutableArray<TSyntaxNode>> GetRelevantNodesAsync<TSyntaxNode>(
-            this Document document,
-            TextSpan span,
-            CancellationToken cancellationToken) where TSyntaxNode : SyntaxNode
+        public static Task<ImmutableArray<TSyntaxNode>> GetRelevantNodesAsync<TSyntaxNode>(
+            this Document document, TextSpan span, CancellationToken cancellationToken) where TSyntaxNode : SyntaxNode
+            => GetRelevantNodesAsync<TSyntaxNode>(document, span, allowEmptyNodes: false, cancellationToken);
+
+        public static Task<ImmutableArray<TSyntaxNode>> GetRelevantNodesAsync<TSyntaxNode>(
+            this Document document, TextSpan span, bool allowEmptyNodes, CancellationToken cancellationToken) where TSyntaxNode : SyntaxNode
         {
             var helpers = document.GetRequiredLanguageService<IRefactoringHelpersService>();
-            return helpers.GetRelevantNodesAsync<TSyntaxNode>(document, span, cancellationToken);
+            return helpers.GetRelevantNodesAsync<TSyntaxNode>(document, span, allowEmptyNodes, cancellationToken);
         }
     }
 }
diff --git a/src/Features/Core/Portable/CodeRefactorings/IRefactoringHelpersService.cs b/src/Features/Core/Portable/CodeRefactorings/IRefactoringHelpersService.cs
index 69eb4ede0fde1..d9317ebd1a832 100644
--- a/src/Features/Core/Portable/CodeRefactorings/IRefactoringHelpersService.cs
+++ b/src/Features/Core/Portable/CodeRefactorings/IRefactoringHelpersService.cs
@@ -27,7 +27,8 @@ internal interface IRefactoringHelpersService : IHeaderFactsService, ILanguageSe
         /// <summary>
         /// <para>
         /// Returns an array of <typeparamref name="TSyntaxNode"/> instances for refactoring given specified selection
-        /// in document. The nodes returned will all have non-empty spans.
+        /// in document. <paramref name="allowEmptyNodes"/> determines if the returned nodes will can have empty spans
+        /// or not.
         /// </para>
         /// <para>
         /// A <typeparamref name="TSyntaxNode"/> instance is returned if: - Selection is zero-width and inside/touching
@@ -52,6 +53,15 @@ internal interface IRefactoringHelpersService : IHeaderFactsService, ILanguageSe
         /// handled correctly. 
         /// </para>
         /// </summary>
-        Task<ImmutableArray<TSyntaxNode>> GetRelevantNodesAsync<TSyntaxNode>(Document document, TextSpan selection, CancellationToken cancellationToken) where TSyntaxNode : SyntaxNode;
+        Task<ImmutableArray<TSyntaxNode>> GetRelevantNodesAsync<TSyntaxNode>(Document document, TextSpan selection, bool allowEmptyNodes, CancellationToken cancellationToken) where TSyntaxNode : SyntaxNode;
+    }
+
+    internal static class IRefactoringHelpersServiceExtensions
+    {
+        public static Task<ImmutableArray<TSyntaxNode>> GetRelevantNodesAsync<TSyntaxNode>(
+            this IRefactoringHelpersService service, Document document, TextSpan selection, CancellationToken cancellationToken) where TSyntaxNode : SyntaxNode
+        {
+            return service.GetRelevantNodesAsync<TSyntaxNode>(document, selection, allowEmptyNodes: false, cancellationToken);
+        }
     }
 }
diff --git a/src/Features/Core/Portable/UseNamedArguments/AbstractUseNamedArgumentsCodeRefactoringProvider.cs b/src/Features/Core/Portable/UseNamedArguments/AbstractUseNamedArgumentsCodeRefactoringProvider.cs
index d00ebc9956317..3a8125dc5b72e 100644
--- a/src/Features/Core/Portable/UseNamedArguments/AbstractUseNamedArgumentsCodeRefactoringProvider.cs
+++ b/src/Features/Core/Portable/UseNamedArguments/AbstractUseNamedArgumentsCodeRefactoringProvider.cs
@@ -31,8 +31,9 @@ public async Task ComputeRefactoringsAsync(
             {
                 var (document, textSpan, cancellationToken) = context;
 
-                var potentialArguments = await document.GetRelevantNodesAsync<TBaseArgumentSyntax>(textSpan, cancellationToken).ConfigureAwait(false);
-                var argument = potentialArguments.FirstOrDefault(n => n?.Parent is TArgumentListSyntax) as TSimpleArgumentSyntax;
+                // We allow empty nodes here to find VB implicit arguments.
+                var potentialArguments = await document.GetRelevantNodesAsync<TBaseArgumentSyntax>(textSpan, allowEmptyNodes: true, cancellationToken).ConfigureAwait(false);
+                var argument = potentialArguments.FirstOrDefault(n => n.Parent is TArgumentListSyntax) as TSimpleArgumentSyntax;
                 if (argument == null)
                 {
                     return;

From c4e40c556ef42ca9e237a1799594e41f6c1ee326 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Thu, 13 Jan 2022 14:24:23 -0800
Subject: [PATCH 347/444] Improve tests for argument completion with semicolon
 insertion

Fixes a race condition where ordering of command handlers could lead to
broken functionality. CompleteStatementCommandHandler depends
SnippetCommandHandler to clear the active selection before attempting to
complete the statement.
---
 .../Impl/Snippets/SnippetCommandHandler.cs    |  4 +-
 .../CSharp/CSharpArgumentProvider.cs          | 39 ++++++++++++++++++-
 2 files changed, 40 insertions(+), 3 deletions(-)

diff --git a/src/VisualStudio/CSharp/Impl/Snippets/SnippetCommandHandler.cs b/src/VisualStudio/CSharp/Impl/Snippets/SnippetCommandHandler.cs
index d9437a82a9a0e..769da32ea385b 100644
--- a/src/VisualStudio/CSharp/Impl/Snippets/SnippetCommandHandler.cs
+++ b/src/VisualStudio/CSharp/Impl/Snippets/SnippetCommandHandler.cs
@@ -13,10 +13,11 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Completion;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
+using Microsoft.CodeAnalysis.Editor.CSharp.CompleteStatement;
 using Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.SignatureHelp;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
-using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.Commanding;
 using Microsoft.VisualStudio.Editor;
@@ -36,6 +37,7 @@ namespace Microsoft.VisualStudio.LanguageServices.CSharp.Snippets
     [Name("CSharp Snippets")]
     [Order(After = PredefinedCompletionNames.CompletionCommandHandler)]
     [Order(After = Microsoft.CodeAnalysis.Editor.PredefinedCommandHandlerNames.SignatureHelpAfterCompletion)]
+    [Order(Before = nameof(CompleteStatementCommandHandler))]
     [Order(Before = Microsoft.CodeAnalysis.Editor.PredefinedCommandHandlerNames.AutomaticLineEnder)]
     internal sealed class SnippetCommandHandler :
         AbstractSnippetCommandHandler,
diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpArgumentProvider.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpArgumentProvider.cs
index 9b4dfc3f556cc..2b564ed45203f 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpArgumentProvider.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpArgumentProvider.cs
@@ -322,11 +322,46 @@ public void Method()
             VisualStudio.Workspace.WaitForAllAsyncOperations(Helper.HangMitigatingTimeout, FeatureAttribute.SignatureHelp);
             VisualStudio.Editor.Verify.CurrentLineText("object.Equals(null$$)", assertCaretPosition: true);
 
+            VisualStudio.Editor.SendKeys(';');
+            VisualStudio.Editor.Verify.CurrentLineText("object.Equals(null);$$", assertCaretPosition: true);
+        }
+
+        /// <summary>
+        /// Argument completion with exactly one argument.
+        /// </summary>
+        [WpfFact]
+        public void SemicolonWithTabTabCompletion3()
+        {
+            SetUpEditor(@"
+public class Test
+{
+    private object f;
+
+    public void Method(int value)
+    {$$
+    }
+
+    public void Method2(int value)
+    {
+    }
+}
+");
+
+            VisualStudio.Editor.SendKeys(VirtualKey.Enter);
+            VisualStudio.Editor.SendKeys("this.M2");
+
             VisualStudio.Editor.SendKeys(VirtualKey.Tab);
-            VisualStudio.Editor.Verify.CurrentLineText("object.Equals(null)$$", assertCaretPosition: true);
+            VisualStudio.Editor.Verify.CurrentLineText("this.Method2$$", assertCaretPosition: true);
+
+            VisualStudio.Editor.SendKeys(VirtualKey.Tab);
+            VisualStudio.Workspace.WaitForAllAsyncOperations(Helper.HangMitigatingTimeout, FeatureAttribute.SignatureHelp);
+            VisualStudio.Editor.Verify.CurrentLineText("this.Method2(value$$)", assertCaretPosition: true);
+
+            VisualStudio.Editor.SendKeys(';');
+            VisualStudio.Editor.Verify.CurrentLineText("this.Method2(value);$$", assertCaretPosition: true);
         }
 
-        [WpfFact(Skip = "https://github.com/dotnet/roslyn/issues/56394")]
+        [WpfFact]
         public void SmartBreakLineWithTabTabCompletion1()
         {
             SetUpEditor(@"

From 0bbc3c26c90bbfa89bc607dd3e87f0b38537a103 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Thu, 13 Jan 2022 14:24:53 -0800
Subject: [PATCH 348/444] Enable test which is already passing

---
 .../IntegrationTests/CSharp/CSharpArgumentProvider.cs           | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpArgumentProvider.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpArgumentProvider.cs
index 2b564ed45203f..5030a176928d3 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpArgumentProvider.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpArgumentProvider.cs
@@ -400,7 +400,7 @@ public void Method()
 ", assertCaretPosition: true);
         }
 
-        [WpfFact(Skip = "https://github.com/dotnet/roslyn/issues/56394")]
+        [WpfFact]
         public void SmartBreakLineWithTabTabCompletion2()
         {
             SetUpEditor(@"

From f3013fd016808687b58067e0f12696d42d81d8ad Mon Sep 17 00:00:00 2001
From: Fred Silberberg <frsilb@microsoft.com>
Date: Thu, 13 Jan 2022 15:13:26 -0800
Subject: [PATCH 349/444] Revert "Revert "Implement GetTypesByMetadataName
 (#58366)" (#58784)" (#58813)

This reverts commit 2eab8221159ca23d2e07df16bdcc1987c59ad20c.
---
 .../Symbol/Compilation/CompilationAPITests.cs | 277 ++++++++++++++++++
 .../Core/Portable/Compilation/Compilation.cs  | 105 ++++++-
 .../Core/Portable/PublicAPI.Unshipped.txt     |   1 +
 .../Test/Symbol/CompilationAPITests.vb        | 226 ++++++++++++++
 .../Core/Extensions/CompilationExtensions.cs  |  51 ++--
 5 files changed, 625 insertions(+), 35 deletions(-)
 create mode 100644 src/Compilers/VisualBasic/Test/Symbol/CompilationAPITests.vb

diff --git a/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs b/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs
index d1a03c60f4a71..6e608104926e4 100644
--- a/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs
@@ -3036,5 +3036,282 @@ void M1()
         }
 
         #endregion
+
+        #region GetTypesByMetadataName Tests
+
+        [Fact]
+        public void GetTypesByMetadataName_NotInSourceNotInReferences()
+        {
+            var comp = CreateCompilation("");
+            comp.VerifyDiagnostics();
+
+            var types = comp.GetTypesByMetadataName("N.C`1");
+            Assert.Empty(types);
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void GetTypesByMetadataName_SingleInSourceNotInReferences(
+            bool useMetadataReference,
+            [CombinatorialValues("public", "internal")] string accessibility)
+        {
+            var referenceComp = CreateCompilation("");
+
+            var comp = CreateCompilation(
+$@"namespace N;
+{accessibility} class C<T> {{}}", new[] { useMetadataReference ? referenceComp.ToMetadataReference() : referenceComp.EmitToImageReference() });
+
+            comp.VerifyDiagnostics();
+
+            var types = comp.GetTypesByMetadataName("N.C`1");
+
+            Assert.Single(types);
+            AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString());
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void GetTypesByMetadataName_MultipleInSourceNotInReferences(
+            bool useMetadataReference,
+            [CombinatorialValues("public", "internal")] string accessibility)
+        {
+            var referenceComp = CreateCompilation("");
+
+            var comp = CreateCompilation(
+$@"namespace N;
+{accessibility} class C<T> {{}}
+{accessibility} class C<T> {{}}", new[] { useMetadataReference ? referenceComp.ToMetadataReference() : referenceComp.EmitToImageReference() });
+
+            comp.VerifyDiagnostics(
+                // (3,16): error CS0101: The namespace 'N' already contains a definition for 'C'
+                // internal class C<T> {}
+                Diagnostic(ErrorCode.ERR_DuplicateNameInNS, "C").WithArguments("C", "N").WithLocation(3, 8 + accessibility.Length)
+            );
+
+            var types = comp.GetTypesByMetadataName("N.C`1");
+
+            Assert.Single(types);
+            AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString());
+            Assert.Equal(2, types[0].Locations.Length);
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void GetTypesByMetadataName_SingleInSourceSingleInReferences(
+            bool useMetadataReference,
+            [CombinatorialValues("public", "internal")] string accessibility)
+        {
+            string source = $@"namespace N;
+{accessibility} class C<T> {{}}";
+
+            var referenceComp = CreateCompilation(source);
+
+            referenceComp.VerifyDiagnostics();
+
+            MetadataReference reference = useMetadataReference ? referenceComp.ToMetadataReference() : referenceComp.EmitToImageReference();
+            var comp = CreateCompilation(source, new[] { reference });
+            comp.VerifyDiagnostics();
+
+            var types = comp.GetTypesByMetadataName("N.C`1");
+
+            Assert.Equal(2, types.Length);
+            AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString());
+            Assert.Same(comp.Assembly.GetPublicSymbol(), types[0].ContainingAssembly);
+            AssertEx.Equal("N.C<T>", types[1].ToTestDisplayString());
+
+            var assembly1 = comp.GetAssemblyOrModuleSymbol(reference).GetPublicSymbol();
+            Assert.Same(types[1].ContainingAssembly, assembly1);
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void GetTypesByMetadataName_NotInSourceSingleInReferences(
+            bool useMetadataReference,
+            [CombinatorialValues("public", "internal")] string accessibility)
+        {
+            string source = @$"namespace N;
+{accessibility} class C<T> {{}}";
+
+            var referenceComp = CreateCompilation(source);
+
+            referenceComp.VerifyDiagnostics();
+
+            MetadataReference reference = useMetadataReference ? referenceComp.ToMetadataReference() : referenceComp.EmitToImageReference();
+            var comp = CreateCompilation("", new[] { reference });
+            comp.VerifyDiagnostics();
+
+            var types = comp.GetTypesByMetadataName("N.C`1");
+
+
+            Assert.Single(types);
+            AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString());
+
+            var assembly1 = comp.GetAssemblyOrModuleSymbol(reference).GetPublicSymbol();
+            Assert.Same(types[0].ContainingAssembly, assembly1);
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void GetTypesByMetadataName_NotInSourceMultipleInReferences(
+            bool useMetadataReference,
+            [CombinatorialValues("public", "internal")] string accessibility)
+        {
+            string source = @$"namespace N;
+{accessibility} class C<T> {{}}";
+
+            var referenceComp1 = CreateCompilation(source);
+            referenceComp1.VerifyDiagnostics();
+
+            var referenceComp2 = CreateCompilation(source);
+            referenceComp2.VerifyDiagnostics();
+
+            MetadataReference reference1 = getReference(referenceComp1);
+            MetadataReference reference2 = getReference(referenceComp2);
+            var comp = CreateCompilation("", new[] { reference1, reference2 });
+            comp.VerifyDiagnostics();
+
+            var types = comp.GetTypesByMetadataName("N.C`1");
+
+            Assert.Equal(2, types.Length);
+            AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString());
+            AssertEx.Equal("N.C<T>", types[1].ToTestDisplayString());
+
+            var assembly1 = comp.GetAssemblyOrModuleSymbol(reference1).GetPublicSymbol();
+            Assert.Same(types[0].ContainingAssembly, assembly1);
+
+            var assembly2 = comp.GetAssemblyOrModuleSymbol(reference2).GetPublicSymbol();
+            Assert.Same(types[1].ContainingAssembly, assembly2);
+
+            MetadataReference getReference(CSharpCompilation referenceComp1)
+            {
+                return useMetadataReference ? referenceComp1.ToMetadataReference() : referenceComp1.EmitToImageReference();
+            }
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void GetTypesByMetadataName_SingleInSourceMultipleInReferences(
+            bool useMetadataReference,
+            [CombinatorialValues("public", "internal")] string accessibility)
+        {
+            string source = @$"namespace N;
+{accessibility} class C<T> {{}}";
+
+            var referenceComp1 = CreateCompilation(source);
+            referenceComp1.VerifyDiagnostics();
+
+            var referenceComp2 = CreateCompilation(source);
+            referenceComp2.VerifyDiagnostics();
+
+            MetadataReference reference1 = getReference(referenceComp1);
+            MetadataReference reference2 = getReference(referenceComp2);
+            var comp = CreateCompilation(source, new[] { reference1, reference2 });
+            comp.VerifyDiagnostics();
+
+            var types = comp.GetTypesByMetadataName("N.C`1");
+
+            Assert.Equal(3, types.Length);
+            AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString());
+            Assert.Same(comp.Assembly.GetPublicSymbol(), types[0].ContainingAssembly);
+            AssertEx.Equal("N.C<T>", types[1].ToTestDisplayString());
+            AssertEx.Equal("N.C<T>", types[2].ToTestDisplayString());
+
+            var assembly1 = comp.GetAssemblyOrModuleSymbol(reference1).GetPublicSymbol();
+            Assert.Same(types[1].ContainingAssembly, assembly1);
+
+            var assembly2 = comp.GetAssemblyOrModuleSymbol(reference2).GetPublicSymbol();
+            Assert.Same(types[2].ContainingAssembly, assembly2);
+
+            MetadataReference getReference(CSharpCompilation referenceComp1)
+            {
+                return useMetadataReference ? referenceComp1.ToMetadataReference() : referenceComp1.EmitToImageReference();
+            }
+        }
+
+        [Fact]
+        public void GetTypesByMetadataName_Ordering()
+        {
+            var corlibSource = @"
+namespace System
+{
+    public class Object {}
+    public class Void {}
+}
+
+public class C {}
+";
+
+            var corlib = CreateEmptyCompilation(corlibSource);
+            var corlibReference = corlib.EmitToImageReference();
+
+            var other = CreateEmptyCompilation(@"public class C {}", new[] { corlibReference });
+            var otherReference = other.EmitToImageReference();
+
+            var current = CreateEmptyCompilation(@"public class C {}", new[] { otherReference, corlibReference });
+            current.VerifyDiagnostics();
+
+            var types = current.GetTypesByMetadataName("C");
+
+            AssertEx.Equal(types.Select(t => t.ToTestDisplayString()), new[] { "C", "C", "C" });
+            Assert.Same(types[0].ContainingAssembly, current.Assembly.GetPublicSymbol());
+
+            var corlibAssembly = current.GetAssemblyOrModuleSymbol(corlibReference).GetPublicSymbol();
+            Assert.Same(types[1].ContainingAssembly, corlibAssembly);
+
+            var otherAssembly = current.GetAssemblyOrModuleSymbol(otherReference).GetPublicSymbol();
+            Assert.Same(types[2].ContainingAssembly, otherAssembly);
+        }
+
+        [Fact]
+        public void GetTypeByMetadataName_CorLibViaExtern()
+        {
+            var corlibSource = @"
+namespace System
+{
+    public class Object {}
+    public class Void {}
+}
+
+public class C {}
+";
+
+            var corlib = CreateEmptyCompilation(corlibSource);
+            var corlibReference = corlib.EmitToImageReference(aliases: ImmutableArray.Create("corlib"));
+
+            var current = CreateEmptyCompilation(@"", new[] { corlibReference });
+            current.VerifyDiagnostics();
+
+            var type = ((Compilation)current).GetTypeByMetadataName("C");
+            Assert.NotNull(type);
+
+            var corlibAssembly = current.GetAssemblyOrModuleSymbol(corlibReference).GetPublicSymbol();
+            Assert.Same(type.ContainingAssembly, corlibAssembly);
+        }
+
+        [Fact]
+        public void GetTypeByMetadataName_OtherViaExtern()
+        {
+            var corlibSource = @"
+namespace System
+{
+    public class Object {}
+    public class Void {}
+}
+";
+
+            var corlib = CreateEmptyCompilation(corlibSource);
+            var corlibReference = corlib.EmitToImageReference();
+
+            var other = CreateEmptyCompilation(@"public class C {}", new[] { corlibReference });
+            var otherReference = other.EmitToImageReference(aliases: ImmutableArray.Create("other"));
+
+            var current = CreateEmptyCompilation(@"", new[] { otherReference, corlibReference });
+            current.VerifyDiagnostics();
+
+            var type = ((Compilation)current).GetTypeByMetadataName("C");
+            Assert.Null(type);
+        }
+
+        #endregion
     }
 }
diff --git a/src/Compilers/Core/Portable/Compilation/Compilation.cs b/src/Compilers/Core/Portable/Compilation/Compilation.cs
index 037ea63240a7d..d48762238a837 100644
--- a/src/Compilers/Core/Portable/Compilation/Compilation.cs
+++ b/src/Compilers/Core/Portable/Compilation/Compilation.cs
@@ -1025,28 +1025,122 @@ public INamedTypeSymbol CreateNativeIntegerTypeSymbol(bool signed)
         private readonly ConcurrentCache<string, INamedTypeSymbol?> _getTypeCache =
             new ConcurrentCache<string, INamedTypeSymbol?>(50, ReferenceEqualityComparer.Instance);
 
+        private readonly ConcurrentCache<string, ImmutableArray<INamedTypeSymbol>> _getTypesCache =
+            new ConcurrentCache<string, ImmutableArray<INamedTypeSymbol>>(50, ReferenceEqualityComparer.Instance);
+
         /// <summary>
         /// Gets the type within the compilation's assembly and all referenced assemblies (other than
         /// those that can only be referenced via an extern alias) using its canonical CLR metadata name.
-        /// </summary>
-        /// <returns>Null if the type can't be found.</returns>
+        /// This lookup follows the following order:
+        /// <list type="number">
+        /// <item><description>If the type is found in the compilation's assembly, that type is returned.</description></item>
+        /// <item><description>
+        /// Next, the core library (the library that defines <c>System.Object</c> and has no assembly references) is searched.
+        /// If the type is found there, that type is returned.
+        /// </description></item>
+        /// <item><description>
+        /// Finally, all remaining referenced non-extern assemblies are searched. If one and only one type matching the provided metadata name is found, that
+        /// single type is returned. Accessibility is ignored for this check.
+        /// </description></item>
+        /// </list>
+        /// </summary>
+        /// <returns>Null if the type can't be found or there was an ambiguity during lookup.</returns>
         /// <remarks>
+        /// <para>
         /// Since VB does not have the concept of extern aliases, it considers all referenced assemblies.
+        /// </para>
+        /// <para>
+        /// In C#, if the core library is referenced as an extern assembly, it will be searched. All other extern-aliased assemblies will not be searched.
+        /// </para>
+        /// <para>
+        /// Because accessibility to the current assembly is ignored when searching for types that match the provided metadata name, if multiple referenced
+        /// assemblies define the same type symbol (as often happens when users copy well-known types from the BCL or other sources) then this API will return null,
+        /// even if all but one of those symbols would be otherwise inaccessible to user-written code in the current assembly. For fine-grained control over ambiguity
+        /// resolution, consider using <see cref="GetTypesByMetadataName(string)" /> instead and filtering the results for the symbol required.
+        /// </para>
+        /// <para>
+        /// Assemblies can contain multiple modules. Within each assembly, the search is performed based on module's position in the module list of that assembly. When
+        /// a match is found in one module in an assembly, no further modules within that assembly are searched.
+        /// </para>
+        /// <para>Type forwarders are ignored, and not considered part of the assembly where the TypeForwardAttribute is written.</para>
         /// </remarks>
         public INamedTypeSymbol? GetTypeByMetadataName(string fullyQualifiedMetadataName)
         {
             if (!_getTypeCache.TryGetValue(fullyQualifiedMetadataName, out INamedTypeSymbol? val))
             {
                 val = CommonGetTypeByMetadataName(fullyQualifiedMetadataName);
-                // Ignore if someone added the same value before us
-                _ = _getTypeCache.TryAdd(fullyQualifiedMetadataName, val);
+                var result = _getTypeCache.TryAdd(fullyQualifiedMetadataName, val);
+                Debug.Assert(result || (_getTypeCache.TryGetValue(fullyQualifiedMetadataName, out var addedType) && ReferenceEquals(addedType, val)));
             }
             return val;
         }
 
         protected abstract INamedTypeSymbol? CommonGetTypeByMetadataName(string metadataName);
 
-#pragma warning disable RS0026 // Do not add multiple public overloads with optional parameters
+        /// <summary>
+        /// Gets all types with the compilation's assembly and all referenced assemblies that have the
+        /// given canonical CLR metadata name. Accessibility to the current assembly is ignored when
+        /// searching for matching type names.
+        /// </summary>
+        /// <returns>Empty array if no types match. Otherwise, all types that match the name, current assembly first if present.</returns>
+        /// <remarks>
+        /// <para>
+        /// Assemblies can contain multiple modules. Within each assembly, the search is performed based on module's position in the module list of that assembly. When
+        /// a match is found in one module in an assembly, no further modules within that assembly are searched.
+        /// </para>
+        /// <para>Type forwarders are ignored, and not considered part of the assembly where the TypeForwardAttribute is written.</para>
+        /// </remarks>
+        public ImmutableArray<INamedTypeSymbol> GetTypesByMetadataName(string fullyQualifiedMetadataName)
+        {
+            if (!_getTypesCache.TryGetValue(fullyQualifiedMetadataName, out ImmutableArray<INamedTypeSymbol> val))
+            {
+                val = getTypesByMetadataNameImpl();
+                var result = _getTypesCache.TryAdd(fullyQualifiedMetadataName, val);
+                Debug.Assert(result
+                    || (_getTypesCache.TryGetValue(fullyQualifiedMetadataName, out var addedArray)
+                        && Enumerable.SequenceEqual(addedArray, val, ReferenceEqualityComparer.Instance)));
+            }
+
+            return val;
+
+            ImmutableArray<INamedTypeSymbol> getTypesByMetadataNameImpl()
+            {
+                ArrayBuilder<INamedTypeSymbol>? typesByMetadataName = null;
+
+                // Start with the current assembly, then corlib, then look through all references, to mimic GetTypeByMetadataName search order.
+
+                addIfNotNull(Assembly.GetTypeByMetadataName(fullyQualifiedMetadataName));
+
+                var corLib = ObjectType.ContainingAssembly;
+
+                if (!ReferenceEquals(corLib, Assembly))
+                {
+                    addIfNotNull(corLib.GetTypeByMetadataName(fullyQualifiedMetadataName));
+                }
+
+                foreach (var referencedAssembly in SourceModule.ReferencedAssemblySymbols)
+                {
+                    if (ReferenceEquals(referencedAssembly, corLib))
+                    {
+                        continue;
+                    }
+
+                    addIfNotNull(referencedAssembly.GetTypeByMetadataName(fullyQualifiedMetadataName));
+                }
+
+                return typesByMetadataName?.ToImmutableAndFree() ?? ImmutableArray<INamedTypeSymbol>.Empty;
+
+                void addIfNotNull(INamedTypeSymbol? toAdd)
+                {
+                    if (toAdd != null)
+                    {
+                        typesByMetadataName ??= ArrayBuilder<INamedTypeSymbol>.GetInstance();
+                        typesByMetadataName.Add(toAdd);
+                    }
+                }
+            }
+        }
+
         /// <summary>
         /// Returns a new INamedTypeSymbol with the given element types and
         /// (optional) element names, locations, and nullable annotations.
@@ -1087,7 +1181,6 @@ public INamedTypeSymbol CreateTupleTypeSymbol(
 
             return CommonCreateTupleTypeSymbol(elementTypes, elementNames, elementLocations, elementNullableAnnotations);
         }
-#pragma warning restore RS0026 // Do not add multiple public overloads with optional parameters
 
         /// <summary>
         /// Returns a new INamedTypeSymbol with the given element types, names, and locations.
diff --git a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
index aaa20ce501924..b780b1cd315e8 100644
--- a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
+++ b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
@@ -9,6 +9,7 @@ const Microsoft.CodeAnalysis.WellKnownGeneratorOutputs.ImplementationSourceOutpu
 const Microsoft.CodeAnalysis.WellKnownGeneratorOutputs.SourceOutput = "SourceOutput" -> string!
 const Microsoft.CodeAnalysis.WellKnownMemberNames.PrintMembersMethodName = "PrintMembers" -> string!
 Microsoft.CodeAnalysis.Compilation.EmitDifference(Microsoft.CodeAnalysis.Emit.EmitBaseline! baseline, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.Emit.SemanticEdit>! edits, System.Func<Microsoft.CodeAnalysis.ISymbol!, bool>! isAddedSymbol, System.IO.Stream! metadataStream, System.IO.Stream! ilStream, System.IO.Stream! pdbStream, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.Emit.EmitDifferenceResult!
+Microsoft.CodeAnalysis.Compilation.GetTypesByMetadataName(string! fullyQualifiedMetadataName) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.INamedTypeSymbol!>
 Microsoft.CodeAnalysis.Emit.EmitDifferenceResult.ChangedTypes.get -> System.Collections.Immutable.ImmutableArray<System.Reflection.Metadata.TypeDefinitionHandle>
 Microsoft.CodeAnalysis.Emit.EmitDifferenceResult.UpdatedMethods.get -> System.Collections.Immutable.ImmutableArray<System.Reflection.Metadata.MethodDefinitionHandle>
 Microsoft.CodeAnalysis.Emit.SemanticEditKind.Replace = 4 -> Microsoft.CodeAnalysis.Emit.SemanticEditKind
diff --git a/src/Compilers/VisualBasic/Test/Symbol/CompilationAPITests.vb b/src/Compilers/VisualBasic/Test/Symbol/CompilationAPITests.vb
new file mode 100644
index 0000000000000..b0f3ed506cc9f
--- /dev/null
+++ b/src/Compilers/VisualBasic/Test/Symbol/CompilationAPITests.vb
@@ -0,0 +1,226 @@
+' 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.
+
+Imports Microsoft.CodeAnalysis.Test.Utilities
+Imports Roslyn.Test.Utilities
+
+Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests
+
+    Public Class CompilationAPITests
+        Inherits BasicTestBase
+
+        <Fact()>
+        Public Sub GetTypesByMetadataName_NotInSourceNotInReferences()
+            Dim comp = CreateCompilation("")
+            comp.AssertNoDiagnostics()
+
+            Dim types = comp.GetTypesByMetadataName("N.C`1")
+            Assert.Empty(types)
+        End Sub
+
+        <Theory, CombinatorialData>
+        Public Sub GetTypesByMetadataName_SingleInSourceNotInReferences(useMetadataReferences As Boolean, <CombinatorialValues("Public", "Friend")> accessibility As String)
+            Dim referenceComp = CreateCompilation("")
+
+            Dim source =
+$"Namespace N
+    {accessibility} Class C(Of T)
+    End Class
+End Namespace"
+
+            Dim comp = CreateCompilation(source, {If(useMetadataReferences, referenceComp.ToMetadataReference(), referenceComp.EmitToImageReference())})
+            comp.AssertNoDiagnostics()
+
+            Dim types = comp.GetTypesByMetadataName("N.C`1")
+
+            Assert.Single(types)
+            AssertEx.Equal("N.C(Of T)", types(0).ToTestDisplayString())
+        End Sub
+
+        <Theory, CombinatorialData>
+        Public Sub GetTypesByMetadataName_MultipleInSourceNotInReferences(useMetadataReferences As Boolean, <CombinatorialValues("Public", "Friend")> accessibility As String)
+            Dim referenceComp = CreateCompilation("")
+
+            Dim source =
+$"Namespace N
+    {accessibility} Class C(Of T)
+    End Class
+    {accessibility} Class C(Of T)
+    End Class
+End Namespace"
+
+            Dim comp = CreateCompilation(source, {If(useMetadataReferences, referenceComp.ToMetadataReference(), referenceComp.EmitToImageReference())})
+            comp.AssertTheseDiagnostics(
+<expected>
+BC30179: class 'C' and class 'C' conflict in namespace 'N'.
+    <%= accessibility %> Class C(Of T)
+                 ~
+</expected>)
+
+            Dim types = comp.GetTypesByMetadataName("N.C`1")
+
+            Assert.Single(types)
+            AssertEx.Equal("N.C(Of T)", types(0).ToTestDisplayString())
+            Assert.Equal(2, types(0).Locations.Length)
+        End Sub
+
+        <Theory, CombinatorialData>
+        Public Sub GetTypesByMetadataName_SingleInSourceSingleInReferences(useMetadataReference As Boolean, <CombinatorialValues("Public", "Friend")> accessibility As String)
+            Dim source =
+$"Namespace N
+    {accessibility} Class C(Of T)
+    End Class
+End Namespace"
+
+            Dim referenceComp = CreateCompilation(source)
+            Dim reference As MetadataReference = If(useMetadataReference, referenceComp.ToMetadataReference(), referenceComp.EmitToImageReference())
+            Dim comp = CreateCompilation(source, {reference})
+            comp.AssertNoDiagnostics()
+
+            Dim types = comp.GetTypesByMetadataName("N.C`1")
+
+            Assert.Equal(2, types.Length)
+            AssertEx.Equal("N.C(Of T)", types(0).ToTestDisplayString())
+            Assert.Same(comp.Assembly, types(0).ContainingAssembly)
+            AssertEx.Equal("N.C(Of T)", types(1).ToTestDisplayString())
+
+            Dim referenceAssembly = comp.GetAssemblyOrModuleSymbol(reference)
+            Assert.Same(types(1).ContainingAssembly, referenceAssembly)
+        End Sub
+
+        <Theory, CombinatorialData>
+        Public Sub GetTypesByMetadataName_NotInSourceSingleInReferences(useMetadataReference As Boolean, <CombinatorialValues("Public", "Friend")> accessibility As String)
+            Dim source =
+$"Namespace N
+    {accessibility} Class C(Of T)
+    End Class
+End Namespace"
+
+            Dim referenceComp = CreateCompilation(source)
+            Dim reference As MetadataReference = GetReference(useMetadataReference, referenceComp)
+            Dim comp = CreateCompilation("", {reference})
+            comp.AssertNoDiagnostics()
+
+            Dim types = comp.GetTypesByMetadataName("N.C`1")
+
+            Assert.Single(types)
+            AssertEx.Equal("N.C(Of T)", types(0).ToTestDisplayString())
+
+            Dim referenceAssembly = comp.GetAssemblyOrModuleSymbol(reference)
+            Assert.Same(types(0).ContainingAssembly, referenceAssembly)
+        End Sub
+
+        Private Shared Function GetReference(useMetadataReference As Boolean, referenceComp As VisualBasicCompilation) As MetadataReference
+            Return If(useMetadataReference, referenceComp.ToMetadataReference(), referenceComp.EmitToImageReference())
+        End Function
+
+        <Theory, CombinatorialData>
+        Public Sub GetTypesByMetadataName_NotInSourceMultipleInReferences(useMetadataReference As Boolean, <CombinatorialValues("Public", "Friend")> accessibility As String)
+            Dim source =
+$"Namespace N
+    {accessibility} Class C(Of T)
+    End Class
+End Namespace"
+
+            Dim referenceComp1 = CreateCompilation(source)
+            Dim referenceComp2 = CreateCompilation(source)
+            Dim reference1 As MetadataReference = GetReference(useMetadataReference, referenceComp1)
+            Dim reference2 As MetadataReference = GetReference(useMetadataReference, referenceComp2)
+            Dim comp = CreateCompilation("", {reference1, reference2})
+            comp.AssertNoDiagnostics()
+
+            Dim types = comp.GetTypesByMetadataName("N.C`1")
+
+            Assert.Equal(2, types.Length)
+            AssertEx.Equal("N.C(Of T)", types(0).ToTestDisplayString())
+            AssertEx.Equal("N.C(Of T)", types(1).ToTestDisplayString())
+
+            Dim referenceAssembly1 = comp.GetAssemblyOrModuleSymbol(reference1)
+            Assert.Same(types(0).ContainingAssembly, referenceAssembly1)
+
+            Dim referenceAssembly2 = comp.GetAssemblyOrModuleSymbol(reference2)
+            Assert.Same(types(1).ContainingAssembly, referenceAssembly2)
+
+            If (useMetadataReference) Then
+            Else
+                Assert.False(types(0).IsInSource())
+                Assert.False(types(1).IsInSource())
+            End If
+        End Sub
+
+        <Theory, CombinatorialData>
+        Public Sub GetTypesByMetadataName_SingleInSourceMultipleInReferences(useMetadataReference As Boolean, <CombinatorialValues("Public", "Friend")> accessibility As String)
+            Dim source =
+$"Namespace N
+    {accessibility} Class C(Of T)
+    End Class
+End Namespace"
+
+            Dim referenceComp1 = CreateCompilation(source)
+            Dim referenceComp2 = CreateCompilation(source)
+            Dim reference1 As MetadataReference = GetReference(useMetadataReference, referenceComp1)
+            Dim reference2 As MetadataReference = GetReference(useMetadataReference, referenceComp2)
+            Dim comp = CreateCompilation(source, {reference1, reference2})
+            comp.AssertNoDiagnostics()
+
+            Dim types = comp.GetTypesByMetadataName("N.C`1")
+
+            Assert.Equal(3, types.Length)
+            AssertEx.Equal("N.C(Of T)", types(0).ToTestDisplayString())
+            Assert.Same(comp.Assembly, types(0).ContainingAssembly)
+            AssertEx.Equal("N.C(Of T)", types(1).ToTestDisplayString())
+            AssertEx.Equal("N.C(Of T)", types(2).ToTestDisplayString())
+
+            Dim referenceAssembly1 = comp.GetAssemblyOrModuleSymbol(reference1)
+            Assert.Same(types(1).ContainingAssembly, referenceAssembly1)
+
+            Dim referenceAssembly2 = comp.GetAssemblyOrModuleSymbol(reference2)
+            Assert.Same(types(2).ContainingAssembly, referenceAssembly2)
+        End Sub
+
+        <Fact>
+        Public Sub GetTypesByMetadataName_Ordering()
+            Dim corlibSource = "
+Namespace System
+    Public Class [Object]
+    End Class
+    Public Class [Void]
+    End Class
+End Namespace
+Public Class C
+End Class
+"
+
+            Dim corlib = CreateEmptyCompilation(corlibSource)
+            Dim corlibReference = corlib.EmitToImageReference()
+
+            Dim otherSource = "
+Public Class C
+End Class
+"
+
+            Dim other = CreateEmptyCompilation(otherSource, {corlibReference})
+            Dim otherReference = other.EmitToImageReference()
+
+            Dim currentSource = "
+Public Class C
+End Class
+"
+            Dim current = CreateEmptyCompilation(currentSource, {otherReference, corlibReference})
+            current.AssertNoDiagnostics()
+
+            Dim types = current.GetTypesByMetadataName("C")
+
+            AssertEx.Equal(types.Select(Function(t) t.ToTestDisplayString()), {"C", "C", "C"})
+
+            Assert.Same(current.Assembly, types(0).ContainingAssembly)
+
+            Dim corlibAssembly = current.GetAssemblyOrModuleSymbol(corlibReference)
+            Assert.Same(types(1).ContainingAssembly, corlibAssembly)
+
+            Dim otherAssembly = current.GetAssemblyOrModuleSymbol(otherReference)
+            Assert.Same(types(2).ContainingAssembly, otherAssembly)
+        End Sub
+    End Class
+End Namespace
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/CompilationExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/CompilationExtensions.cs
index 649d9f7bfa377..0384afee7e1fc 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/CompilationExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/CompilationExtensions.cs
@@ -2,6 +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.Diagnostics;
+
 namespace Microsoft.CodeAnalysis.Shared.Extensions
 {
     internal static class CompilationExtensions
@@ -33,42 +35,33 @@ internal static class CompilationExtensions
         /// <returns>The symbol to use for code analysis; otherwise, <see langword="null"/>.</returns>
         public static INamedTypeSymbol? GetBestTypeByMetadataName(this Compilation compilation, string fullyQualifiedMetadataName)
         {
-            // Try to get the unique type with this name, ignoring accessibility
-            var type = compilation.GetTypeByMetadataName(fullyQualifiedMetadataName);
-
-            // Otherwise, try to get the unique type with this name originally defined in 'compilation'
-            type ??= compilation.Assembly.GetTypeByMetadataName(fullyQualifiedMetadataName);
+            INamedTypeSymbol? type = null;
 
-            // Otherwise, try to get the unique accessible type with this name from a reference
-            if (type is null)
+            foreach (var currentType in compilation.GetTypesByMetadataName(fullyQualifiedMetadataName))
             {
-                foreach (var module in compilation.Assembly.Modules)
+                if (ReferenceEquals(currentType.ContainingAssembly, compilation.Assembly))
                 {
-                    foreach (var referencedAssembly in module.ReferencedAssemblySymbols)
-                    {
-                        var currentType = referencedAssembly.GetTypeByMetadataName(fullyQualifiedMetadataName);
-                        if (currentType is null)
-                            continue;
-
-                        switch (currentType.GetResultantVisibility())
-                        {
-                            case Utilities.SymbolVisibility.Public:
-                            case Utilities.SymbolVisibility.Internal when referencedAssembly.GivesAccessTo(compilation.Assembly):
-                                break;
+                    Debug.Assert(type is null);
+                    return currentType;
+                }
 
-                            default:
-                                continue;
-                        }
+                switch (currentType.GetResultantVisibility())
+                {
+                    case Utilities.SymbolVisibility.Public:
+                    case Utilities.SymbolVisibility.Internal when currentType.ContainingAssembly.GivesAccessTo(compilation.Assembly):
+                        break;
 
-                        if (type is object)
-                        {
-                            // Multiple visible types with the same metadata name are present
-                            return null;
-                        }
+                    default:
+                        continue;
+                }
 
-                        type = currentType;
-                    }
+                if (type is object)
+                {
+                    // Multiple visible types with the same metadata name are present
+                    return null;
                 }
+
+                type = currentType;
             }
 
             return type;

From b7b363dd420f9a7d197ae5c28145c63d7037e0e4 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Thu, 13 Jan 2022 15:41:44 -0800
Subject: [PATCH 350/444] Fix

---
 .../Core/Portable/CodeRefactoringHelpers.cs   | 41 ++++++++++---------
 1 file changed, 22 insertions(+), 19 deletions(-)

diff --git a/src/Features/Core/Portable/CodeRefactoringHelpers.cs b/src/Features/Core/Portable/CodeRefactoringHelpers.cs
index 3f7eba0acb939..4b1d99a7370dd 100644
--- a/src/Features/Core/Portable/CodeRefactoringHelpers.cs
+++ b/src/Features/Core/Portable/CodeRefactoringHelpers.cs
@@ -15,60 +15,63 @@ internal static class CodeRefactoringHelpers
     {
         /// <summary>
         /// <para>
-        /// Determines if a <paramref name="node"/> is underselected given <paramref name="selection"/>.
+        /// Determines if a <paramref name="node"/> is under-selected given <paramref name="selection"/>.
         /// </para>
         /// <para>
-        /// Underselection is defined as omitting whole nodes from either the beginning or the end. It can be used e.g. to detect that
-        /// following selection `1 + [|2 + 3|]` is underselecting the whole expression node tree.
+        /// Under-selection is defined as omitting whole nodes from either the beginning or the end. It can be used e.g.
+        /// to detect that following selection `1 + [|2 + 3|]` is under-selecting the whole expression node tree.
         /// </para>
         /// <para>
-        /// Returns false if only and precisely one <see cref="SyntaxToken"/> is selected. In that case the <paramref name="selection"/> 
-        /// is treated more as a caret location.
+        /// Returns false if only and precisely one <see cref="SyntaxToken"/> is selected. In that case the <paramref
+        /// name="selection"/> is treated more as a caret location.
         /// </para>
         /// <para>
-        /// It's intended to be used in conjunction with <see cref="IRefactoringHelpersService.GetRelevantNodesAsync{TSyntaxNode}(Document, TextSpan, CancellationToken)"/>
-        /// that, for non-empty selections, returns the smallest encompassing node. A node that can, for certain refactorings, be too large given user-selection even though
-        /// it is the smallest that can be retrieved.
+        /// It's intended to be used in conjunction with <see
+        /// cref="IRefactoringHelpersService.GetRelevantNodesAsync{TSyntaxNode}(Document, TextSpan, bool,
+        /// CancellationToken)"/> that, for non-empty selections, returns the smallest encompassing node. A node that
+        /// can, for certain refactorings, be too large given user-selection even though it is the smallest that can be
+        /// retrieved.
         /// </para>
         /// <para>
-        /// When <paramref name="selection"/> doesn't intersect the node in any way it's not considered to be underselected.
+        /// When <paramref name="selection"/> doesn't intersect the node in any way it's not considered to be
+        /// under-selected.
         /// </para>
         /// <para>
-        /// Null node is always considered underselected.
+        /// Null node is always considered under-selected.
         /// </para>
         /// </summary>
         public static bool IsNodeUnderselected(SyntaxNode? node, TextSpan selection)
         {
-            // Selection is null -> it's always underselected
-            // REASON: Easier API use -> underselected node, don't work on it further
+            // Selection is null -> it's always under-selected
+            // REASON: Easier API use -> under-selected node, don't work on it further
             if (node == null)
             {
                 return true;
             }
 
-            // Selection or node is empty -> can't be underselected
+            // Selection or node is empty -> can't be under-selected
             if (selection.IsEmpty || node.Span.IsEmpty)
             {
                 return false;
             }
 
-            // Selection is larger than node.Span -> can't be underselecting
+            // Selection is larger than node.Span -> can't be under-selecting
             if (selection.Contains(node.Span))
             {
                 return false;
             }
 
-            // Selection doesn't intersect node -> can't be underselecting.
+            // Selection doesn't intersect node -> can't be under-selecting.
             // RATIONALE: If there's no intersection then we got the node in some other way, e.g. 
             // extracting it after user selected `;` at the end of an expression statement 
-            // `foo()[|;|]` for `foo()` node.
+            // `goo()[|;|]` for `goo()` node.
             if (!node.FullSpan.OverlapsWith(selection))
             {
                 return false;
             }
 
             // Only precisely one token of the node is selected -> treat is as empty selection -> not 
-            // underselected. The rationale is that if only one Token is selected then the selection 
+            // under-selected. The rationale is that if only one Token is selected then the selection 
             // wasn't about precisely getting the one node and nothing else & therefore we should treat 
             // it as empty selection.
             if (node.FullSpan.Contains(selection.Start))
@@ -85,10 +88,10 @@ public static bool IsNodeUnderselected(SyntaxNode? node, TextSpan selection)
             RoslynDebug.Assert(beginningNode is object);
             RoslynDebug.Assert(endNode is object);
 
-            // Node is underselected if either the first (lowest) child doesn't contain start of selection
+            // Node is under-selected if either the first (lowest) child doesn't contain start of selection
             // of the last child doesn't intersect with the end.
 
-            // Node is underselected if either the first (lowest) child ends before the selection has started
+            // Node is under-selected if either the first (lowest) child ends before the selection has started
             // or the last child starts after the selection ends (i.e. one of them is completely on the outside of selection).
             // It's a crude heuristic but it allows omitting parts of nodes or trivial tokens from the beginning/end 
             // but fires up e.g.: `1 + [|2 + 3|]`.

From 325c3b273aa83c8283994da4dc78a18326694e95 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Fri, 30 Apr 2021 14:11:15 -0700
Subject: [PATCH 351/444] Expand support for context variables

---
 .../ContextVariableArgumentProviderTests.cs   |  19 +--
 .../ContextVariableArgumentProviderTests.vb   |  16 ++-
 ...AbstractContextVariableArgumentProvider.cs | 109 ++++++++++++++++--
 3 files changed, 123 insertions(+), 21 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/ContextVariableArgumentProviderTests.cs b/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/ContextVariableArgumentProviderTests.cs
index da4eb408377ee..84456834eafe5 100644
--- a/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/ContextVariableArgumentProviderTests.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/ContextVariableArgumentProviderTests.cs
@@ -97,22 +97,25 @@ void Target({type} arg)
         }
 
         [Theory]
-        [InlineData("string")]
-        [InlineData("bool")]
-        [InlineData("int?")]
-        public async Task TestInstanceVariable(string type)
+        [InlineData("string", "string")]
+        [InlineData("string", "IEnumerable<char>")]
+        [InlineData("bool", "bool")]
+        [InlineData("int?", "int?")]
+        [InlineData("int", "int?")]
+        public async Task TestInstanceVariable(string fieldType, string parameterType)
         {
             var markup = $@"
+using System.Collections.Generic;
 class C
 {{
-    {type} arg;
+    {fieldType} arg;
 
     void Method()
     {{
         this.Target($$);
     }}
 
-    void Target({type} arg)
+    void Target({parameterType} arg)
     {{
     }}
 }}
@@ -122,8 +125,8 @@ void Target({type} arg)
             await VerifyDefaultValueAsync(markup, expectedDefaultValue: null, previousDefaultValue: "prior");
         }
 
-        // Note: The current implementation checks for exact type and name match. If this changes, some of these tests
-        // may need to be updated to account for the new behavior.
+        // Note: The current implementation checks for exact type match for primitive types. If this changes, some of
+        // these tests may need to be updated to account for the new behavior.
         [Theory]
         [InlineData("object", "string")]
         [InlineData("string", "object")]
diff --git a/src/EditorFeatures/VisualBasicTest/Completion/ArgumentProviders/ContextVariableArgumentProviderTests.vb b/src/EditorFeatures/VisualBasicTest/Completion/ArgumentProviders/ContextVariableArgumentProviderTests.vb
index 57cb3b0a273f2..bb4d7872101a0 100644
--- a/src/EditorFeatures/VisualBasicTest/Completion/ArgumentProviders/ContextVariableArgumentProviderTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/Completion/ArgumentProviders/ContextVariableArgumentProviderTests.vb
@@ -55,19 +55,23 @@ End Class
         End Function
 
         <Theory>
-        <InlineData("String")>
-        <InlineData("Boolean")>
-        <InlineData("Integer?")>
-        Public Async Function TestInstanceVariable(type As String) As Task
+        <InlineData("String", "String")>
+        <InlineData("String", "IEnumerable(Of Char)")>
+        <InlineData("Boolean", "Boolean")>
+        <InlineData("Integer?", "Integer?")>
+        <InlineData("Integer", "Integer?")>
+        Public Async Function TestInstanceVariable(fieldType As String, parameterType As String) As Task
             Dim markup = $"
+Imports System.Collections.Generic
+
 Class C
-    Dim arg As {type}
+    Dim arg As {fieldType}
 
     Sub Method()
         Me.Target($$)
     End Sub
 
-    Sub Target(arg As {type})
+    Sub Target(arg As {parameterType})
     End Sub
 End Class
 "
diff --git a/src/Features/Core/Portable/Completion/Providers/AbstractContextVariableArgumentProvider.cs b/src/Features/Core/Portable/Completion/Providers/AbstractContextVariableArgumentProvider.cs
index a1c6a3818f6d8..af07362191704 100644
--- a/src/Features/Core/Portable/Completion/Providers/AbstractContextVariableArgumentProvider.cs
+++ b/src/Features/Core/Portable/Completion/Providers/AbstractContextVariableArgumentProvider.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;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Operations;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 
 namespace Microsoft.CodeAnalysis.Completion
@@ -20,20 +22,113 @@ public override Task ProvideArgumentAsync(ArgumentContext context)
                 return Task.CompletedTask;
             }
 
-            var symbols = context.SemanticModel.LookupSymbols(context.Position, name: context.Parameter.Name);
+            var requireExactType = context.Parameter.Type.IsSpecialType()
+                || context.Parameter.RefKind != RefKind.None;
+            var symbols = context.SemanticModel.LookupSymbols(context.Position);
+
+            // First try to find a local variable
+            ISymbol? bestSymbol = null;
+            CommonConversion bestConversion = default;
             foreach (var symbol in symbols)
             {
-                // Currently we check for an exact type match before using a variable from context. As we hone the
-                // default argument provider heuristics, we may alter the definition of "in scope" as well as the type
-                // and name check(s) that occur.
-                if (SymbolEqualityComparer.Default.Equals(context.Parameter.Type, symbol.GetSymbolType()))
+                ISymbol candidate;
+                if (symbol.IsKind(SymbolKind.Parameter, out IParameterSymbol? parameter))
+                    candidate = parameter;
+                else if (symbol.IsKind(SymbolKind.Local, out ILocalSymbol? local))
+                    candidate = local;
+                else
+                    continue;
+
+                CheckCandidate(candidate);
+            }
+
+            if (bestSymbol is not null)
+            {
+                context.DefaultValue = bestSymbol.Name;
+                return Task.CompletedTask;
+            }
+
+            foreach (var symbol in symbols)
+            {
+                ISymbol candidate;
+                if (symbol.IsKind(SymbolKind.Field, out IFieldSymbol? field))
+                    candidate = field;
+                else if (symbol.IsKind(SymbolKind.Property, out IPropertySymbol? property))
+                    candidate = property;
+                else
+                    continue;
+
+                // Require a name match for primitive types
+                if (candidate.GetSymbolType().IsSpecialType()
+                    && !string.Equals(candidate.Name, context.Parameter.Name, StringComparison.OrdinalIgnoreCase))
                 {
-                    context.DefaultValue = context.Parameter.Name;
-                    return Task.CompletedTask;
+                    continue;
                 }
+
+                CheckCandidate(candidate);
+            }
+
+            if (bestSymbol is not null)
+            {
+                context.DefaultValue = bestSymbol.Name;
+                return Task.CompletedTask;
             }
 
             return Task.CompletedTask;
+
+            // Local functions
+            void CheckCandidate(ISymbol candidate)
+            {
+                if (candidate.GetSymbolType() is not { } symbolType)
+                {
+                    return;
+                }
+
+                if (requireExactType && !SymbolEqualityComparer.Default.Equals(context.Parameter.Type, symbolType))
+                {
+                    return;
+                }
+
+                var conversion = context.SemanticModel.Compilation.ClassifyCommonConversion(symbolType, context.Parameter.Type);
+                if (!conversion.IsImplicit)
+                {
+                    return;
+                }
+
+                if (bestSymbol is not null && !IsNewConversionSameOrBetter(conversion))
+                {
+                    if (!IsNewConversionSameOrBetter(conversion))
+                        return;
+
+                    if (!IsNewNameSameOrBetter(candidate))
+                        return;
+                }
+
+                bestSymbol = candidate;
+                bestConversion = conversion;
+            }
+
+            bool IsNewConversionSameOrBetter(CommonConversion conversion)
+            {
+                if (bestConversion.IsIdentity && !conversion.IsIdentity)
+                    return false;
+
+                if (bestConversion.IsImplicit && !conversion.IsImplicit)
+                    return false;
+
+                return true;
+            }
+
+            bool IsNewNameSameOrBetter(ISymbol symbol)
+            {
+                if (string.Equals(bestSymbol.Name, context.Parameter.Name))
+                    return string.Equals(symbol.Name, context.Parameter.Name);
+
+                if (string.Equals(bestSymbol.Name, context.Parameter.Name, StringComparison.OrdinalIgnoreCase))
+                    return string.Equals(symbol.Name, context.Parameter.Name, StringComparison.OrdinalIgnoreCase);
+
+                return true;
+            }
         }
     }
 }

From 9a696923fc18dbff1abae5b1cae1bdf95984153b Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrus.najmabadi@gmail.com>
Date: Thu, 13 Jan 2022 14:57:59 -1000
Subject: [PATCH 352/444] Perform progression search in two phases. (#58785)

* Break progression search into two phases

* Update tests

* Add asserts

* REorder

* Make public

* Update src/Features/Core/Portable/NavigateTo/NavigateToSearcher.cs

Co-authored-by: David Barbet <dibarbet@gmail.com>

* Remove parallelism.  We don't need the contention

* Fix counter logic

* Reorder

* Fix comment

* Lint

Co-authored-by: David Barbet <dibarbet@gmail.com>
---
 .../Portable/NavigateTo/NavigateToSearcher.cs | 135 ++++++++++++------
 .../Progression/GraphProvider.cs              |  15 +-
 .../GraphQueries/SearchGraphQuery.cs          |   7 +-
 .../Progression/GraphQueryManager.cs          |  27 ++--
 .../SearchGraphQueryTests_NavigateTo.vb       |  23 +--
 5 files changed, 132 insertions(+), 75 deletions(-)

diff --git a/src/Features/Core/Portable/NavigateTo/NavigateToSearcher.cs b/src/Features/Core/Portable/NavigateTo/NavigateToSearcher.cs
index 9b7b97313a2af..c47474836bc98 100644
--- a/src/Features/Core/Portable/NavigateTo/NavigateToSearcher.cs
+++ b/src/Features/Core/Portable/NavigateTo/NavigateToSearcher.cs
@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -19,6 +20,14 @@
 
 namespace Microsoft.CodeAnalysis.NavigateTo
 {
+    [Flags]
+    internal enum NavigateToSearchScope
+    {
+        RegularDocuments = 0b01,
+        GeneratedDocuments = 0b10,
+        AllDocuments = RegularDocuments | GeneratedDocuments
+    }
+
     internal class NavigateToSearcher
     {
         private readonly INavigateToSearcherHost _host;
@@ -27,11 +36,13 @@ internal class NavigateToSearcher
         private readonly INavigateToSearchCallback _callback;
         private readonly string _searchPattern;
         private readonly IImmutableSet<string> _kinds;
-        private readonly IStreamingProgressTracker _progress;
+        private readonly IStreamingProgressTracker _progress_doNotAccessDirectly;
 
         private readonly Document? _activeDocument;
         private readonly ImmutableArray<Document> _visibleDocuments;
 
+        private int _remainingProgressItems;
+
         private NavigateToSearcher(
             INavigateToSearcherHost host,
             Solution solution,
@@ -46,7 +57,7 @@ private NavigateToSearcher(
             _callback = callback;
             _searchPattern = searchPattern;
             _kinds = kinds;
-            _progress = new StreamingProgressTracker((current, maximum, ct) =>
+            _progress_doNotAccessDirectly = new StreamingProgressTracker((current, maximum, ct) =>
             {
                 callback.ReportProgress(current, maximum);
                 return new ValueTask();
@@ -75,7 +86,28 @@ public static NavigateToSearcher Create(
             return new NavigateToSearcher(host, solution, asyncListener, callback, searchPattern, kinds);
         }
 
-        internal async Task SearchAsync(bool searchCurrentDocument, CancellationToken cancellationToken)
+        private async Task AddProgressItemsAsync(int count, CancellationToken cancellationToken)
+        {
+            Debug.Assert(count >= 0);
+            Debug.Assert(_remainingProgressItems >= 0);
+            Interlocked.Add(ref _remainingProgressItems, count);
+            await _progress_doNotAccessDirectly.AddItemsAsync(count, cancellationToken).ConfigureAwait(false);
+        }
+
+        private async Task ProgressItemsCompletedAsync(int count, CancellationToken cancellationToken)
+        {
+            var newValue = Interlocked.Add(ref _remainingProgressItems, -count);
+            Debug.Assert(newValue >= 0);
+            await _progress_doNotAccessDirectly.ItemsCompletedAsync(count, cancellationToken).ConfigureAwait(false);
+        }
+
+        public Task SearchAsync(bool searchCurrentDocument, CancellationToken cancellationToken)
+            => SearchAsync(searchCurrentDocument, NavigateToSearchScope.AllDocuments, cancellationToken);
+
+        public async Task SearchAsync(
+            bool searchCurrentDocument,
+            NavigateToSearchScope scope,
+            CancellationToken cancellationToken)
         {
             var isFullyLoaded = true;
 
@@ -94,7 +126,7 @@ internal async Task SearchAsync(bool searchCurrentDocument, CancellationToken ca
                     // totally hydrated the oop side.  Until that happens, we'll attempt to return cached data from languages
                     // that support that.
                     isFullyLoaded = await _host.IsFullyLoadedAsync(cancellationToken).ConfigureAwait(false);
-                    await SearchAllProjectsAsync(isFullyLoaded, cancellationToken).ConfigureAwait(false);
+                    await SearchAllProjectsAsync(isFullyLoaded, scope, cancellationToken).ConfigureAwait(false);
                 }
             }
             catch (OperationCanceledException)
@@ -102,8 +134,11 @@ internal async Task SearchAsync(bool searchCurrentDocument, CancellationToken ca
             }
             finally
             {
-                // providing this extra information will make UI to show indication to users
-                // that result might not contain full data
+                // Ensure that we actually complete all our remaining progress items so that the progress bar completes.
+                await ProgressItemsCompletedAsync(_remainingProgressItems, cancellationToken).ConfigureAwait(false);
+                Debug.Assert(_remainingProgressItems == 0);
+
+                // Pass along isFullyLoaded so that the UI can show indication to users that results may be incomplete.
                 _callback.Done(isFullyLoaded);
             }
         }
@@ -118,57 +153,67 @@ private async Task SearchCurrentDocumentAsync(CancellationToken cancellationToke
             if (service == null)
                 return;
 
-            await _progress.AddItemsAsync(1, cancellationToken).ConfigureAwait(false);
-            try
-            {
-                await service.SearchDocumentAsync(
-                    _activeDocument, _searchPattern, _kinds,
-                    r => _callback.AddItemAsync(project, r, cancellationToken),
-                    cancellationToken).ConfigureAwait(false);
-            }
-            finally
-            {
-                await _progress.ItemCompletedAsync(cancellationToken).ConfigureAwait(false);
-            }
+            await AddProgressItemsAsync(1, cancellationToken).ConfigureAwait(false);
+            await service.SearchDocumentAsync(
+                _activeDocument, _searchPattern, _kinds,
+                r => _callback.AddItemAsync(project, r, cancellationToken),
+                cancellationToken).ConfigureAwait(false);
         }
 
-        private async Task SearchAllProjectsAsync(bool isFullyLoaded, CancellationToken cancellationToken)
+        private async Task SearchAllProjectsAsync(
+            bool isFullyLoaded,
+            NavigateToSearchScope scope,
+            CancellationToken cancellationToken)
         {
             var seenItems = new HashSet<INavigateToSearchResult>(NavigateToSearchResultComparer.Instance);
             var orderedProjects = GetOrderedProjectsToProcess();
-            var searchGeneratedDocuments = isFullyLoaded;
 
-            var projectCount = orderedProjects.Sum(g => g.Length);
+            var searchRegularDocuments = scope.HasFlag(NavigateToSearchScope.RegularDocuments);
+            var searchGeneratedDocuments = scope.HasFlag(NavigateToSearchScope.GeneratedDocuments);
+            Debug.Assert(searchRegularDocuments || searchGeneratedDocuments);
 
-            // We do at least two passes.  One for loaded docs.  One for source generated docs.
-            await _progress.AddItemsAsync(projectCount * 2, cancellationToken).ConfigureAwait(false);
+            var projectCount = orderedProjects.Sum(g => g.Length);
 
-            if (!isFullyLoaded)
+            if (isFullyLoaded)
             {
-                // We need an additional pass to look through cached docs.
-                await _progress.AddItemsAsync(projectCount, cancellationToken).ConfigureAwait(false);
+                // We may do up to two passes.  One for loaded docs.  One for source generated docs.
+                await AddProgressItemsAsync(
+                    projectCount * ((searchRegularDocuments ? 1 : 0) + (searchGeneratedDocuments ? 1 : 0)),
+                    cancellationToken).ConfigureAwait(false);
 
-                await SearchCachedDocumentsAsync(orderedProjects, seenItems, cancellationToken).ConfigureAwait(false);
+                if (searchRegularDocuments)
+                    await SearchFullyLoadedProjectsAsync(orderedProjects, seenItems, cancellationToken).ConfigureAwait(false);
 
-                // If searching cached data returned any results, then we're done.  We've at least shown some results
-                // to the user.  That will hopefully serve them well enough until the solution fully loads.
-                if (seenItems.Count > 0)
-                {
-                    // Ensure that we actually complete all our workitems so that the progress bar completes.
-                    await _progress.ItemsCompletedAsync(projectCount * 2, cancellationToken).ConfigureAwait(false);
-                    return;
-                }
+                if (searchGeneratedDocuments)
+                    await SearchGeneratedDocumentsAsync(seenItems, cancellationToken).ConfigureAwait(false);
             }
+            else
+            {
+                // If we're not fully loaded, we only search regular documents.  Generated documents must wait until
+                // we're fully loaded (and thus have all the information necessary to properly run generators).
+                if (searchRegularDocuments)
+                {
+                    // We do at least two passes.  One for cached docs.  One for normal docs.
+                    await AddProgressItemsAsync(
+                        projectCount * 2,
+                        cancellationToken).ConfigureAwait(false);
+
+                    await SearchCachedDocumentsAsync(orderedProjects, seenItems, cancellationToken).ConfigureAwait(false);
 
-            await SearchFullyLoadedProjectsAsync(orderedProjects, seenItems, cancellationToken).ConfigureAwait(false);
-            await SearchGeneratedDocumentsAsync(seenItems, cancellationToken).ConfigureAwait(false);
+                    // If searching cached data returned any results, then we're done.  We've at least shown some results
+                    // to the user.  That will hopefully serve them well enough until the solution fully loads.
+                    if (seenItems.Count > 0)
+                        return;
+
+                    await SearchFullyLoadedProjectsAsync(orderedProjects, seenItems, cancellationToken).ConfigureAwait(false);
 
-            // Report a telemetry even to track if we found uncached items after failing to find cached items.
-            // In practice if we see that we are always finding uncached items, then it's likely something
-            // has broken in the caching system since we would expect to normally find values there.  Specifically
-            // we expect: foundFullItems <<< not foundFullItems.
-            if (!isFullyLoaded)
-                Logger.Log(FunctionId.NavigateTo_CacheItemsMiss, KeyValueLogMessage.Create(m => m["FoundFullItems"] = seenItems.Count > 0));
+                    // Report a telemetry event to track if we found uncached items after failing to find cached items.
+                    // In practice if we see that we are always finding uncached items, then it's likely something
+                    // has broken in the caching system since we would expect to normally find values there.  Specifically
+                    // we expect: foundFullItems <<< not foundFullItems.
+                    Logger.Log(FunctionId.NavigateTo_CacheItemsMiss, KeyValueLogMessage.Create(m => m["FoundFullItems"] = seenItems.Count > 0));
+                }
+            }
         }
 
         /// <summary>
@@ -293,7 +338,7 @@ await processProjectAsync(service, project, result =>
                 finally
                 {
                     // after each project is searched, increment our progress.
-                    await _progress.ItemCompletedAsync(cancellationToken).ConfigureAwait(false);
+                    await ProgressItemsCompletedAsync(count: 1, cancellationToken).ConfigureAwait(false);
                 }
             }
         }
@@ -320,7 +365,7 @@ private Task SearchCachedDocumentsAsync(
             HashSet<INavigateToSearchResult> seenItems,
             CancellationToken cancellationToken)
         {
-            // We searched cached information in parallel.  This is because there's no syncing step when searching cached
+            // We search cached information in parallel.  This is because there's no syncing step when searching cached
             // docs.  As such, we can just send a request for all projects in parallel to our OOP host and have it read
             // and search the local DB easily.  The DB can easily scale to feed all the threads trying to read from it
             // and we can get high throughput just processing everything in parallel.
diff --git a/src/VisualStudio/Core/Def/Implementation/Progression/GraphProvider.cs b/src/VisualStudio/Core/Def/Implementation/Progression/GraphProvider.cs
index 616538256944c..92a0b27abc7b3 100644
--- a/src/VisualStudio/Core/Def/Implementation/Progression/GraphProvider.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Progression/GraphProvider.cs
@@ -10,6 +10,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.NavigateTo;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.VisualStudio.GraphModel;
 using Microsoft.VisualStudio.GraphModel.CodeSchema;
@@ -136,11 +137,15 @@ internal static List<IGraphQuery> GetGraphQueries(
 
                 if (searchParameters != null)
                 {
-                    // WARNING: searchParameters.SearchQuery returns an IVsSearchQuery object, which
-                    // is a COM type. Therefore, it's probably best to grab the values we want now
-                    // rather than get surprised by COM marshalling later.
-                    graphQueries.Add(new SearchGraphQuery(
-                        searchParameters.SearchQuery.SearchString, threadingContext, asyncListener));
+                    // WARNING: searchParameters.SearchQuery returns an IVsSearchQuery object, which is a COM type.
+                    // Therefore, it's probably best to grab the values we want now rather than get surprised by COM
+                    // marshalling later.
+                    //
+                    // Create two queries.  One to find results in normal docs, and one to find results in generated
+                    // docs.  That way if the generated docs take a long time we can still report the regular doc
+                    // results immediately.
+                    graphQueries.Add(new SearchGraphQuery(searchParameters.SearchQuery.SearchString, NavigateToSearchScope.RegularDocuments, threadingContext, asyncListener));
+                    graphQueries.Add(new SearchGraphQuery(searchParameters.SearchQuery.SearchString, NavigateToSearchScope.GeneratedDocuments, threadingContext, asyncListener));
                 }
             }
 
diff --git a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/SearchGraphQuery.cs b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/SearchGraphQuery.cs
index 54763a0a89ea2..7c183928aa8b8 100644
--- a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/SearchGraphQuery.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueries/SearchGraphQuery.cs
@@ -14,18 +14,21 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.Progression
 {
     internal sealed partial class SearchGraphQuery : IGraphQuery
     {
+        private readonly string _searchPattern;
+        private readonly NavigateToSearchScope _searchScope;
         private readonly IThreadingContext _threadingContext;
         private readonly IAsynchronousOperationListener _asyncListener;
-        private readonly string _searchPattern;
 
         public SearchGraphQuery(
             string searchPattern,
+            NavigateToSearchScope searchScope,
             IThreadingContext threadingContext,
             IAsynchronousOperationListener asyncListener)
         {
             _threadingContext = threadingContext;
             _asyncListener = asyncListener;
             _searchPattern = searchPattern;
+            _searchScope = searchScope;
         }
 
         public async Task<GraphBuilder> GetGraphAsync(Solution solution, IGraphContext context, CancellationToken cancellationToken)
@@ -40,7 +43,7 @@ public async Task<GraphBuilder> GetGraphAsync(Solution solution, IGraphContext c
                 NavigateToUtilities.GetKindsProvided(solution),
                 _threadingContext.DisposalToken);
 
-            await searcher.SearchAsync(searchCurrentDocument: false, cancellationToken).ConfigureAwait(false);
+            await searcher.SearchAsync(searchCurrentDocument: false, _searchScope, cancellationToken).ConfigureAwait(false);
 
             return graphBuilder;
         }
diff --git a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueryManager.cs b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueryManager.cs
index d5d278a403db1..744779f300135 100644
--- a/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueryManager.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Progression/GraphQueryManager.cs
@@ -156,25 +156,28 @@ private static async Task PopulateContextGraphAsync(Solution solution, List<IGra
             try
             {
                 var cancellationToken = context.CancelToken;
-                var graphBuilderTasks = graphQueries.Select(q => q.GetGraphAsync(solution, context, cancellationToken)).ToArray();
-                var graphBuilders = await Task.WhenAll(graphBuilderTasks).ConfigureAwait(false);
 
                 // Perform the actual graph transaction 
-                using var transaction = new GraphTransactionScope();
-
-                // Remove any links that may have been added by a previous population. We don't
-                // remove nodes to maintain node identity, matching the behavior of the old
-                // providers.
-                context.Graph.Links.Clear();
+                using (var transaction1 = new GraphTransactionScope())
+                {
+                    // Remove any links that may have been added by a previous population. We don't
+                    // remove nodes to maintain node identity, matching the behavior of the old
+                    // providers.
+                    context.Graph.Links.Clear();
+                    transaction1.Complete();
+                }
 
-                foreach (var graphBuilder in graphBuilders)
+                foreach (var query in graphQueries)
                 {
-                    graphBuilder.ApplyToGraph(context.Graph, cancellationToken);
+                    var graphBuilder = await query.GetGraphAsync(solution, context, cancellationToken).ConfigureAwait(false);
 
+                    using var transaction2 = new GraphTransactionScope();
+
+                    graphBuilder.ApplyToGraph(context.Graph, cancellationToken);
                     context.OutputNodes.AddAll(graphBuilder.GetCreatedNodes(cancellationToken));
-                }
 
-                transaction.Complete();
+                    transaction2.Complete();
+                }
             }
             catch (Exception ex) when (FatalError.ReportAndPropagateUnlessCanceled(ex, ErrorSeverity.Diagnostic))
             {
diff --git a/src/VisualStudio/Core/Test/Progression/SearchGraphQueryTests_NavigateTo.vb b/src/VisualStudio/Core/Test/Progression/SearchGraphQueryTests_NavigateTo.vb
index 922e30c5f4970..169119fdbe56d 100644
--- a/src/VisualStudio/Core/Test/Progression/SearchGraphQueryTests_NavigateTo.vb
+++ b/src/VisualStudio/Core/Test/Progression/SearchGraphQueryTests_NavigateTo.vb
@@ -5,6 +5,7 @@
 Imports System.Threading.Tasks
 Imports Microsoft.CodeAnalysis.Editor.Shared.Utilities
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
+Imports Microsoft.CodeAnalysis.NavigateTo
 Imports Microsoft.CodeAnalysis.Shared.TestHooks
 Imports Microsoft.CodeAnalysis.Test.Utilities
 Imports Microsoft.VisualStudio.GraphModel
@@ -27,7 +28,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Progression
 
                 Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
                 Dim outputContext = Await testState.GetGraphContextAfterQuery(
-                    New Graph(), New SearchGraphQuery("C", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
+                    New Graph(), New SearchGraphQuery("C", NavigateToSearchScope.AllDocuments, threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
 
                 AssertSimplifiedGraphIs(
                     outputContext.Graph,
@@ -60,7 +61,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Progression
 
                 Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
                 Dim outputContext = Await testState.GetGraphContextAfterQuery(
-                    New Graph(), New SearchGraphQuery("F", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
+                    New Graph(), New SearchGraphQuery("F", NavigateToSearchScope.AllDocuments, threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
 
                 AssertSimplifiedGraphIs(
                     outputContext.Graph,
@@ -93,7 +94,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Progression
 
                 Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
                 Dim outputContext = Await testState.GetGraphContextAfterQuery(
-                    New Graph(), New SearchGraphQuery("M", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
+                    New Graph(), New SearchGraphQuery("M", NavigateToSearchScope.AllDocuments, threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
 
                 AssertSimplifiedGraphIs(
                     outputContext.Graph,
@@ -139,7 +140,7 @@ End Namespace
 
                 Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
                 Dim outputContext = Await testState.GetGraphContextAfterQuery(
-                    New Graph(), New SearchGraphQuery("C", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
+                    New Graph(), New SearchGraphQuery("C", NavigateToSearchScope.AllDocuments, threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
 
                 AssertSimplifiedGraphIs(
                     outputContext.Graph,
@@ -189,7 +190,7 @@ End Namespace
 
                 Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
                 Dim outputContext = Await testState.GetGraphContextAfterQuery(
-                    New Graph(), New SearchGraphQuery("Goo", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
+                    New Graph(), New SearchGraphQuery("Goo", NavigateToSearchScope.AllDocuments, threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
 
                 AssertSimplifiedGraphIs(
                     outputContext.Graph,
@@ -235,7 +236,7 @@ End Namespace
 
                 Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
                 Dim outputContext = Await testState.GetGraphContextAfterQuery(
-                    New Graph(), New SearchGraphQuery("Z", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
+                    New Graph(), New SearchGraphQuery("Z", NavigateToSearchScope.AllDocuments, threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
 
                 AssertSimplifiedGraphIs(
                     outputContext.Graph,
@@ -272,7 +273,7 @@ End Namespace
 
                 Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
                 Dim outputContext = Await testState.GetGraphContextAfterQuery(
-                    New Graph(), New SearchGraphQuery("D.B", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
+                    New Graph(), New SearchGraphQuery("D.B", NavigateToSearchScope.AllDocuments, threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
 
                 AssertSimplifiedGraphIs(
                     outputContext.Graph,
@@ -305,7 +306,7 @@ End Namespace
 
                 Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
                 Dim outputContext = Await testState.GetGraphContextAfterQuery(
-                    New Graph(), New SearchGraphQuery("C.B", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
+                    New Graph(), New SearchGraphQuery("C.B", NavigateToSearchScope.AllDocuments, threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
 
                 AssertSimplifiedGraphIs(
                     outputContext.Graph,
@@ -329,7 +330,7 @@ End Namespace
 
                 Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
                 Dim outputContext = Await testState.GetGraphContextAfterQuery(
-                    New Graph(), New SearchGraphQuery("D.B", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
+                    New Graph(), New SearchGraphQuery("D.B", NavigateToSearchScope.AllDocuments, threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
 
                 AssertSimplifiedGraphIs(
                     outputContext.Graph,
@@ -362,7 +363,7 @@ End Namespace
 
                 Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
                 Dim outputContext = Await testState.GetGraphContextAfterQuery(
-                    New Graph(), New SearchGraphQuery("A.D.B", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
+                    New Graph(), New SearchGraphQuery("A.D.B", NavigateToSearchScope.AllDocuments, threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
 
                 AssertSimplifiedGraphIs(
                     outputContext.Graph,
@@ -395,7 +396,7 @@ End Namespace
 
                 Dim threadingContext = testState.Workspace.ExportProvider.GetExportedValue(Of IThreadingContext)
                 Dim outputContext = Await testState.GetGraphContextAfterQuery(
-                    New Graph(), New SearchGraphQuery("A.D.B", threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
+                    New Graph(), New SearchGraphQuery("A.D.B", NavigateToSearchScope.AllDocuments, threadingContext, AsynchronousOperationListenerProvider.NullListener), GraphContextDirection.Custom)
 
                 ' When searching, don't descend into projects with a null FilePath because they are artifacts and not
                 ' representable in the Solution Explorer, e.g., Venus projects create sub-projects with a null file

From dca8ab39272fb9bf3c6b7b6c9f53ace9a6a7139a Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Thu, 13 Jan 2022 17:06:40 -0800
Subject: [PATCH 353/444] Support 'this' and 'Me' as context variables

---
 .../ContextVariableArgumentProviderTests.cs   | 78 +++++++++++++++++++
 .../ContextVariableArgumentProviderTests.vb   | 73 +++++++++++++++++
 .../ContextVariableArgumentProvider.cs        |  7 ++
 ...AbstractContextVariableArgumentProvider.cs | 47 +++++++++--
 .../ContextVariableArgumentProvider.vb        | 32 ++++++++
 5 files changed, 229 insertions(+), 8 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/ContextVariableArgumentProviderTests.cs b/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/ContextVariableArgumentProviderTests.cs
index 84456834eafe5..acb913736e4e8 100644
--- a/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/ContextVariableArgumentProviderTests.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/ArgumentProviders/ContextVariableArgumentProviderTests.cs
@@ -125,6 +125,84 @@ void Target({parameterType} arg)
             await VerifyDefaultValueAsync(markup, expectedDefaultValue: null, previousDefaultValue: "prior");
         }
 
+        [Theory]
+        [InlineData("C")]
+        [InlineData("B")]
+        [InlineData("I")]
+        public async Task TestThisInstance(string parameterType)
+        {
+            var markup = $@"
+using System.Collections.Generic;
+interface I {{ }}
+
+class B {{ }}
+
+class C : B, I
+{{
+    void Method()
+    {{
+        this.Target($$);
+    }}
+
+    void Target({parameterType} arg)
+    {{
+    }}
+}}
+";
+
+            await VerifyDefaultValueAsync(markup, "this");
+            await VerifyDefaultValueAsync(markup, expectedDefaultValue: null, previousDefaultValue: "prior");
+        }
+
+        [Theory]
+        [InlineData("object")]
+        [InlineData("string")]
+        public async Task TestThisInstanceNotProvided1(string parameterType)
+        {
+            var markup = $@"
+using System.Collections.Generic;
+interface I {{ }}
+
+class B {{ }}
+
+class C : B, I
+{{
+    void Method()
+    {{
+        this.Target($$);
+    }}
+
+    void Target({parameterType} arg)
+    {{
+    }}
+}}
+";
+
+            await VerifyDefaultValueAsync(markup, null);
+        }
+
+        [Fact]
+        public async Task TestThisInstanceNotProvided2()
+        {
+            var markup = $@"
+using System.Collections.Generic;
+
+class C
+{{
+    static void Method()
+    {{
+        Target($$);
+    }}
+
+    static void Target(C arg)
+    {{
+    }}
+}}
+";
+
+            await VerifyDefaultValueAsync(markup, null);
+        }
+
         // Note: The current implementation checks for exact type match for primitive types. If this changes, some of
         // these tests may need to be updated to account for the new behavior.
         [Theory]
diff --git a/src/EditorFeatures/VisualBasicTest/Completion/ArgumentProviders/ContextVariableArgumentProviderTests.vb b/src/EditorFeatures/VisualBasicTest/Completion/ArgumentProviders/ContextVariableArgumentProviderTests.vb
index bb4d7872101a0..e93ae272337e6 100644
--- a/src/EditorFeatures/VisualBasicTest/Completion/ArgumentProviders/ContextVariableArgumentProviderTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/Completion/ArgumentProviders/ContextVariableArgumentProviderTests.vb
@@ -80,6 +80,79 @@ End Class
             Await VerifyDefaultValueAsync(markup, expectedDefaultValue:=Nothing, previousDefaultValue:="prior")
         End Function
 
+        <Theory>
+        <InlineData("C")>
+        <InlineData("B")>
+        <InlineData("I")>
+        Public Async Function TestMeInstance(parameterType As String) As Task
+            Dim markup = $"
+Imports System.Collections.Generic
+
+Interface I : End Interface
+Class B : End Class
+
+Class C
+    Inherits B
+    Implements I
+
+    Sub Method()
+        Me.Target($$)
+    End Sub
+
+    Sub Target(arg As {parameterType})
+    End Sub
+End Class
+"
+
+            Await VerifyDefaultValueAsync(markup, "Me")
+            Await VerifyDefaultValueAsync(markup, expectedDefaultValue:=Nothing, previousDefaultValue:="prior")
+        End Function
+
+        <Theory>
+        <InlineData("Object")>
+        <InlineData("String")>
+        Public Async Function TestMeInstanceNotProvided1(parameterType As String) As Task
+            Dim markup = $"
+Imports System.Collections.Generic
+
+Interface I : End Interface
+Class B : End Class
+
+Class C
+    Inherits B
+    Implements I
+
+    Sub Method()
+        Me.Target($$)
+    End Sub
+
+    Sub Target(arg As {parameterType})
+    End Sub
+End Class
+"
+
+            Await VerifyDefaultValueAsync(markup, Nothing)
+        End Function
+
+        <Fact>
+        Public Async Function TestMeInstanceNotProvided2() As Task
+            Dim markup = $"
+Imports System.Collections.Generic
+
+Class C
+
+    Shared Sub Method()
+        Target($$)
+    End Sub
+
+    Shared Sub Target(arg As C)
+    End Sub
+End Class
+"
+
+            Await VerifyDefaultValueAsync(markup, Nothing)
+        End Function
+
         ' Note: The current implementation checks for exact type and name match. If this changes, some of these tests
         ' may need to be updated to account for the new behavior.
         <Theory>
diff --git a/src/Features/CSharp/Portable/Completion/Providers/ContextVariableArgumentProvider.cs b/src/Features/CSharp/Portable/Completion/Providers/ContextVariableArgumentProvider.cs
index 95c2ad546dc09..8fd8b96510e1f 100644
--- a/src/Features/CSharp/Portable/Completion/Providers/ContextVariableArgumentProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/Providers/ContextVariableArgumentProvider.cs
@@ -4,8 +4,10 @@
 
 using System;
 using System.Composition;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Completion;
+using Microsoft.CodeAnalysis.CSharp.Extensions.ContextQuery;
 using Microsoft.CodeAnalysis.Host.Mef;
 
 namespace Microsoft.CodeAnalysis.CSharp.Completion.Providers
@@ -21,6 +23,11 @@ public ContextVariableArgumentProvider()
         {
         }
 
+        protected override string ThisOrMeKeyword => SyntaxFacts.GetText(SyntaxKind.ThisKeyword);
+
+        protected override bool IsInstanceContext(SyntaxTree syntaxTree, SyntaxToken targetToken, SemanticModel semanticModel, CancellationToken cancellationToken)
+            => syntaxTree.IsInstanceContext(targetToken, semanticModel, cancellationToken);
+
         public override async Task ProvideArgumentAsync(ArgumentContext context)
         {
             await base.ProvideArgumentAsync(context).ConfigureAwait(false);
diff --git a/src/Features/Core/Portable/Completion/Providers/AbstractContextVariableArgumentProvider.cs b/src/Features/Core/Portable/Completion/Providers/AbstractContextVariableArgumentProvider.cs
index af07362191704..91a7bdd9e6fea 100644
--- a/src/Features/Core/Portable/Completion/Providers/AbstractContextVariableArgumentProvider.cs
+++ b/src/Features/Core/Portable/Completion/Providers/AbstractContextVariableArgumentProvider.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Operations;
 using Microsoft.CodeAnalysis.Shared.Extensions;
@@ -14,12 +15,16 @@ namespace Microsoft.CodeAnalysis.Completion
     /// </summary>
     internal abstract class AbstractContextVariableArgumentProvider : ArgumentProvider
     {
-        public override Task ProvideArgumentAsync(ArgumentContext context)
+        protected abstract string ThisOrMeKeyword { get; }
+
+        protected abstract bool IsInstanceContext(SyntaxTree syntaxTree, SyntaxToken targetToken, SemanticModel semanticModel, CancellationToken cancellationToken);
+
+        public override async Task ProvideArgumentAsync(ArgumentContext context)
         {
             if (context.PreviousValue is not null)
             {
                 // This argument provider does not attempt to replace arguments already in code.
-                return Task.CompletedTask;
+                return;
             }
 
             var requireExactType = context.Parameter.Type.IsSpecialType()
@@ -28,6 +33,7 @@ public override Task ProvideArgumentAsync(ArgumentContext context)
 
             // First try to find a local variable
             ISymbol? bestSymbol = null;
+            string? bestSymbolName = null;
             CommonConversion bestConversion = default;
             foreach (var symbol in symbols)
             {
@@ -44,10 +50,11 @@ public override Task ProvideArgumentAsync(ArgumentContext context)
 
             if (bestSymbol is not null)
             {
-                context.DefaultValue = bestSymbol.Name;
-                return Task.CompletedTask;
+                context.DefaultValue = bestSymbolName;
+                return;
             }
 
+            // Next try fields and properties of the current type
             foreach (var symbol in symbols)
             {
                 ISymbol candidate;
@@ -70,14 +77,37 @@ public override Task ProvideArgumentAsync(ArgumentContext context)
 
             if (bestSymbol is not null)
             {
-                context.DefaultValue = bestSymbol.Name;
-                return Task.CompletedTask;
+                context.DefaultValue = bestSymbolName;
+                return;
             }
 
-            return Task.CompletedTask;
+            // Finally, if the invocation occurs in an instance context, check the current type ('this' or 'Me')
+            var tree = context.SemanticModel.SyntaxTree;
+            var targetToken = await tree.GetTouchingTokenAsync(context.Position, context.CancellationToken).ConfigureAwait(false);
+            if (IsInstanceContext(tree, targetToken, context.SemanticModel, context.CancellationToken))
+            {
+                var enclosingSymbol = context.SemanticModel.GetEnclosingSymbol(targetToken.SpanStart, context.CancellationToken);
+                while (enclosingSymbol is IMethodSymbol { MethodKind: MethodKind.LocalFunction or MethodKind.AnonymousFunction } method)
+                {
+                    // It is allowed to reference the instance (`this`) within a local function or anonymous function,
+                    // as long as the containing method allows it
+                    enclosingSymbol = enclosingSymbol.ContainingSymbol;
+                }
+
+                if (enclosingSymbol is IMethodSymbol { ContainingType: { } containingType })
+                {
+                    CheckCandidate(containingType, ThisOrMeKeyword);
+                }
+            }
+
+            if (bestSymbol is not null)
+            {
+                context.DefaultValue = bestSymbolName;
+                return;
+            }
 
             // Local functions
-            void CheckCandidate(ISymbol candidate)
+            void CheckCandidate(ISymbol candidate, string? overridingName = null)
             {
                 if (candidate.GetSymbolType() is not { } symbolType)
                 {
@@ -105,6 +135,7 @@ void CheckCandidate(ISymbol candidate)
                 }
 
                 bestSymbol = candidate;
+                bestSymbolName = overridingName ?? bestSymbol.Name;
                 bestConversion = conversion;
             }
 
diff --git a/src/Features/VisualBasic/Portable/Completion/Providers/ContextVariableArgumentProvider.vb b/src/Features/VisualBasic/Portable/Completion/Providers/ContextVariableArgumentProvider.vb
index 9cd00c88f7fc1..60d0513fc0746 100644
--- a/src/Features/VisualBasic/Portable/Completion/Providers/ContextVariableArgumentProvider.vb
+++ b/src/Features/VisualBasic/Portable/Completion/Providers/ContextVariableArgumentProvider.vb
@@ -3,8 +3,10 @@
 ' See the LICENSE file in the project root for more information.
 
 Imports System.Composition
+Imports System.Threading
 Imports Microsoft.CodeAnalysis.Completion
 Imports Microsoft.CodeAnalysis.Host.Mef
+Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.Completion.Providers
     <ExportArgumentProvider(NameOf(ContextVariableArgumentProvider), LanguageNames.VisualBasic)>
@@ -17,5 +19,35 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Completion.Providers
         <Obsolete(MefConstruction.ImportingConstructorMessage, True)>
         Public Sub New()
         End Sub
+
+        Protected Overrides ReadOnly Property ThisOrMeKeyword As String
+            Get
+                Return SyntaxFacts.GetText(SyntaxKind.MeKeyword)
+            End Get
+        End Property
+
+        Protected Overrides Function IsInstanceContext(syntaxTree As SyntaxTree, targetToken As SyntaxToken, semanticModel As SemanticModel, cancellationToken As CancellationToken) As Boolean
+            ' Uses logic from MeKeywordRecommender, restricted by knowledge that this is an invocation within an
+            ' expression
+            If targetToken.GetInnermostDeclarationContext().IsKind(SyntaxKind.ClassBlock, SyntaxKind.StructureBlock) Then
+                If targetToken.GetContainingMemberBlockBegin().TypeSwitch(
+                    Function(methodBase As MethodBaseSyntax) Not methodBase.Modifiers.Any(SyntaxKind.SharedKeyword),
+                    Function(propertyStatement As PropertyStatementSyntax) Not propertyStatement.Modifiers.Any(SyntaxKind.SharedKeyword),
+                    Function(eventStatement As EventStatementSyntax) Not eventStatement.Modifiers.Any(SyntaxKind.SharedKeyword)) Then
+
+                    Return True
+                End If
+
+                Dim containingMember = targetToken.GetContainingMember()
+                If TypeOf containingMember Is FieldDeclarationSyntax Then
+                    Dim fieldDecl = DirectCast(containingMember, FieldDeclarationSyntax)
+                    If Not fieldDecl.Modifiers.Any(SyntaxKind.SharedKeyword) Then
+                        Return True
+                    End If
+                End If
+            End If
+
+            Return False
+        End Function
     End Class
 End Namespace

From a43f1c8f6ff8e4b191381b0514750f4cf1e32159 Mon Sep 17 00:00:00 2001
From: David Wengier <david.wengier@microsoft.com>
Date: Fri, 14 Jan 2022 14:44:53 +1100
Subject: [PATCH 354/444] Add GlassTestsHotReloadService external access
 (#58456)

Co-authored-by: Isadora Sophia <isaecia@gmail.com>
---
 eng/Versions.props                            |   2 +-
 .../Microsoft.CodeAnalysis.Features.csproj    |   1 +
 .../Debugger/GlassTestsHotReloadService.cs    | 116 ++++++++++++++++++
 ...odeAnalysis.ExternalAccess.Debugger.csproj |   2 +
 4 files changed, 120 insertions(+), 1 deletion(-)
 create mode 100644 src/Tools/ExternalAccess/Debugger/GlassTestsHotReloadService.cs

diff --git a/eng/Versions.props b/eng/Versions.props
index ac7ff9e44210f..ff6a57b0a4690 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -126,7 +126,7 @@
     <MicrosoftVisualStudioCompositionVersion>16.9.20</MicrosoftVisualStudioCompositionVersion>
     <MicrosoftVisualStudioCoreUtilityVersion>$(VisualStudioEditorNewPackagesVersion)</MicrosoftVisualStudioCoreUtilityVersion>
     <MicrosoftVisualStudioDebuggerUIInterfacesVersion>17.2.0-beta.21616.2</MicrosoftVisualStudioDebuggerUIInterfacesVersion>
-    <MicrosoftVisualStudioDebuggerContractsVersion>17.2.0-beta.21616.2</MicrosoftVisualStudioDebuggerContractsVersion>
+    <MicrosoftVisualStudioDebuggerContractsVersion>17.2.0-beta.22063.1</MicrosoftVisualStudioDebuggerContractsVersion>
     <MicrosoftVisualStudioDebuggerEngineimplementationVersion>17.0.1042805-preview</MicrosoftVisualStudioDebuggerEngineimplementationVersion>
     <MicrosoftVisualStudioDebuggerMetadataimplementationVersion>17.0.1042805-preview</MicrosoftVisualStudioDebuggerMetadataimplementationVersion>
     <MicrosoftVisualStudioDesignerInterfacesVersion>$(MicrosoftVisualStudioShellPackagesVersion)</MicrosoftVisualStudioDesignerInterfacesVersion>
diff --git a/src/Features/Core/Portable/Microsoft.CodeAnalysis.Features.csproj b/src/Features/Core/Portable/Microsoft.CodeAnalysis.Features.csproj
index 0d40e2fb88215..6596e33cc5a8d 100644
--- a/src/Features/Core/Portable/Microsoft.CodeAnalysis.Features.csproj
+++ b/src/Features/Core/Portable/Microsoft.CodeAnalysis.Features.csproj
@@ -29,6 +29,7 @@
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.InteractiveFeatures" />
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.LanguageServer.Protocol" />
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.LanguageServer.Protocol.UnitTests" />
+    <InternalsVisibleTo Include="Microsoft.CodeAnalysis.ExternalAccess.Debugger" />
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.ExternalAccess.UnitTesting" />
     <InternalsVisibleTo Include="Microsoft.VisualStudio.LanguageServices" />
     <InternalsVisibleTo Include="Microsoft.VisualStudio.LanguageServices.CodeLens" />
diff --git a/src/Tools/ExternalAccess/Debugger/GlassTestsHotReloadService.cs b/src/Tools/ExternalAccess/Debugger/GlassTestsHotReloadService.cs
new file mode 100644
index 0000000000000..32e0797a8366e
--- /dev/null
+++ b/src/Tools/ExternalAccess/Debugger/GlassTestsHotReloadService.cs
@@ -0,0 +1,116 @@
+// 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.EditAndContinue;
+using Microsoft.CodeAnalysis.Editor.Implementation.EditAndContinue;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.VisualStudio.Debugger.Contracts.EditAndContinue;
+using Microsoft.VisualStudio.Debugger.Contracts.HotReload;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.Debugger
+{
+    internal sealed class GlassTestsHotReloadService
+    {
+        private static readonly ActiveStatementSpanProvider s_noActiveStatementSpanProvider =
+           (_, _, _) => ValueTaskFactory.FromResult(ImmutableArray<ActiveStatementSpan>.Empty);
+
+        private readonly IManagedHotReloadService _debuggerService;
+
+        private readonly IEditAndContinueWorkspaceService _encService;
+        private DebuggingSessionId _sessionId;
+
+        public GlassTestsHotReloadService(HostWorkspaceServices services, IManagedHotReloadService debuggerService)
+        {
+            _encService = services.GetRequiredService<IEditAndContinueWorkspaceService>();
+            _debuggerService = debuggerService;
+        }
+
+        public async Task StartSessionAsync(Solution solution, CancellationToken cancellationToken)
+        {
+            var newSessionId = await _encService.StartDebuggingSessionAsync(
+                solution,
+                new ManagedHotReloadServiceImpl(_debuggerService),
+                captureMatchingDocuments: ImmutableArray<DocumentId>.Empty,
+                captureAllMatchingDocuments: true,
+                reportDiagnostics: false,
+                cancellationToken).ConfigureAwait(false);
+
+            Contract.ThrowIfFalse(_sessionId == default, "Session already started");
+            _sessionId = newSessionId;
+        }
+
+        private DebuggingSessionId GetSessionId()
+        {
+            var sessionId = _sessionId;
+            Contract.ThrowIfFalse(sessionId != default, "Session has not started");
+
+            return sessionId;
+        }
+
+        public void EnterBreakState()
+        {
+            _encService.BreakStateOrCapabilitiesChanged(GetSessionId(), inBreakState: true, out _);
+        }
+
+        public void ExitBreakState()
+        {
+            _encService.BreakStateOrCapabilitiesChanged(GetSessionId(), inBreakState: false, out _);
+        }
+
+        public void OnCapabilitiesChanged()
+        {
+            _encService.BreakStateOrCapabilitiesChanged(GetSessionId(), inBreakState: null, out _);
+        }
+
+        public void CommitSolutionUpdate()
+        {
+            _encService.CommitSolutionUpdate(GetSessionId(), out _);
+        }
+
+        public void DiscardSolutionUpdate()
+        {
+            _encService.DiscardSolutionUpdate(GetSessionId());
+        }
+
+        public void EndDebuggingSession()
+        {
+            _encService.EndDebuggingSession(GetSessionId(), out _);
+            _sessionId = default;
+        }
+
+        public async ValueTask<bool> HasChangesAsync(Solution solution, string? sourceFilePath, CancellationToken cancellationToken)
+        {
+            var sessionId = _sessionId;
+            if (sessionId == default)
+            {
+                return false;
+            }
+
+            return await _encService.HasChangesAsync(sessionId, solution, s_noActiveStatementSpanProvider, sourceFilePath, cancellationToken).ConfigureAwait(false);
+        }
+
+        public async ValueTask<ManagedModuleUpdates> GetEditAndContinueUpdatesAsync(Solution solution, CancellationToken cancellationToken)
+        {
+            var result = await _encService.EmitSolutionUpdateAsync(GetSessionId(), solution, s_noActiveStatementSpanProvider, cancellationToken).ConfigureAwait(false);
+
+            return result.ModuleUpdates.FromContract();
+        }
+
+        public async ValueTask<ManagedHotReloadUpdates> GetHotReloadUpdatesAsync(Solution solution, CancellationToken cancellationToken)
+        {
+            var result = await _encService.EmitSolutionUpdateAsync(GetSessionId(), solution, s_noActiveStatementSpanProvider, cancellationToken).ConfigureAwait(false);
+
+            var updates = result.ModuleUpdates.Updates.SelectAsArray(
+                update => new ManagedHotReloadUpdate(update.Module, update.ILDelta, update.MetadataDelta, update.PdbDelta, update.UpdatedTypes));
+
+            var diagnostics = await EmitSolutionUpdateResults.GetHotReloadDiagnosticsAsync(solution, result.GetDiagnosticData(solution), result.RudeEdits, result.GetSyntaxErrorData(solution), cancellationToken).ConfigureAwait(false);
+
+            return new ManagedHotReloadUpdates(updates, diagnostics.FromContract());
+        }
+    }
+}
diff --git a/src/Tools/ExternalAccess/Debugger/Microsoft.CodeAnalysis.ExternalAccess.Debugger.csproj b/src/Tools/ExternalAccess/Debugger/Microsoft.CodeAnalysis.ExternalAccess.Debugger.csproj
index ffa1250dac7da..26415884a85b0 100644
--- a/src/Tools/ExternalAccess/Debugger/Microsoft.CodeAnalysis.ExternalAccess.Debugger.csproj
+++ b/src/Tools/ExternalAccess/Debugger/Microsoft.CodeAnalysis.ExternalAccess.Debugger.csproj
@@ -20,6 +20,7 @@
       ⚠ ONLY VISUAL STUDIO DEBUGGER ASSEMBLIES MAY BE ADDED HERE ⚠
     -->
     <InternalsVisibleTo Include="VsDebugPresentationPackage" Key="$(VisualStudioDebuggerKey)" />
+    <InternalsVisibleTo Include="Microsoft.VisualStudio.Debugger.BrokeredServices.Glass" Key="$(VisualStudioDebuggerKey)" />
   </ItemGroup>
 
   <ItemGroup>
@@ -29,6 +30,7 @@
   <ItemGroup>
     <ProjectReference Include="..\..\..\Compilers\Core\Portable\Microsoft.CodeAnalysis.csproj" />
     <ProjectReference Include="..\..\..\EditorFeatures\Core\Microsoft.CodeAnalysis.EditorFeatures.csproj" />
+    <ProjectReference Include="..\..\..\Features\Core\Portable\Microsoft.CodeAnalysis.Features.csproj" />
     <ProjectReference Include="..\..\..\Workspaces\Core\Portable\Microsoft.CodeAnalysis.Workspaces.csproj" />
   </ItemGroup>
 

From cd89d6fc4c5e0aeda1502d068ad2521eff31ba3a Mon Sep 17 00:00:00 2001
From: "dotnet-maestro[bot]"
 <42748379+dotnet-maestro[bot]@users.noreply.github.com>
Date: Fri, 14 Jan 2022 15:06:36 +0000
Subject: [PATCH 355/444] Update dependencies from
 https://github.com/dotnet/arcade build 20220113.6 (#58859)

[main] Update dependencies from dotnet/arcade
---
 eng/Version.Details.xml                       |  8 +++---
 eng/common/cross/toolchain.cmake              | 11 ++++++--
 eng/common/post-build/publish-using-darc.ps1  | 28 +------------------
 .../templates/post-build/post-build.yml       |  1 -
 global.json                                   |  4 +--
 5 files changed, 16 insertions(+), 36 deletions(-)

diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index ce5700e572d70..b3471fe8a3c6f 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -13,18 +13,18 @@
     </Dependency>
   </ProductDependencies>
   <ToolsetDependencies>
-    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="7.0.0-beta.22063.1">
+    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="7.0.0-beta.22063.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>7a7ba506eed201288d4182fce8b380b22bdd73cb</Sha>
+      <Sha>ecf92bbdc4354adc1960fa53808e87d91624f9b5</Sha>
       <SourceBuild RepoName="arcade" ManagedOnly="true" />
     </Dependency>
     <Dependency Name="Microsoft.Net.Compilers.Toolset" Version="4.1.0-2.21609.7">
       <Uri>https://github.com/dotnet/roslyn</Uri>
       <Sha>818313426323d979747781a17c78860c833776da</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="7.0.0-beta.22063.1">
+    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="7.0.0-beta.22063.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>7a7ba506eed201288d4182fce8b380b22bdd73cb</Sha>
+      <Sha>ecf92bbdc4354adc1960fa53808e87d91624f9b5</Sha>
     </Dependency>
   </ToolsetDependencies>
 </Dependencies>
diff --git a/eng/common/cross/toolchain.cmake b/eng/common/cross/toolchain.cmake
index f7878dddd3921..fba2afda438b6 100644
--- a/eng/common/cross/toolchain.cmake
+++ b/eng/common/cross/toolchain.cmake
@@ -37,6 +37,13 @@ elseif(TARGET_ARCH_NAME STREQUAL "arm")
   if(TIZEN)
     set(TIZEN_TOOLCHAIN "armv7hl-tizen-linux-gnueabihf/9.2.0")
   endif()
+elseif(TARGET_ARCH_NAME STREQUAL "armv6")
+  set(CMAKE_SYSTEM_PROCESSOR armv6l)
+  if(EXISTS ${CROSS_ROOTFS}/usr/lib/gcc/armv6-alpine-linux-musleabihf)
+    set(TOOLCHAIN "armv6-alpine-linux-musleabihf")
+  else()
+    set(TOOLCHAIN "arm-linux-gnueabihf")
+  endif()
 elseif(TARGET_ARCH_NAME STREQUAL "arm64")
   set(CMAKE_SYSTEM_PROCESSOR aarch64)
   if(EXISTS ${CROSS_ROOTFS}/usr/lib/gcc/aarch64-alpine-linux-musl)
@@ -60,7 +67,7 @@ elseif (ILLUMOS)
   set(CMAKE_SYSTEM_PROCESSOR "x86_64")
   set(TOOLCHAIN "x86_64-illumos")
 else()
-  message(FATAL_ERROR "Arch is ${TARGET_ARCH_NAME}. Only armel, arm, arm64, s390x and x86 are supported!")
+  message(FATAL_ERROR "Arch is ${TARGET_ARCH_NAME}. Only armel, arm, armv6, arm64, s390x and x86 are supported!")
 endif()
 
 if(DEFINED ENV{TOOLCHAIN})
@@ -194,7 +201,7 @@ endif()
 
 # Specify compile options
 
-if((TARGET_ARCH_NAME MATCHES "^(arm|armel|arm64|s390x)$" AND NOT ANDROID) OR ILLUMOS)
+if((TARGET_ARCH_NAME MATCHES "^(arm|armv6|armel|arm64|s390x)$" AND NOT ANDROID) OR ILLUMOS)
   set(CMAKE_C_COMPILER_TARGET ${TOOLCHAIN})
   set(CMAKE_CXX_COMPILER_TARGET ${TOOLCHAIN})
   set(CMAKE_ASM_COMPILER_TARGET ${TOOLCHAIN})
diff --git a/eng/common/post-build/publish-using-darc.ps1 b/eng/common/post-build/publish-using-darc.ps1
index 2427ca6b6aec7..8508397d77640 100644
--- a/eng/common/post-build/publish-using-darc.ps1
+++ b/eng/common/post-build/publish-using-darc.ps1
@@ -5,13 +5,8 @@ param(
   [Parameter(Mandatory=$true)][string] $MaestroToken,
   [Parameter(Mandatory=$false)][string] $MaestroApiEndPoint = 'https://maestro-prod.westus2.cloudapp.azure.com',
   [Parameter(Mandatory=$true)][string] $WaitPublishingFinish,
-  [Parameter(Mandatory=$false)][string] $EnableSourceLinkValidation,
-  [Parameter(Mandatory=$false)][string] $EnableSigningValidation,
-  [Parameter(Mandatory=$false)][string] $EnableNugetValidation,
-  [Parameter(Mandatory=$false)][string] $PublishInstallersAndChecksums,
   [Parameter(Mandatory=$false)][string] $ArtifactsPublishingAdditionalParameters,
-  [Parameter(Mandatory=$false)][string] $SymbolPublishingAdditionalParameters,
-  [Parameter(Mandatory=$false)][string] $SigningValidationAdditionalParameters
+  [Parameter(Mandatory=$false)][string] $SymbolPublishingAdditionalParameters
 )
 
 try {
@@ -35,27 +30,6 @@ try {
     $optionalParams.Add("--no-wait") | Out-Null
   }
 
-  if ("false" -ne $PublishInstallersAndChecksums) {
-    $optionalParams.Add("--publish-installers-and-checksums") | Out-Null
-  }
-
-  if ("true" -eq $EnableNugetValidation) {
-    $optionalParams.Add("--validate-nuget") | Out-Null
-  }
-
-  if ("true" -eq $EnableSourceLinkValidation) {
-    $optionalParams.Add("--validate-sourcelinkchecksums") | Out-Null
-  }
-
-  if ("true" -eq $EnableSigningValidation) {
-    $optionalParams.Add("--validate-signingchecksums") | Out-Null
-
-    if ("" -ne $SigningValidationAdditionalParameters) {
-      $optionalParams.Add("--signing-validation-parameters") | Out-Null
-      $optionalParams.Add($SigningValidationAdditionalParameters) | Out-Null
-    }
-  }
-
   & $darc add-build-to-channel `
   --id $buildId `
   --publishing-infra-version $PublishingInfraVersion `
diff --git a/eng/common/templates/post-build/post-build.yml b/eng/common/templates/post-build/post-build.yml
index d1759337abe6a..8985b429c8543 100644
--- a/eng/common/templates/post-build/post-build.yml
+++ b/eng/common/templates/post-build/post-build.yml
@@ -263,6 +263,5 @@ stages:
             -AzdoToken '$(publishing-dnceng-devdiv-code-r-build-re)'
             -MaestroToken '$(MaestroApiAccessToken)'
             -WaitPublishingFinish true
-            -PublishInstallersAndChecksums ${{ parameters.publishInstallersAndChecksums }}
             -ArtifactsPublishingAdditionalParameters '${{ parameters.artifactsPublishingAdditionalParameters }}'
             -SymbolPublishingAdditionalParameters '${{ parameters.symbolPublishingAdditionalParameters }}'
\ No newline at end of file
diff --git a/global.json b/global.json
index 133b313ed80bc..d13f8db2dc177 100644
--- a/global.json
+++ b/global.json
@@ -12,7 +12,7 @@
     "xcopy-msbuild": "16.10.0-preview2"
   },
   "msbuild-sdks": {
-    "Microsoft.DotNet.Arcade.Sdk": "7.0.0-beta.22063.1",
-    "Microsoft.DotNet.Helix.Sdk": "7.0.0-beta.22063.1"
+    "Microsoft.DotNet.Arcade.Sdk": "7.0.0-beta.22063.6",
+    "Microsoft.DotNet.Helix.Sdk": "7.0.0-beta.22063.6"
   }
 }

From 0d16b5be6d726c45d4be24295c6052002f043754 Mon Sep 17 00:00:00 2001
From: Charles Stoner <10732005+cston@users.noreply.github.com>
Date: Fri, 14 Jan 2022 08:29:14 -0800
Subject: [PATCH 356/444] Clarify breaking change requirement for constructor
 in 'struct' with field initializers (#58812)

---
 .../Compiler Breaking Changes - DotNet 6.md   | 21 +++++++++++++++++++
 .../Compiler Breaking Changes - DotNet 7.md   |  9 --------
 2 files changed, 21 insertions(+), 9 deletions(-)

diff --git a/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 6.md b/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 6.md
index a530a0ab2d7dc..478fca0892c81 100644
--- a/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 6.md	
+++ b/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 6.md	
@@ -108,3 +108,24 @@ These are _function_type_conversions_.
         }
     }
     ```
+
+4. In Visual Studio 17.1, `struct` type declarations with field initializers must include an explicitly declared constructor. Additionally, all fields must be definitely assigned in `struct` instance constructors that do not have a `: this()` initializer so any previously unassigned fields must be assigned from the added constructor or from field initializers.
+
+    For instance, the following results in an error in 17.1:
+    ```csharp
+    struct S
+    {
+        int X = 1; // error: struct with field initializers must include an explicitly declared constructor
+        int Y;
+    }
+    ```
+
+    The error could be resolved by adding a constructor and assigning the other field.
+    ```csharp
+    struct S
+    {
+        int X = 1;
+        int Y;
+        public S() { Y = 0; } // ok
+    }
+    ```
diff --git a/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 7.md b/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 7.md
index 3239e1081ddcf..1c5bd04f9a240 100644
--- a/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 7.md	
+++ b/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 7.md	
@@ -77,12 +77,3 @@ https://github.com/dotnet/roslyn/issues/5775
 
     //prints now: "{C}" - not "{X}}"
     ```
-
-6. Starting with Visual Studio 17.1, `struct` type declarations with field initializers must include an explicitly declared constructor.
-
-    ```csharp
-    struct S
-    {
-        int X = 1; // error: struct with field initializers must include an explicitly declared constructor
-    }
-    ```

From b13f58709aaa8d38d8279d892f5db293e04cbee9 Mon Sep 17 00:00:00 2001
From: AlekseyTs <AlekseyTs@users.noreply.github.com>
Date: Fri, 14 Jan 2022 09:30:46 -0800
Subject: [PATCH 357/444] Add "Utf8 String Literals" to the feature list
 (#58851)

---
 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 4188a05fdd7ee..09c5fb02a475b 100644
--- a/docs/Language Feature Status.md	
+++ b/docs/Language Feature Status.md	
@@ -26,7 +26,7 @@ efforts behind them.
 | [Cache delegates for static method group](https://github.com/dotnet/roslyn/issues/5835) | main | [In Progress](https://github.com/dotnet/roslyn/pull/58288) | [pawchen](https://github.com/pawchen) | [AlekseyTs](https://github.com/AlekseyTs), [jcouv](https://github.com/jcouv) | [AlekseyTs](https://github.com/AlekseyTs) |
 | [Switch on ReadOnlySpan<char>](https://github.com/dotnet/csharplang/issues/1881) | main | [In Progress](https://github.com/dotnet/roslyn/pull/44388) | [YairHalberstadt ](https://github.com/YairHalberstadt) | [cston](https://github.com/cston), [RikkiGibson](https://github.com/RikkiGibson) | [jcouv](https://github.com/jcouv) |
 | [nameof accessing instance memebers](https://github.com/dotnet/roslyn/issues/40229) | main | [In Progress](https://github.com/dotnet/roslyn/pull/48754) | [YairHalberstadt ](https://github.com/YairHalberstadt) | [333fred](https://github.com/333fred), [AlekseyTs](https://github.com/AlekseyTs)  | [333fred](https://github.com/333fred) |
-
+| [Utf8 String Literals](https://github.com/dotnet/csharplang/issues/184) | [Utf8StringLiterals](https://github.com/dotnet/roslyn/tree/features/Utf8StringLiterals) | [In Progress](https://github.com/dotnet/roslyn/issues/58848) | [AlekseyTs](https://github.com/AlekseyTs) | [cston](https://github.com/cston), [RikkiGibson](https://github.com/RikkiGibson) | [MadsTorgersen](https://github.com/MadsTorgersen) |
   
 # C# 10.0
 

From 95c7400c9e3f71930bf56c2bb9face3425f12fc1 Mon Sep 17 00:00:00 2001
From: Jonathon Marolf <jmarolf@microsoft.com>
Date: Fri, 14 Jan 2022 10:34:01 -0800
Subject: [PATCH 358/444] Allow patch releases of the SDK to be used

Accorsing to the documentation [here](https://docs.microsoft.com/dotnet/core/tools/global-json) setting `rollForward` to `latestPatch` should allow newer SDKs to be used _only_ if the patch digits of the SDK have changed.

So under these vallues and `6.0.1xx` SDK is valid but `6.0.200` would not be.
---
 global.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/global.json b/global.json
index d13f8db2dc177..9464a838e0edc 100644
--- a/global.json
+++ b/global.json
@@ -2,7 +2,7 @@
   "sdk": {
     "version": "6.0.100",
     "allowPrerelease": true,
-    "rollForward": "disable"
+    "rollForward": "latestPatch"
   },
   "tools": {
     "dotnet": "6.0.100",

From 9318267f77badb6e6f8e4388f723971e62eb9d88 Mon Sep 17 00:00:00 2001
From: Shen Chen <cos_ifne@hotmail.com>
Date: Fri, 14 Jan 2022 11:53:45 -0800
Subject: [PATCH 359/444] Change tfm to net46

---
 .../IntegrationTests/Workspace/WorkspacesNetCore.cs          | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspacesNetCore.cs b/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspacesNetCore.cs
index b516cb97d23e2..ee5634df0a1de 100644
--- a/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspacesNetCore.cs
+++ b/src/VisualStudio/IntegrationTest/IntegrationTests/Workspace/WorkspacesNetCore.cs
@@ -40,7 +40,7 @@ public override void MetadataReference()
             VisualStudio.SolutionExplorer.EditProjectFile(project);
             VisualStudio.Editor.SetText(@"<Project Sdk=""Microsoft.NET.Sdk"">
   <PropertyGroup>
-    <TargetFramework>net461</TargetFramework>
+    <TargetFramework>net46</TargetFramework>
   </PropertyGroup>
 </Project>");
             VisualStudio.SolutionExplorer.SaveAll();
@@ -49,9 +49,6 @@ public override void MetadataReference()
             // https://github.com/dotnet/roslyn/issues/34264
             VisualStudio.Workspace.WaitForAllAsyncOperations(Helper.HangMitigatingTimeout);
             VisualStudio.SolutionExplorer.OpenFile(project, "Class1.cs");
-            var referenceAssemblies = new ProjectUtils.PackageReference("Microsoft.NETFramework.ReferenceAssemblies.net461", "1.0.2");
-            VisualStudio.SolutionExplorer.AddPackageReference(project, referenceAssemblies);
-            VisualStudio.SolutionExplorer.RestoreNuGetPackages(project);
             base.MetadataReference();
         }
 

From 29c69155f9f070762ac4d3da994339d28d026609 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Fri, 14 Jan 2022 13:11:35 -0800
Subject: [PATCH 360/444] Remove formatting suppression for tuple syntax
 (#58810)

---
 dotnet-tools.json                                               | 2 +-
 eng/Versions.props                                              | 2 +-
 eng/test-build-correctness.ps1                                  | 2 +-
 .../CSharp/Portable/Binder/EarlyWellKnownAttributeBinder.cs     | 2 --
 4 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/dotnet-tools.json b/dotnet-tools.json
index 0d36407e3c7fa..c232231ac428f 100644
--- a/dotnet-tools.json
+++ b/dotnet-tools.json
@@ -2,7 +2,7 @@
   "isRoot": true,
   "tools": {
     "dotnet-format": {
-      "version": "6.0.240501",
+      "version": "6.0.257007",
       "commands": [
         "dotnet-format"
       ]
diff --git a/eng/Versions.props b/eng/Versions.props
index ba98342d82a7a..1bc3d89e8b959 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -24,7 +24,7 @@
     <MicrosoftCodeAnalysisTestingVersion>1.1.1-beta1.21480.3</MicrosoftCodeAnalysisTestingVersion>
     <MicrosoftVisualStudioExtensibilityTestingVersion>0.1.122-beta</MicrosoftVisualStudioExtensibilityTestingVersion>
     <!-- CodeStyleAnalyzerVersion should we updated together with version of dotnet-format in dotnet-tools.json -->
-    <CodeStyleAnalyzerVersion>4.0.0-3.final</CodeStyleAnalyzerVersion>
+    <CodeStyleAnalyzerVersion>4.0.1</CodeStyleAnalyzerVersion>
     <VisualStudioEditorPackagesVersion>16.10.230</VisualStudioEditorPackagesVersion>
     <VisualStudioEditorNewPackagesVersion>17.0.487</VisualStudioEditorNewPackagesVersion>
     <ILAsmPackageVersion>5.0.0-alpha1.19409.1</ILAsmPackageVersion>
diff --git a/eng/test-build-correctness.ps1 b/eng/test-build-correctness.ps1
index 29aec700aef10..082207feceb7a 100644
--- a/eng/test-build-correctness.ps1
+++ b/eng/test-build-correctness.ps1
@@ -75,7 +75,7 @@ try {
   # Verify the state of our generated syntax files
   Write-Host "Checking generated compiler files"
   Exec-Block { & (Join-Path $PSScriptRoot "generate-compiler-code.ps1") -test -configuration:$configuration }
-  Exec-Console dotnet "tool run dotnet-format . --include-generated --include src/Compilers/CSharp/Portable/Generated/ src/Compilers/VisualBasic/Portable/Generated/ src/ExpressionEvaluator/VisualBasic/Source/ResultProvider/Generated/ --check -f"
+  Exec-Console dotnet "tool run dotnet-format whitespace . --folder --include-generated --include src/Compilers/CSharp/Portable/Generated/ src/Compilers/VisualBasic/Portable/Generated/ src/ExpressionEvaluator/VisualBasic/Source/ResultProvider/Generated/ --verify-no-changes"
   Write-Host ""
 
   exit 0
diff --git a/src/Compilers/CSharp/Portable/Binder/EarlyWellKnownAttributeBinder.cs b/src/Compilers/CSharp/Portable/Binder/EarlyWellKnownAttributeBinder.cs
index 149a790972594..5a2040024594f 100644
--- a/src/Compilers/CSharp/Portable/Binder/EarlyWellKnownAttributeBinder.cs
+++ b/src/Compilers/CSharp/Portable/Binder/EarlyWellKnownAttributeBinder.cs
@@ -39,13 +39,11 @@ internal EarlyWellKnownAttributeBinder(Binder enclosing)
         // Hide the GetAttribute overload which takes a diagnostic bag.
         // This ensures that diagnostics from the early bound attributes are never preserved.
         [Obsolete("EarlyWellKnownAttributeBinder has a better overload - GetAttribute(AttributeSyntax, NamedTypeSymbol, out bool)", true)]
-#pragma warning disable format // https://github.com/dotnet/roslyn/issues/56498
         internal new (CSharpAttributeData, BoundAttribute) GetAttribute(
             AttributeSyntax node, NamedTypeSymbol boundAttributeType,
             Action<AttributeSyntax> beforeAttributePartBound,
             Action<AttributeSyntax> afterAttributePartBound,
             BindingDiagnosticBag diagnostics)
-#pragma warning restore format
         {
             Debug.Assert(false, "Don't call this overload.");
             diagnostics.Add(ErrorCode.ERR_InternalError, node.Location);

From 62420a0c08c08515be01cb723a9dd3f2f37c32c7 Mon Sep 17 00:00:00 2001
From: Joey Robichaud <jorobich@microsoft.com>
Date: Fri, 14 Jan 2022 10:49:12 -0800
Subject: [PATCH 361/444] Clone source from mirror for DartLab integration
 tests

---
 azure-pipelines-integration-dartlab.yml | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/azure-pipelines-integration-dartlab.yml b/azure-pipelines-integration-dartlab.yml
index 63f243e7f1de4..3744c777f092d 100644
--- a/azure-pipelines-integration-dartlab.yml
+++ b/azure-pipelines-integration-dartlab.yml
@@ -1,6 +1,7 @@
 # Roslyn integration test pipeline for validating against branch builds of VS.
 
 trigger: none # Manual trigger for now
+pr: none # Manual trigger for now
 
 resources:
   pipelines:
@@ -15,6 +16,13 @@ resources:
     type: git
     name: DartLab.Templates
     ref: refs/heads/dev/bradwhit/RemoveCheckoutNone
+  - repository: RoslynMirror
+    endpoint: dnceng/internal dotnet-roslyn
+    type: git
+    name: internal/dotnet-roslyn
+    ref: $(Build.SourceBranchName)
+    trigger:
+    - main
 
 variables:
 - name: XUNIT_LOGS
@@ -54,6 +62,7 @@ stages:
         filePath: $(DartLab.Path)\Scripts\VisualStudio\Build\Get-VisualStudioDropName.ps1
         arguments: -DropNamePrefix 'Products' -VstsDropUrlsJson '$(Pipeline.Workspace)\VisualStudioBuildUnderTest\BuildArtifacts\VstsDropUrls.json' -OutVariableName 'VisualStudio.BuildUnderTest.ProductsDropName'
     deployAndRunTestsStepList:
+    - checkout: RoslynMirror
     - template: eng/pipelines/test-integration-job.yml
       parameters:
         configuration: $(_configuration)

From 471dbca899b866ab527e28b5d19f736c41a93e40 Mon Sep 17 00:00:00 2001
From: Rikki Gibson <rigibson@microsoft.com>
Date: Fri, 14 Jan 2022 13:24:41 -0800
Subject: [PATCH 362/444] Avoid unnecessary array creation (#58821)

---
 src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs        | 2 +-
 .../Lowering/LocalRewriter/LocalRewriter_AssignmentOperator.vb  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
index b2a274c519301..8194f135ac121 100644
--- a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
+++ b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
@@ -1288,7 +1288,7 @@ forSemanticModel.Syntax is { } semanticModelSyntax &&
 
                             if (hasBody)
                             {
-                                boundStatements = boundStatements.Concat(ImmutableArray.Create(loweredBodyOpt));
+                                boundStatements = boundStatements.Concat(loweredBodyOpt);
                             }
 
                             var factory = new SyntheticBoundNodeFactory(methodSymbol, syntax, compilationState, diagsForCurrentMethod);
diff --git a/src/Compilers/VisualBasic/Portable/Lowering/LocalRewriter/LocalRewriter_AssignmentOperator.vb b/src/Compilers/VisualBasic/Portable/Lowering/LocalRewriter/LocalRewriter_AssignmentOperator.vb
index fbf0a7371c11c..874a2322c203c 100644
--- a/src/Compilers/VisualBasic/Portable/Lowering/LocalRewriter/LocalRewriter_AssignmentOperator.vb
+++ b/src/Compilers/VisualBasic/Portable/Lowering/LocalRewriter/LocalRewriter_AssignmentOperator.vb
@@ -235,7 +235,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                 Return RewriteReceiverArgumentsAndGenerateAccessorCall(node.Syntax,
                                   setMethod,
                                   setNode.ReceiverOpt,
-                                  setNode.Arguments.Concat(ImmutableArray.Create(node.Right)),
+                                  setNode.Arguments.Concat(node.Right),
                                   node.ConstantValueOpt,
                                   isLValue:=False,
                                   suppressObjectClone:=False,

From 1a5c819281188ac6e6f37119e4177539d062b7a8 Mon Sep 17 00:00:00 2001
From: "dotnet-maestro[bot]"
 <42748379+dotnet-maestro[bot]@users.noreply.github.com>
Date: Sat, 15 Jan 2022 00:43:08 +0000
Subject: [PATCH 363/444] [main] Update dependencies from dotnet/roslyn
 (#58423)

[main] Update dependencies from dotnet/roslyn


 - Merge branch 'main' into darc-main-8b613451-a3bf-43ce-baa2-0b5705ec5b93
---
 eng/Version.Details.xml | 4 ++--
 eng/Versions.props      | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index b3471fe8a3c6f..1213dfd204e1b 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -18,9 +18,9 @@
       <Sha>ecf92bbdc4354adc1960fa53808e87d91624f9b5</Sha>
       <SourceBuild RepoName="arcade" ManagedOnly="true" />
     </Dependency>
-    <Dependency Name="Microsoft.Net.Compilers.Toolset" Version="4.1.0-2.21609.7">
+    <Dependency Name="Microsoft.Net.Compilers.Toolset" Version="4.1.0-3.22057.9">
       <Uri>https://github.com/dotnet/roslyn</Uri>
-      <Sha>818313426323d979747781a17c78860c833776da</Sha>
+      <Sha>a07da6871b3b7f53611b0f95530561286dd1e529</Sha>
     </Dependency>
     <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="7.0.0-beta.22063.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
diff --git a/eng/Versions.props b/eng/Versions.props
index 1bc3d89e8b959..463595578559e 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -15,7 +15,7 @@
       Keep the setting conditional. The toolset sets the assembly version to 42.42.42.42 if not set explicitly.
     -->
     <AssemblyVersion Condition="'$(OfficialBuild)' == 'true' or '$(DotNetUseShippingVersions)' == 'true'">$(MajorVersion).$(MinorVersion).0.0</AssemblyVersion>
-    <MicrosoftNetCompilersToolsetVersion>4.1.0-2.21609.7</MicrosoftNetCompilersToolsetVersion>
+    <MicrosoftNetCompilersToolsetVersion>4.1.0-3.22057.9</MicrosoftNetCompilersToolsetVersion>
   </PropertyGroup>
   <PropertyGroup>
     <!-- Versions used by several individual references below -->

From d1383e7b718ffdaa55f2b06126c6a78bca14f072 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Fri, 14 Jan 2022 16:50:19 -0800
Subject: [PATCH 364/444] Steps to investigate CI flakiness with async-streams
 tests (#58864)

---
 .../Emit/CodeGen/CodeGenAsyncIteratorTests.cs |  6 ++
 .../Core/Compilation/IRuntimeEnvironment.cs   |  1 +
 .../Test/Utilities/CSharp/CSharpTestBase.cs   | 59 ++++++++++++++++---
 3 files changed, 58 insertions(+), 8 deletions(-)

diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncIteratorTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncIteratorTests.cs
index 33bdb13a7ccad..59e075cdefb02 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncIteratorTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncIteratorTests.cs
@@ -11,6 +11,7 @@
 using System.Text;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.Emit;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Roslyn.Test.Utilities;
 using Xunit;
@@ -129,6 +130,11 @@ private static void VerifyMissingType(string source, WellKnownType type, params
             comp.VerifyEmitDiagnostics(expected);
         }
 
+        // Instrumentation to investigate CI failure: https://github.com/dotnet/roslyn/issues/34207
+        private CSharpCompilation CreateCompilationWithAsyncIterator(string source, CSharpCompilationOptions options = null, CSharpParseOptions parseOptions = null)
+            => CreateCompilationWithTasksExtensions(new[] { (CSharpTestSource)CSharpTestBase.Parse(source, filename: "source", parseOptions), CSharpTestBase.Parse(AsyncStreamsTypes, filename: "AsyncStreamsTypes", parseOptions) },
+                options: options, parseOptions: parseOptions);
+
         private CSharpCompilation CreateCompilationWithAsyncIterator(CSharpTestSource source, CSharpCompilationOptions options = null, CSharpParseOptions parseOptions = null)
             => CreateCompilationWithTasksExtensions(new[] { source, AsyncStreamsTypes }, options: options, parseOptions: parseOptions);
 
diff --git a/src/Compilers/Test/Core/Compilation/IRuntimeEnvironment.cs b/src/Compilers/Test/Core/Compilation/IRuntimeEnvironment.cs
index c17c634d67adb..faf86ba2a4501 100644
--- a/src/Compilers/Test/Core/Compilation/IRuntimeEnvironment.cs
+++ b/src/Compilers/Test/Core/Compilation/IRuntimeEnvironment.cs
@@ -242,6 +242,7 @@ EmitOptions emitOptions
             var assembly = default(ImmutableArray<byte>);
             var pdbStream = (emitOptions.DebugInformationFormat != DebugInformationFormat.Embedded) ? new MemoryStream() : null;
 
+            // Note: don't forget to name the source inputs to get them embedded for debugging
             var embeddedTexts = compilation.SyntaxTrees
                 .Select(t => (filePath: t.FilePath, text: t.GetText()))
                 .Where(t => t.text.CanBeEmbedded && !string.IsNullOrEmpty(t.filePath))
diff --git a/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs b/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs
index ef99a145bc866..1b78800f91fbb 100644
--- a/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs
+++ b/src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs
@@ -269,20 +269,38 @@ public AsyncIteratorStateMachineAttribute(Type stateMachineType) : base(stateMac
 
 namespace System.Threading.Tasks.Sources
 {
+    // From https://github.com/dotnet/runtime/blob/f580068aa93fb3c6d5fbc7e33f6cd7d52fa86b24/src/libraries/Microsoft.Bcl.AsyncInterfaces/src/System/Threading/Tasks/Sources/ManualResetValueTaskSourceCore.cs
     using System.Diagnostics;
     using System.Runtime.ExceptionServices;
     using System.Runtime.InteropServices;
 
+    /// <summary>Provides the core logic for implementing a manual-reset <see cref=""IValueTaskSource""/> or <see cref=""IValueTaskSource{TResult}""/>.</summary>
+    /// <typeparam name=""TResult""></typeparam>
     [StructLayout(LayoutKind.Auto)]
     public struct ManualResetValueTaskSourceCore<TResult>
     {
+        /// <summary>
+        /// The callback to invoke when the operation completes if <see cref=""OnCompleted""/> was called before the operation completed,
+        /// or <see cref=""ManualResetValueTaskSourceCoreShared.s_sentinel""/> if the operation completed before a callback was supplied,
+        /// or null if a callback hasn't yet been provided and the operation hasn't yet completed.
+        /// </summary>
         private Action<object> _continuation;
+        /// <summary>State to pass to <see cref=""_continuation""/>.</summary>
         private object _continuationState;
+        /// <summary><see cref=""ExecutionContext""/> to flow to the callback, or null if no flowing is required.</summary>
         private ExecutionContext _executionContext;
+        /// <summary>
+        /// A ""captured"" <see cref=""SynchronizationContext""/> or <see cref=""TaskScheduler""/> with which to invoke the callback,
+        /// or null if no special context is required.
+        /// </summary>
         private object _capturedContext;
+        /// <summary>Whether the current operation has completed.</summary>
         private bool _completed;
+        /// <summary>The result with which the operation succeeded, or the default value if it hasn't yet completed or failed.</summary>
         private TResult _result;
+        /// <summary>The exception with which the operation failed, or null if it hasn't yet completed or completed successfully.</summary>
         private ExceptionDispatchInfo _error;
+        /// <summary>The current version of this value, used to help prevent misuse.</summary>
         private short _version;
 
         /// <summary>Gets or sets whether to force continuations to run asynchronously.</summary>
@@ -303,42 +321,56 @@ public void Reset()
             _continuationState = null;
         }
 
+        /// <summary>Completes with a successful result.</summary>
+        /// <param name=""result"">The result.</param>
         public void SetResult(TResult result)
         {
             _result = result;
             SignalCompletion();
         }
 
+        /// <summary>Complets with an error.</summary>
+        /// <param name=""error""></param>
         public void SetException(Exception error)
         {
             _error = ExceptionDispatchInfo.Capture(error);
             SignalCompletion();
         }
 
+        /// <summary>Gets the operation version.</summary>
         public short Version => _version;
 
+        /// <summary>Gets the status of the operation.</summary>
+        /// <param name=""token"">Opaque value that was provided to the <see cref=""ValueTask""/>'s constructor.</param>
         public ValueTaskSourceStatus GetStatus(short token)
         {
             ValidateToken(token);
             return
-                !_completed ? ValueTaskSourceStatus.Pending :
+                _continuation == null || !_completed ? ValueTaskSourceStatus.Pending :
                 _error == null ? ValueTaskSourceStatus.Succeeded :
                 _error.SourceException is OperationCanceledException ? ValueTaskSourceStatus.Canceled :
                 ValueTaskSourceStatus.Faulted;
         }
 
+        /// <summary>Gets the result of the operation.</summary>
+        /// <param name=""token"">Opaque value that was provided to the <see cref=""ValueTask""/>'s constructor.</param>
         public TResult GetResult(short token)
         {
             ValidateToken(token);
             if (!_completed)
             {
-                ManualResetValueTaskSourceCoreShared.ThrowInvalidOperationException();
+                throw new InvalidOperationException();
             }
 
             _error?.Throw();
             return _result;
         }
 
+        /// <summary>Schedules the continuation action for this operation.</summary>
+        /// <param name=""continuation"">The continuation to invoke when the operation has completed.</param>
+        /// <param name=""state"">The state object to pass to <paramref name=""continuation""/> when it's invoked.</param>
+        /// <param name=""token"">Opaque value that was provided to the <see cref=""ValueTask""/>'s constructor.</param>
+        /// <param name=""flags"">The flags describing the behavior of the continuation.</param>
         public void OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags)
         {
             if (continuation == null)
@@ -389,7 +421,7 @@ public void OnCompleted(Action<object> continuation, object state, short token,
                 // Operation already completed, so we need to queue the supplied callback.
                 if (!ReferenceEquals(oldContinuation, ManualResetValueTaskSourceCoreShared.s_sentinel))
                 {
-                    ManualResetValueTaskSourceCoreShared.ThrowInvalidOperationException();
+                    throw new InvalidOperationException();
                 }
 
                 switch (_capturedContext)
@@ -413,19 +445,22 @@ public void OnCompleted(Action<object> continuation, object state, short token,
             }
         }
 
+        /// <summary>Ensures that the specified token matches the current version.</summary>
+        /// <param name=""token"">The token supplied by <see cref=""ValueTask""/>.</param>
         private void ValidateToken(short token)
         {
             if (token != _version)
             {
-                ManualResetValueTaskSourceCoreShared.ThrowInvalidOperationException();
+                throw new InvalidOperationException();
             }
         }
 
+        /// <summary>Signals that the operation has completed.  Invoked after the result or error has been set.</summary>
         private void SignalCompletion()
         {
             if (_completed)
             {
-                ManualResetValueTaskSourceCoreShared.ThrowInvalidOperationException();
+                throw new InvalidOperationException();
             }
             _completed = true;
 
@@ -445,8 +480,15 @@ private void SignalCompletion()
             }
         }
 
+        /// <summary>
+        /// Invokes the continuation with the appropriate captured context / scheduler.
+        /// This assumes that if <see cref=""_executionContext""/> is not null we're already
+        /// running within that <see cref=""ExecutionContext""/>.
+        /// </summary>
         private void InvokeContinuation()
         {
+            Debug.Assert(_continuation != null);
+
             switch (_capturedContext)
             {
                 case null:
@@ -477,13 +519,14 @@ private void InvokeContinuation()
 
     internal static class ManualResetValueTaskSourceCoreShared // separated out of generic to avoid unnecessary duplication
     {
-        internal static void ThrowInvalidOperationException() => throw new InvalidOperationException();
-
         internal static readonly Action<object> s_sentinel = CompletionSentinel;
         private static void CompletionSentinel(object _) // named method to aid debugging
         {
+            // Instrumented with FailFast to investigate CI failure:
+            // https://github.com/dotnet/roslyn/issues/34207
+            System.Environment.FailFast(""The sentinel delegate should never be invoked."");
             Debug.Fail(""The sentinel delegate should never be invoked."");
-            ThrowInvalidOperationException();
+            throw new InvalidOperationException();
         }
     }
 }

From d567c5c3badb3e94b13f67459e3fac49eca009c3 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Fri, 14 Jan 2022 18:27:54 -0800
Subject: [PATCH 365/444] Initial analyzer

---
 .../Core/Analyzers/EnforceOnBuildValues.cs    |   1 +
 .../Core/Analyzers/IDEDiagnosticIds.cs        |   2 +
 .../Portable/CSharpFeaturesResources.resx     |   6 +
 ...SimplifyLambdaExpressionCodeFixProvider.cs |  80 ++++++
 ...plifyLambdaExpressionDiagnosticAnalyzer.cs | 235 ++++++++++++++++++
 5 files changed, 324 insertions(+)
 create mode 100644 src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpSimplifyLambdaExpressionCodeFixProvider.cs
 create mode 100644 src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpSimplifyLambdaExpressionDiagnosticAnalyzer.cs

diff --git a/src/Analyzers/Core/Analyzers/EnforceOnBuildValues.cs b/src/Analyzers/Core/Analyzers/EnforceOnBuildValues.cs
index 4f5e6d27eedfe..bf6a967e39024 100644
--- a/src/Analyzers/Core/Analyzers/EnforceOnBuildValues.cs
+++ b/src/Analyzers/Core/Analyzers/EnforceOnBuildValues.cs
@@ -76,6 +76,7 @@ internal static class EnforceOnBuildValues
         public const EnforceOnBuild UseImplicitObjectCreation = /*IDE0090*/ EnforceOnBuild.Recommended;
         public const EnforceOnBuild RemoveRedundantEquality = /*IDE0100*/ EnforceOnBuild.Recommended;
         public const EnforceOnBuild RemoveUnnecessaryDiscardDesignation = /*IDE0110*/ EnforceOnBuild.Recommended;
+        public const EnforceOnBuild RemoveUnnecessaryLambdaExpression = /*IDE0200*/ EnforceOnBuild.Recommended;
         public const EnforceOnBuild InvokeDelegateWithConditionalAccess = /*IDE1005*/ EnforceOnBuild.Recommended;
         public const EnforceOnBuild NamingRule = /*IDE1006*/ EnforceOnBuild.Recommended;
         public const EnforceOnBuild MatchFolderAndNamespace = /*IDE0130*/ EnforceOnBuild.Recommended;
diff --git a/src/Analyzers/Core/Analyzers/IDEDiagnosticIds.cs b/src/Analyzers/Core/Analyzers/IDEDiagnosticIds.cs
index 592390e6f38ab..364fb3468a509 100644
--- a/src/Analyzers/Core/Analyzers/IDEDiagnosticIds.cs
+++ b/src/Analyzers/Core/Analyzers/IDEDiagnosticIds.cs
@@ -169,6 +169,8 @@ internal static class IDEDiagnosticIds
 
         public const string UseParameterNullCheckingId = "IDE0190";
 
+        public const string RemoveUnnecessaryLambdaExpressionDiagnosticId = "IDE0200";
+
         // Analyzer error Ids
         public const string AnalyzerChangedId = "IDE1001";
         public const string AnalyzerDependencyConflictId = "IDE1002";
diff --git a/src/Features/CSharp/Portable/CSharpFeaturesResources.resx b/src/Features/CSharp/Portable/CSharpFeaturesResources.resx
index 345282c97cc4e..731bd2fd515a0 100644
--- a/src/Features/CSharp/Portable/CSharpFeaturesResources.resx
+++ b/src/Features/CSharp/Portable/CSharpFeaturesResources.resx
@@ -630,4 +630,10 @@
   <data name="Selection_cannot_include_top_level_statements" xml:space="preserve">
     <value>Selection cannot include top-level statements</value>
   </data>
+  <data name="Lambda_expression_can_be_removed" xml:space="preserve">
+    <value>Lambda expression can be removed</value>
+  </data>
+  <data name="Remove_unnecessary_lambda_expression" xml:space="preserve">
+    <value>Remove unnecessary lambda expression</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpSimplifyLambdaExpressionCodeFixProvider.cs b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpSimplifyLambdaExpressionCodeFixProvider.cs
new file mode 100644
index 0000000000000..a660ec7d2ea94
--- /dev/null
+++ b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpSimplifyLambdaExpressionCodeFixProvider.cs
@@ -0,0 +1,80 @@
+// 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 System;
+using System.Collections.Immutable;
+using System.Composition;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.CSharp.RemoveUnnecessaryLambdaExpression
+{
+    [ExportCodeFixProvider(LanguageNames.CSharp, Name = PredefinedCodeFixProviderNames.UsePatternMatchingIsAndCastCheckWithoutName), Shared]
+    internal partial class CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider : SyntaxEditorBasedCodeFixProvider
+    {
+        [ImportingConstructor]
+        [SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")]
+        public CSharpIsAndCastCheckWithoutNameCodeFixProvider()
+            : base(supportsFixAll: false)
+        {
+        }
+
+        public override ImmutableArray<string> FixableDiagnosticIds
+            => ImmutableArray.Create(IDEDiagnosticIds.InlineIsTypeWithoutNameCheckDiagnosticsId);
+
+        internal sealed override CodeFixCategory CodeFixCategory => CodeFixCategory.CodeStyle;
+
+        public override Task RegisterCodeFixesAsync(CodeFixContext context)
+        {
+            context.RegisterCodeFix(
+                new MyCodeAction(c => FixAsync(context.Document, context.Diagnostics.First(), c)),
+                context.Diagnostics);
+            return Task.CompletedTask;
+        }
+
+        protected override async Task FixAllAsync(
+            Document document, ImmutableArray<Diagnostic> diagnostics,
+            SyntaxEditor editor, CancellationToken cancellationToken)
+        {
+            Debug.Assert(diagnostics.Length == 1);
+            var location = diagnostics[0].Location;
+            var isExpression = (BinaryExpressionSyntax)location.FindNode(
+                getInnermostNodeForTie: true, cancellationToken: cancellationToken);
+
+            var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            var expressionTypeOpt = semanticModel.Compilation.ExpressionOfTType();
+
+            var (matches, localName) = CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.Instance.AnalyzeExpression(
+                semanticModel, isExpression, expressionTypeOpt, cancellationToken);
+
+            var updatedSemanticModel = CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.ReplaceMatches(
+                semanticModel, isExpression, localName, matches, cancellationToken);
+
+            var updatedRoot = updatedSemanticModel.SyntaxTree.GetRoot(cancellationToken);
+            editor.ReplaceNode(editor.OriginalRoot, updatedRoot);
+        }
+
+        private class MyCodeAction : CodeAction.DocumentChangeAction
+        {
+            public MyCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument)
+                : base(CSharpAnalyzersResources.Use_pattern_matching, createChangedDocument, nameof(CSharpIsAndCastCheckWithoutNameCodeFixProvider))
+            {
+            }
+
+            internal override CodeActionPriority Priority => CodeActionPriority.Low;
+        }
+    }
+}
diff --git a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpSimplifyLambdaExpressionDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpSimplifyLambdaExpressionDiagnosticAnalyzer.cs
new file mode 100644
index 0000000000000..03c02c9babd97
--- /dev/null
+++ b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpSimplifyLambdaExpressionDiagnosticAnalyzer.cs
@@ -0,0 +1,235 @@
+// 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 System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.CodeGeneration;
+using Microsoft.CodeAnalysis.CSharp.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.CSharp.Utilities;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.LanguageServices;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Shared.Utilities;
+using Microsoft.CodeAnalysis.Text;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.CSharp.RemoveUnnecessaryLambdaExpression
+{
+    /// <summary>
+    /// DiagnosticAnalyzer that looks code like <c>Goo(() => Bar())</c> and offers to convert it to <c>Goo(Bar)</c>.
+    /// This is only offered on C# 11 and above where this delegate can be cached and will not cause allocations each
+    /// time.
+    /// </summary>
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    internal class CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer : AbstractBuiltInCodeStyleDiagnosticAnalyzer
+    {
+        public CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer()
+            : base(IDEDiagnosticIds.RemoveUnnecessaryLambdaExpressionDiagnosticId,
+                   EnforceOnBuildValues.RemoveUnnecessaryLambdaExpression,
+                   option: null,
+                   LanguageNames.CSharp,
+                   new LocalizableResourceString(nameof(CSharpFeaturesResources.Remove_unnecessary_lambda_expression), CSharpFeaturesResources.ResourceManager, typeof(CSharpFeaturesResources)),
+                   new LocalizableResourceString(nameof(CSharpFeaturesResources.Lambda_expression_can_be_removed), CSharpFeaturesResources.ResourceManager, typeof(CSharpFeaturesResources)),
+                   isUnnecessary: true)
+        {
+        }
+
+        public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
+            => DiagnosticAnalyzerCategory.SemanticSpanAnalysis;
+
+        protected override void InitializeWorker(AnalysisContext context)
+        {
+            context.RegisterCompilationStartAction(context =>
+            {
+                //if (((CSharpCompilation)context.Compilation).LanguageVersion >= LanguageVersion.Preview)
+                //{
+                context.RegisterSyntaxNodeAction(
+                    AnalyzeSyntax,
+                    SyntaxKind.SimpleLambdaExpression, SyntaxKind.ParenthesizedLambdaExpression, SyntaxKind.AnonymousMethodExpression);
+                // }
+            });
+        }
+
+        private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
+        {
+            var cancellationToken = context.CancellationToken;
+            var semanticModel = context.SemanticModel;
+            var syntaxTree = semanticModel.SyntaxTree;
+
+            var anonymousFunction = (AnonymousFunctionExpressionSyntax)context.Node;
+
+            // Syntax checks first.
+
+            // Don't simplify static lambdas.  The user made them explicitly static to make it clear it doesn't capture
+            // anything.  If we get rid of the lambda it won't be clear anymore if capturing/allocs are happening or not.
+            if (anonymousFunction.Modifiers.Any(SyntaxKind.StaticKeyword))
+                return;
+
+            if (!TryGetInvocation(anonymousFunction, out var invocation, out var wasAwaited))
+                return;
+
+            // If we had an async function, but we didn't await the expression inside then we can't convert this. The
+            // underlying value was wrapped into a task, and that won't work if directly referencing the function.
+            if (wasAwaited != anonymousFunction.Modifiers.Any(SyntaxKind.AsyncKeyword))
+                return;
+
+            // We have to have an invocation in the lambda like `() => X()` or `() => expr.X()`.
+            var invokedExpression = invocation.Expression;
+            if (invokedExpression is not IdentifierNameSyntax and not MemberAccessExpressionSyntax)
+                return;
+
+            // lambda and invocation have to agree on number of parameters.
+            var parameters = GetParameters(anonymousFunction);
+            if (parameters.Count != invocation.ArgumentList.Arguments.Count)
+                return;
+
+            // parameters must be passed 1:1 from lambda to invocation.
+            for (int i = 0, n = parameters.Count - 1; i < n; i++)
+            {
+                var parameter = parameters[i];
+                var argument = invocation.ArgumentList.Arguments[i];
+
+                if (argument.Expression is not IdentifierNameSyntax argumentIdentifier)
+                    return;
+
+                if (parameter.Identifier.ValueText != argumentIdentifier.Identifier.ValueText)
+                    return;
+            }
+
+            // Looks like a reasonable candidate to simplify.  Now switch to semantics to check for sure.
+
+            // If we have `object obj = x => Goo(x);` we don't want to simplify.  The compiler warns if you write
+            // `object obj = Goo;` because of the conversion to a non-delegate type.
+            var lambdaTypeInfo = semanticModel.GetTypeInfo(anonymousFunction, cancellationToken);
+            if (lambdaTypeInfo.ConvertedType == null || lambdaTypeInfo.ConvertedType.SpecialType is SpecialType.System_Object)
+                return;
+
+            var lambdaSymbolInfo = semanticModel.GetSymbolInfo(anonymousFunction, cancellationToken);
+            if (lambdaSymbolInfo.Symbol is not IMethodSymbol lambdaMethod)
+                return;
+
+            var invokedSymbolInfo = semanticModel.GetSymbolInfo(invokedExpression, cancellationToken);
+            if (invokedSymbolInfo.Symbol is not IMethodSymbol invokedMethod)
+                return;
+
+            // Methods have to be complimentary.  That means the same number of parameters, with proper
+            // co-contravariance for the parameters and return type.
+            if (lambdaMethod.Parameters.Length != invokedMethod.Parameters.Length)
+                return;
+
+            var compilation = semanticModel.Compilation;
+
+            // Must be able to convert the invoked method return type to the lambda's return type.
+            var returnTypeConversion = compilation.ClassifyConversion(invokedMethod.ReturnType, lambdaMethod.ReturnType);
+            if (!returnTypeConversion.IsIdentityOrImplicitReference())
+                return;
+
+            for (int i = 0, n = lambdaMethod.Parameters.Length; i < n; i++)
+            {
+                var lambdaParameter = lambdaMethod.Parameters[i];
+                var invokedParameter = invokedMethod.Parameters[i];
+
+                // All the lambda parameters must be convertible to the invoked method parameters.
+                var parameterConversion = compilation.ClassifyConversion(lambdaParameter.Type, invokedParameter.Type);
+                if (!parameterConversion.IsIdentityOrImplicitReference())
+                    return;
+            }
+
+            // Semantically, this looks good to go.  Now, do an actual speculative replacement to ensure that the
+            // non-invoked method reference refers to the same method symbol, and that it converts to the same type that
+            // the lambda was.
+            var analyzer = new SpeculationAnalyzer(anonymousFunction, invokedExpression, semanticModel, cancellationToken);
+
+            var rewrittenExpression = analyzer.ReplacedExpression;
+            var rewrittenSemanticModel = analyzer.SpeculativeSemanticModel;
+
+            var rewrittenSymbolInfo = rewrittenSemanticModel.GetSymbolInfo(rewrittenExpression, cancellationToken);
+            if (rewrittenSymbolInfo.Symbol is not IMethodSymbol rewrittenMethod ||
+                !invokedMethod.Equals(rewrittenMethod))
+            {
+                return;
+            }
+
+            var rewrittenConvertedType = rewrittenSemanticModel.GetTypeInfo(rewrittenExpression, cancellationToken).ConvertedType;
+            if (!lambdaTypeInfo.ConvertedType.Equals(rewrittenConvertedType))
+                return;
+
+            var startReportSpan = TextSpan.FromBounds(anonymousFunction.SpanStart, invokedExpression.SpanStart);
+            var endReportSpan = TextSpan.FromBounds(invokedExpression.Span.End, anonymousFunction.Span.End);
+
+            context.ReportDiagnostic(DiagnosticHelper.CreateWithLocationTags(
+                Descriptor,
+                syntaxTree.GetLocation(startReportSpan),
+                ReportDiagnostic.Default,
+                additionalLocations: ImmutableArray.Create(anonymousFunction.GetLocation(), invokedExpression.GetLocation()),
+                additionalUnnecessaryLocations: ImmutableArray.Create(syntaxTree.GetLocation(endReportSpan))));
+        }
+
+        private static SeparatedSyntaxList<ParameterSyntax> GetParameters(AnonymousFunctionExpressionSyntax expression)
+            => expression switch
+            {
+                AnonymousMethodExpressionSyntax anonymousMethod => anonymousMethod.ParameterList?.Parameters ?? default,
+                SimpleLambdaExpressionSyntax simpleLambda => SyntaxFactory.SingletonSeparatedList(simpleLambda.Parameter),
+                ParenthesizedLambdaExpressionSyntax parenthesizedLambda => parenthesizedLambda.ParameterList.Parameters,
+                _ => throw ExceptionUtilities.UnexpectedValue(expression.Kind()),
+            };
+
+        private bool TryGetAnonymousFunctionInvocation(
+            AnonymousFunctionExpressionSyntax anonymousFunction,
+            [NotNullWhen(true)] out InvocationExpressionSyntax? invocation,
+            out bool wasAwaited)
+        {
+            if (anonymousFunction.ExpressionBody != null)
+                return TryGetInvocation(anonymousFunction.ExpressionBody, out invocation, out wasAwaited);
+
+            if (anonymousFunction.Block != null && anonymousFunction.Block.Statements.Count == 1)
+            {
+                var statement = anonymousFunction.Block.Statements[0];
+                if (statement is ReturnStatementSyntax { Expression: { } expression })
+                    return TryGetInvocation(expression, out invocation, out wasAwaited);
+
+                if (statement is ExpressionStatementSyntax expressionStatement)
+                    return TryGetInvocation(expressionStatement.Expression, out invocation, out wasAwaited);
+            }
+
+            invocation = null;
+            wasAwaited = false;
+            return false;
+        }
+
+        private bool TryGetInvocation(
+            ExpressionSyntax expression,
+            [NotNullWhen(true)] out InvocationExpressionSyntax? invocation,
+            out bool wasAwaited)
+        {
+            wasAwaited = false;
+
+            // if we have either `await Goo()` or `await Goo().ConfigureAwait` then unwrap to get at `Goo()`.
+            if (expression is AwaitExpressionSyntax awaitExpression)
+            {
+                wasAwaited = true;
+                expression = awaitExpression.Expression;
+                if (expression is InvocationExpressionSyntax
+                    {
+                        Expression: MemberAccessExpressionSyntax { Name.Identifier.ValueText: nameof(Task.ConfigureAwait), Expression: var underlying }
+                    })
+                {
+                    expression = underlying;
+                }
+            }
+
+            invocation = expression as InvocationExpressionSyntax;
+            return invocation != null;
+        }
+    }
+}

From 4ed7e99a55b87a29a6aa38ce30607ca4c981bbd8 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Fri, 14 Jan 2022 19:19:35 -0800
Subject: [PATCH 366/444] Add fixer

---
 ...cessaryLambdaExpressionCodeFixProvider.cs} | 44 +++++++++----------
 ...saryLambdaExpressionDiagnosticAnalyzer.cs} | 14 +-----
 .../xlf/CSharpFeaturesResources.cs.xlf        | 10 +++++
 .../xlf/CSharpFeaturesResources.de.xlf        | 10 +++++
 .../xlf/CSharpFeaturesResources.es.xlf        | 10 +++++
 .../xlf/CSharpFeaturesResources.fr.xlf        | 10 +++++
 .../xlf/CSharpFeaturesResources.it.xlf        | 10 +++++
 .../xlf/CSharpFeaturesResources.ja.xlf        | 10 +++++
 .../xlf/CSharpFeaturesResources.ko.xlf        | 10 +++++
 .../xlf/CSharpFeaturesResources.pl.xlf        | 10 +++++
 .../xlf/CSharpFeaturesResources.pt-BR.xlf     | 10 +++++
 .../xlf/CSharpFeaturesResources.ru.xlf        | 10 +++++
 .../xlf/CSharpFeaturesResources.tr.xlf        | 10 +++++
 .../xlf/CSharpFeaturesResources.zh-Hans.xlf   | 10 +++++
 .../xlf/CSharpFeaturesResources.zh-Hant.xlf   | 10 +++++
 15 files changed, 154 insertions(+), 34 deletions(-)
 rename src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/{CSharpSimplifyLambdaExpressionCodeFixProvider.cs => CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs} (53%)
 rename src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/{CSharpSimplifyLambdaExpressionDiagnosticAnalyzer.cs => CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs} (95%)

diff --git a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpSimplifyLambdaExpressionCodeFixProvider.cs b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs
similarity index 53%
rename from src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpSimplifyLambdaExpressionCodeFixProvider.cs
rename to src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs
index a660ec7d2ea94..459ec65fb8aec 100644
--- a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpSimplifyLambdaExpressionCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs
@@ -7,8 +7,6 @@
 using System;
 using System.Collections.Immutable;
 using System.Composition;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -17,23 +15,25 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.RemoveUnnecessaryLambdaExpression
 {
+    using static CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer;
+
     [ExportCodeFixProvider(LanguageNames.CSharp, Name = PredefinedCodeFixProviderNames.UsePatternMatchingIsAndCastCheckWithoutName), Shared]
     internal partial class CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider : SyntaxEditorBasedCodeFixProvider
     {
         [ImportingConstructor]
-        [SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")]
-        public CSharpIsAndCastCheckWithoutNameCodeFixProvider()
-            : base(supportsFixAll: false)
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider()
         {
         }
 
         public override ImmutableArray<string> FixableDiagnosticIds
-            => ImmutableArray.Create(IDEDiagnosticIds.InlineIsTypeWithoutNameCheckDiagnosticsId);
+            => ImmutableArray.Create(IDEDiagnosticIds.RemoveUnnecessaryLambdaExpressionDiagnosticId);
 
         internal sealed override CodeFixCategory CodeFixCategory => CodeFixCategory.CodeStyle;
 
@@ -49,32 +49,32 @@ protected override async Task FixAllAsync(
             Document document, ImmutableArray<Diagnostic> diagnostics,
             SyntaxEditor editor, CancellationToken cancellationToken)
         {
-            Debug.Assert(diagnostics.Length == 1);
-            var location = diagnostics[0].Location;
-            var isExpression = (BinaryExpressionSyntax)location.FindNode(
-                getInnermostNodeForTie: true, cancellationToken: cancellationToken);
-
-            var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
-            var expressionTypeOpt = semanticModel.Compilation.ExpressionOfTType();
+            foreach (var diagnostic in diagnostics)
+            {
+                var anonymousFunction = diagnostic.AdditionalLocations[0].FindNode(getInnermostNodeForTie: true, cancellationToken);
 
-            var (matches, localName) = CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.Instance.AnalyzeExpression(
-                semanticModel, isExpression, expressionTypeOpt, cancellationToken);
+                editor.ReplaceNode(anonymousFunction,
+                    (current, generator) =>
+                    {
+                        if (current is AnonymousFunctionExpressionSyntax anonymousFunction &&
+                            TryGetInvocation(anonymousFunction, out var invocation, out _))
+                        {
+                            return invocation.Expression.WithTriviaFrom(current);
+                        }
 
-            var updatedSemanticModel = CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.ReplaceMatches(
-                semanticModel, isExpression, localName, matches, cancellationToken);
+                        return current;
+                    });
+            }
 
-            var updatedRoot = updatedSemanticModel.SyntaxTree.GetRoot(cancellationToken);
-            editor.ReplaceNode(editor.OriginalRoot, updatedRoot);
+            return Task.CompletedTask;
         }
 
         private class MyCodeAction : CodeAction.DocumentChangeAction
         {
             public MyCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument)
-                : base(CSharpAnalyzersResources.Use_pattern_matching, createChangedDocument, nameof(CSharpIsAndCastCheckWithoutNameCodeFixProvider))
+                : base(CSharpFeaturesResources.Remove_unnecessary_lambda_expression, createChangedDocument, nameof(CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider))
             {
             }
-
-            internal override CodeActionPriority Priority => CodeActionPriority.Low;
         }
     }
 }
diff --git a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpSimplifyLambdaExpressionDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
similarity index 95%
rename from src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpSimplifyLambdaExpressionDiagnosticAnalyzer.cs
rename to src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
index 03c02c9babd97..74664184d7a06 100644
--- a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpSimplifyLambdaExpressionDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
@@ -2,24 +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 System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeStyle;
-using Microsoft.CodeAnalysis.CSharp.CodeGeneration;
-using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CSharp.Utilities;
 using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.Editing;
-using Microsoft.CodeAnalysis.LanguageServices;
-using Microsoft.CodeAnalysis.Shared.Extensions;
-using Microsoft.CodeAnalysis.Shared.Utilities;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
@@ -171,7 +161,7 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
                 Descriptor,
                 syntaxTree.GetLocation(startReportSpan),
                 ReportDiagnostic.Default,
-                additionalLocations: ImmutableArray.Create(anonymousFunction.GetLocation(), invokedExpression.GetLocation()),
+                additionalLocations: ImmutableArray.Create(anonymousFunction.GetLocation()),
                 additionalUnnecessaryLocations: ImmutableArray.Create(syntaxTree.GetLocation(endReportSpan))));
         }
 
@@ -207,7 +197,7 @@ private bool TryGetAnonymousFunctionInvocation(
             return false;
         }
 
-        private bool TryGetInvocation(
+        public static bool TryGetInvocation(
             ExpressionSyntax expression,
             [NotNullWhen(true)] out InvocationExpressionSyntax? invocation,
             out bool wasAwaited)
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.cs.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.cs.xlf
index 0973c83d3f393..d73332715ead1 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.cs.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.cs.xlf
@@ -142,6 +142,11 @@
         <target state="translated">Zjistily se konflikty.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">Nastavit privátní pole jako jenom pro čtení, kde je to možné</target>
@@ -162,6 +167,11 @@
         <target state="translated">Odebrat modifikátor new</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">Obrátit příkaz for</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.de.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.de.xlf
index 1f32da3391bfe..b1863827841a7 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.de.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.de.xlf
@@ -142,6 +142,11 @@
         <target state="translated">Konflikt(e) erkannt.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">Private Felder nach Möglichkeit als schreibgeschützt festlegen</target>
@@ -162,6 +167,11 @@
         <target state="translated">new-Modifizierer entfernen</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">for-Anweisung umkehren</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.es.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.es.xlf
index 4511fe240f950..ea7f621b83069 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.es.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.es.xlf
@@ -142,6 +142,11 @@
         <target state="translated">Conflicto(s) detectado(s).</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">Cuando sea posible, hacer que los cambios privados sean solo de lectura</target>
@@ -162,6 +167,11 @@
         <target state="translated">Quitar el modificador "new"</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">Invertir la instrucción "for"</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.fr.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.fr.xlf
index 83c192c454017..7af5f5690cbab 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.fr.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.fr.xlf
@@ -142,6 +142,11 @@
         <target state="translated">Conflit(s) détecté(s).</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">Configurer les champs privés en lecture seule quand cela est possible</target>
@@ -162,6 +167,11 @@
         <target state="translated">Supprimer le modificateur 'new'</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">Inverser l'instruction 'for'</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.it.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.it.xlf
index 059515829ba39..5a455b2964bce 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.it.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.it.xlf
@@ -142,6 +142,11 @@
         <target state="translated">Sono stati rilevati conflitti.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">Imposta i campi privati come di sola lettura quando possibile</target>
@@ -162,6 +167,11 @@
         <target state="translated">Rimuovi il modificatore 'new'</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">Inverti l'istruzione 'for'</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ja.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ja.xlf
index a730dfa534ff3..6483adbde4a26 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ja.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ja.xlf
@@ -142,6 +142,11 @@
         <target state="translated">競合が検出されました。</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">可能な場合、private フィールドを読み取り専用にする</target>
@@ -162,6 +167,11 @@
         <target state="translated">'new' 修飾子の削除</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">'for' ステートメントの反転</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ko.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ko.xlf
index 4091a3a7311f6..63edf54b98f10 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ko.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ko.xlf
@@ -142,6 +142,11 @@
         <target state="translated">충돌이 감지되었습니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">가능한 경우 프라이빗 필드를 읽기 전용으로 만들기</target>
@@ -162,6 +167,11 @@
         <target state="translated">'new' 한정자 제거</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">역 'for' 문</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pl.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pl.xlf
index 958bc8e9e885c..235276ff464c8 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pl.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pl.xlf
@@ -142,6 +142,11 @@
         <target state="translated">Wykryto konflikty.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">Ustawiaj pola prywatne jako tylko do odczytu, gdy to możliwe</target>
@@ -162,6 +167,11 @@
         <target state="translated">Usuń modyfikator „new”</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">Odwróć instrukcję „for”</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pt-BR.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pt-BR.xlf
index 7de4bca5edbea..cc5d415939c20 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pt-BR.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pt-BR.xlf
@@ -142,6 +142,11 @@
         <target state="translated">Conflito(s) detectado(s).</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">Tornar os campos privados somente leitura quando possível</target>
@@ -162,6 +167,11 @@
         <target state="translated">Remover modificador 'novo'</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">Reverter instrução 'for'</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ru.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ru.xlf
index b00ad6f2adc8b..7a7461b0e8db0 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ru.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ru.xlf
@@ -142,6 +142,11 @@
         <target state="translated">Обнаружены конфликты.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">При возможности делать частные поля доступными только для чтения</target>
@@ -162,6 +167,11 @@
         <target state="translated">Удалить модификатор "new"</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">Обратить оператор "for"</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.tr.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.tr.xlf
index ac56005f5a0e8..c4d125db341e5 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.tr.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.tr.xlf
@@ -142,6 +142,11 @@
         <target state="translated">Çakışmalar algılandı.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">Özel alanları mümkün olduğunda salt okunur yap</target>
@@ -162,6 +167,11 @@
         <target state="translated">'New' değiştiricisini kaldır</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">'for' ifadesini tersine çevir</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hans.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hans.xlf
index 5c8d1d8e66197..f7f93db37aed6 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hans.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hans.xlf
@@ -142,6 +142,11 @@
         <target state="translated">检测到冲突。</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">尽可能将私有字段设置为“只读”</target>
@@ -162,6 +167,11 @@
         <target state="translated">删除 "new" 修饰符</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">反向“for”语句</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hant.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hant.xlf
index c563694b3a485..12fd5c6374acc 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hant.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hant.xlf
@@ -142,6 +142,11 @@
         <target state="translated">偵測到衝突。</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">若可能的話，請將私用欄位設定為唯讀</target>
@@ -162,6 +167,11 @@
         <target state="translated">移除 'new' 修飾詞</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">反向 'for' 陳述式</target>

From 6d136664db04b6a1d1e4306ac66ae5f0fc1b4588 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Fri, 14 Jan 2022 19:33:12 -0800
Subject: [PATCH 367/444] Update tests

---
 src/Compilers/Test/Core/Traits/Traits.cs      |   2 +-
 ...RemoveUnnecessaryLambdaExpressionTests.cs} | 268 +++++-------------
 2 files changed, 68 insertions(+), 202 deletions(-)
 rename src/EditorFeatures/CSharpTest/{CodeActions/LambdaSimplifier/LambdaSimplifierTests.cs => RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs} (66%)

diff --git a/src/Compilers/Test/Core/Traits/Traits.cs b/src/Compilers/Test/Core/Traits/Traits.cs
index cb0992ea28c49..4fbfc0c4844cc 100644
--- a/src/Compilers/Test/Core/Traits/Traits.cs
+++ b/src/Compilers/Test/Core/Traits/Traits.cs
@@ -118,7 +118,7 @@ public static class Features
             public const string CodeActionsInvertIf = "CodeActions.InvertIf";
             public const string CodeActionsInvertLogical = "CodeActions.InvertLogical";
             public const string CodeActionsInvokeDelegateWithConditionalAccess = "CodeActions.InvokeDelegateWithConditionalAccess";
-            public const string CodeActionsLambdaSimplifier = "CodeActions.LambdaSimplifier";
+            public const string CodeActionsRemoveUnnecessaryLambdaExpression = "CodeActions.LambdaSimplifier";
             public const string CodeActionsMakeFieldReadonly = "CodeActions.MakeFieldReadonly";
             public const string CodeActionsMakeLocalFunctionStatic = "CodeActions.MakeLocalFunctionStatic";
             public const string CodeActionsMakeMethodAsynchronous = "CodeActions.MakeMethodAsynchronous";
diff --git a/src/EditorFeatures/CSharpTest/CodeActions/LambdaSimplifier/LambdaSimplifierTests.cs b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
similarity index 66%
rename from src/EditorFeatures/CSharpTest/CodeActions/LambdaSimplifier/LambdaSimplifierTests.cs
rename to src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
index 365d272454b37..3974006038ecf 100644
--- a/src/EditorFeatures/CSharpTest/CodeActions/LambdaSimplifier/LambdaSimplifierTests.cs
+++ b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
@@ -2,25 +2,39 @@
 // 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.Threading.Tasks;
-using Microsoft.CodeAnalysis.CodeRefactorings;
-using Microsoft.CodeAnalysis.CSharp.CodeRefactorings.LambdaSimplifier;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.RemoveUnnecessaryLambdaExpression;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Roslyn.Test.Utilities;
 using Xunit;
 
-namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings.LambdaSimplifier
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.RemoveUnnecessaryLambdaExpression
 {
-    public class LambdaSimplifierTests : AbstractCSharpCodeActionTest
+    using VerifyCS = CSharpCodeFixVerifier<
+       CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer,
+       CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider>;
+
+    public class RemoveUnnecessaryLambdaExpressionTests
     {
-        protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace, TestParameters parameters)
-            => new LambdaSimplifierCodeRefactoringProvider();
+        private static async Task TestInRegularAndScriptAsync(string testCode, string fixedCode)
+        {
+            await new VerifyCS.Test
+            {
+                TestCode = testCode,
+                FixedCode = fixedCode,
+                LanguageVersion = LanguageVersion.Preview,
+            }.RunAsync();
+        }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsLambdaSimplifier)]
-        public async Task TestFixAll1()
+        private static Task TestMissingInRegularAndScriptAsync(string testCode)
+            => TestInRegularAndScriptAsync(testCode, testCode);
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task Test1()
         {
             await TestInRegularAndScriptAsync(
 @"using System;
@@ -29,7 +43,7 @@ class C
 {
     void Goo()
     {
-        Bar(s [||]=> Quux(s));
+        Bar([|s => |]Quux(s));
     }
 
     void Bar(Func<int, string> f);
@@ -46,11 +60,10 @@ void Goo()
 
     void Bar(Func<int, string> f);
     string Quux(int i);
-}",
-                index: 1);
+}";
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsLambdaSimplifier)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
         public async Task TestFixCoContravariance1()
         {
             await TestInRegularAndScriptAsync(
@@ -60,7 +73,7 @@ class C
 {
     void Goo()
     {
-        Bar(s [||]=> Quux(s));
+        Bar([|s => |]Quux(s));
     }
 
     void Bar(Func<object, string> f);
@@ -77,11 +90,10 @@ void Goo()
 
     void Bar(Func<object, string> f);
     string Quux(object o);
-}",
-                index: 1);
+}");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsLambdaSimplifier)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
         public async Task TestFixCoContravariance2()
         {
             await TestInRegularAndScriptAsync(
@@ -91,7 +103,7 @@ class C
 {
     void Goo()
     {
-        Bar(s [||]=> Quux(s));
+        Bar([|s => |]Quux(s));
     }
 
     void Bar(Func<string, object> f);
@@ -108,11 +120,10 @@ void Goo()
 
     void Bar(Func<string, object> f);
     string Quux(object o);
-}",
-                index: 1);
+}");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsLambdaSimplifier)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
         public async Task TestFixCoContravariance3()
         {
             await TestMissingInRegularAndScriptAsync(
@@ -130,7 +141,7 @@ void Goo()
 }");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsLambdaSimplifier)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
         public async Task TestFixCoContravariance4()
         {
             await TestMissingInRegularAndScriptAsync(
@@ -148,7 +159,7 @@ void Goo()
 }");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsLambdaSimplifier)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
         public async Task TestFixCoContravariance5()
         {
             await TestMissingInRegularAndScriptAsync(
@@ -166,8 +177,8 @@ void Goo()
 }");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsLambdaSimplifier)]
-        public async Task TestFixAll2()
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestTwoArgs()
         {
             await TestInRegularAndScriptAsync(
 @"using System;
@@ -176,7 +187,7 @@ class C
 {
     void Goo()
     {
-        Bar((s1, s2) [||]=> Quux(s1, s2));
+        Bar([|(s1, s2) => |]Quux(s1, s2));
     }
 
     void Bar(Func<int, bool, string> f);
@@ -193,12 +204,11 @@ void Goo()
 
     void Bar(Func<int, bool, string> f);
     string Quux(int i, bool b);
-}",
-                index: 1);
+}");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsLambdaSimplifier)]
-        public async Task TestFixAll3()
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestReturnStatement()
         {
             await TestInRegularAndScriptAsync(
 @"using System;
@@ -207,8 +217,8 @@ class C
 {
     void Goo()
     {
-        Bar((s1, s2) [||]=> {
-            return Quux(s1, s2);
+        Bar([|(s1, s2) => {
+            return |]Quux(s1, s2);
         });
     }
 
@@ -226,12 +236,11 @@ void Goo()
 
     void Bar(Func<int, bool, string> f);
     string Quux(int i, bool b);
-}",
-                index: 1);
+}");
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsLambdaSimplifier)]
-        public async Task TestFixAll4()
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task RestReturnStatement2()
         {
             await TestInRegularAndScriptAsync(
 @"using System;
@@ -240,8 +249,8 @@ class C
 {
     void Goo()
     {
-        Bar((s1, s2) [||]=> {
-            return this.Quux(s1, s2);
+        Bar([|(s1, s2) => {
+            return |]this.Quux(s1, s2);
         });
     }
 
@@ -259,82 +268,19 @@ void Goo()
 
     void Bar(Func<int, bool, string> f);
     string Quux(int i, bool b);
-}",
-                index: 1);
-        }
-
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsLambdaSimplifier)]
-        public async Task TestFixOneOrAll()
-        {
-            await TestInRegularAndScriptAsync(
-@"using System;
-
-class C
-{
-    void Goo()
-    {
-        Bar(s [||]=> Quux(s));
-        Bar(s => Quux(s));
-    }
-
-    void Bar(Func<int, string> f);
-    string Quux(int i);
-}",
-@"using System;
-
-class C
-{
-    void Goo()
-    {
-        Bar(Quux);
-        Bar(s => Quux(s));
-    }
-
-    void Bar(Func<int, string> f);
-    string Quux(int i);
-}",
-                index: 0);
-
-            await TestInRegularAndScriptAsync(
-@"using System;
-
-class C
-{
-    void Goo()
-    {
-        Bar(s [||]=> Quux(s));
-        Bar(s => Quux(s));
-    }
-
-    void Bar(Func<int, string> f);
-    string Quux(int i);
-}",
-@"using System;
-
-class C
-{
-    void Goo()
-    {
-        Bar(Quux);
-        Bar(Quux);
-    }
-
-    void Bar(Func<int, string> f);
-    string Quux(int i);
-}",
-                index: 1);
+}");
         }
 
         [WorkItem(542562, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542562")]
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsLambdaSimplifier)]
-        public async Task TestMissingOnAmbiguity1_CSharp7()
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestMissingOnAmbiguity1()
         {
             await TestMissingInRegularAndScriptAsync(
 @"using System;
 
 class A
 {
-    static void Goo<T>(T x) where T : class
+    static void Goo<T>(T x)
     {
     }
 
@@ -348,14 +294,14 @@ static void Bar(Action<string> x)
 
     static void Main()
     {
-        Bar(x [||]=> Goo(x));
+        Bar([|x => |]Goo(x));
     }
-}", parameters: new TestParameters(TestOptions.Regular7));
+}");
         }
 
         [WorkItem(542562, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542562")]
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsLambdaSimplifier)]
-        public async Task TestMissingOnAmbiguity1()
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestWithConstraint()
         {
             var code = @"
 using System;
@@ -375,7 +321,7 @@ static void Bar(Action<string> x)
 
     static void Main()
     {
-        Bar(x [||]=> Goo(x));
+        Bar([|x => |]Goo(x));
     }
 }";
 
@@ -400,12 +346,11 @@ static void Main()
         Bar(Goo);
     }
 }";
-
-            await TestInRegularAndScriptAsync(code, expected, parseOptions: TestOptions.Regular7_3);
+            await TestInRegularAndScriptAsync(code, expected);
         }
 
         [WorkItem(627092, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/627092")]
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsLambdaSimplifier)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
         public async Task TestMissingOnLambdaWithDynamic_1()
         {
             await TestMissingInRegularAndScriptAsync(
@@ -440,7 +385,7 @@ static void Goo(object x, T y)
         }
 
         [WorkItem(627092, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/627092")]
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsLambdaSimplifier)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
         public async Task TestMissingOnLambdaWithDynamic_2()
         {
             await TestMissingInRegularAndScriptAsync(
@@ -480,7 +425,7 @@ static void Goo(object x, T y)
         }
 
         [WorkItem(544625, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544625")]
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsLambdaSimplifier)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
         public async Task ParenthesizeIfParseChanges()
         {
             var code = @"
@@ -491,7 +436,7 @@ static void M()
     {
         C x = new C();
         int y = 1;
-        Bar(() [||]=> { return Console.ReadLine(); } < x, y > (1 + 2));
+        Bar([|() => { return |]Console.ReadLine(); } < x, y > (1 + 2));
     }
 
     static void Bar(object a, object b) { }
@@ -519,10 +464,10 @@ static void Bar(object a, object b) { }
         }
 
         [WorkItem(545856, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545856")]
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsLambdaSimplifier)]
-        public async Task TestWarningOnSideEffects()
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestNotWithSideEffects()
         {
-            await TestInRegularAndScriptAsync(
+            await TestMissingInRegularAndScriptAsync(
 @"using System;
 
 class C
@@ -531,20 +476,11 @@ void Main()
     {
         Func<string> a = () [||]=> new C().ToString();
     }
-}",
-@"using System;
-
-class C
-{
-    void Main()
-    {
-        Func<string> a = {|Warning:new C()|}.ToString;
-    }
 }");
         }
 
         [WorkItem(545994, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545994")]
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsLambdaSimplifier)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
         public async Task TestNonReturnBlockSyntax()
         {
             await TestInRegularAndScriptAsync(
@@ -554,80 +490,10 @@ class Program
 {
     static void Main()
     {
-        Action a = [||]() => {
-            Console.WriteLine();
-        };
-    }
-}",
-@"using System;
-
-class Program
-{
-    static void Main()
-    {
-        Action a = Console.WriteLine;
-    }
-}");
-        }
-
-        [WorkItem(35180, "https://github.com/dotnet/roslyn/issues/35180")]
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsLambdaSimplifier)]
-        public async Task TestMissingCaretPositionInside()
-        {
-            await TestMissingInRegularAndScriptAsync(
-@"using System;
-
-class Program
-{
-    static void Main()
-    {
-        Action a = () => {
-            Console.[||]WriteLine();
+        Action a = [|() => {
+            |]Console.WriteLine();
         };
     }
-}");
-        }
-
-        [WorkItem(35180, "https://github.com/dotnet/roslyn/issues/35180")]
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsLambdaSimplifier)]
-        public async Task TestCaretPositionBeforeBody()
-        {
-            await TestInRegularAndScriptAsync(
-@"using System;
-
-class Program
-{
-    static void Main()
-    {
-        Action a = () => [||]Console.WriteLine();
-    }
-}",
-@"using System;
-
-class Program
-{
-    static void Main()
-    {
-        Action a = Console.WriteLine;
-    }
-}");
-        }
-
-        [WorkItem(35180, "https://github.com/dotnet/roslyn/issues/35180")]
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsLambdaSimplifier)]
-        public async Task TestCaretPosition()
-        {
-            await TestInRegularAndScriptAsync(
-@"using System;
-
-class Program
-{
-    static void Main()
-    {
-        [|Action a = () => {
-            Console.WriteLine();
-        };|]
-    }
 }",
 @"using System;
 

From 2b5f27015e19895434937f3d3fa438e11a17ac20 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Fri, 14 Jan 2022 19:38:14 -0800
Subject: [PATCH 368/444] Tweak tests

---
 .../RemoveUnnecessaryLambdaExpressionTests.cs | 66 +++++++++----------
 ...ecessaryLambdaExpressionCodeFixProvider.cs |  2 +-
 2 files changed, 33 insertions(+), 35 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
index 3974006038ecf..91f7a9a8252ec 100644
--- a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
+++ b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
@@ -2,11 +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.Threading.Tasks;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.RemoveUnnecessaryLambdaExpression;
-using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
 using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Roslyn.Test.Utilities;
@@ -46,8 +44,8 @@ void Goo()
         Bar([|s => |]Quux(s));
     }
 
-    void Bar(Func<int, string> f);
-    string Quux(int i);
+    void Bar(Func<int, string> f) { }
+    string Quux(int i) => default;
 }",
 @"using System;
 
@@ -58,9 +56,9 @@ void Goo()
         Bar(Quux);
     }
 
-    void Bar(Func<int, string> f);
-    string Quux(int i);
-}";
+    void Bar(Func<int, string> f) { }
+    string Quux(int i) => default;
+}");
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
@@ -76,8 +74,8 @@ void Goo()
         Bar([|s => |]Quux(s));
     }
 
-    void Bar(Func<object, string> f);
-    string Quux(object o);
+    void Bar(Func<object, string> f) { }
+    string Quux(object o) => default;
 }",
 @"using System;
 
@@ -88,8 +86,8 @@ void Goo()
         Bar(Quux);
     }
 
-    void Bar(Func<object, string> f);
-    string Quux(object o);
+    void Bar(Func<object, string> f) { }
+    string Quux(object o) => default;
 }");
         }
 
@@ -106,8 +104,8 @@ void Goo()
         Bar([|s => |]Quux(s));
     }
 
-    void Bar(Func<string, object> f);
-    string Quux(object o);
+    void Bar(Func<string, object> f) { }
+    string Quux(object o) => default;
 }",
 @"using System;
 
@@ -118,8 +116,8 @@ void Goo()
         Bar(Quux);
     }
 
-    void Bar(Func<string, object> f);
-    string Quux(object o);
+    void Bar(Func<string, object> f) { }
+    string Quux(object o) => default;
 }");
         }
 
@@ -136,8 +134,8 @@ void Goo()
         Bar(s [||]=> Quux(s));
     }
 
-    void Bar(Func<string, string> f);
-    object Quux(object o);
+    void Bar(Func<string, string> f) { }
+    object Quux(object o) => default;
 }");
         }
 
@@ -154,8 +152,8 @@ void Goo()
         Bar(s [||]=> Quux(s));
     }
 
-    void Bar(Func<object, object> f);
-    string Quux(string o);
+    void Bar(Func<object, object> f) { }
+    string Quux(string o) => default;
 }");
         }
 
@@ -172,8 +170,8 @@ void Goo()
         Bar(s [||]=> Quux(s));
     }
 
-    void Bar(Func<object, string> f);
-    object Quux(string o);
+    void Bar(Func<object, string> f) { }
+    object Quux(string o) => default;
 }");
         }
 
@@ -190,8 +188,8 @@ void Goo()
         Bar([|(s1, s2) => |]Quux(s1, s2));
     }
 
-    void Bar(Func<int, bool, string> f);
-    string Quux(int i, bool b);
+    void Bar(Func<int, bool, string> f) { }
+    string Quux(int i, bool b) => default;
 }",
 @"using System;
 
@@ -202,8 +200,8 @@ void Goo()
         Bar(Quux);
     }
 
-    void Bar(Func<int, bool, string> f);
-    string Quux(int i, bool b);
+    void Bar(Func<int, bool, string> f) { }
+    string Quux(int i, bool b) => default;
 }");
         }
 
@@ -222,8 +220,8 @@ void Goo()
         });
     }
 
-    void Bar(Func<int, bool, string> f);
-    string Quux(int i, bool b);
+    void Bar(Func<int, bool, string> f) { }
+    string Quux(int i, bool b) => default;
 }",
 @"using System;
 
@@ -234,8 +232,8 @@ void Goo()
         Bar(Quux);
     }
 
-    void Bar(Func<int, bool, string> f);
-    string Quux(int i, bool b);
+    void Bar(Func<int, bool, string> f) { }
+    string Quux(int i, bool b) => default;
 }");
         }
 
@@ -254,8 +252,8 @@ void Goo()
         });
     }
 
-    void Bar(Func<int, bool, string> f);
-    string Quux(int i, bool b);
+    void Bar(Func<int, bool, string> f) { }
+    string Quux(int i, bool b) => default;
 }",
 @"using System;
 
@@ -266,8 +264,8 @@ void Goo()
         Bar(this.Quux);
     }
 
-    void Bar(Func<int, bool, string> f);
-    string Quux(int i, bool b);
+    void Bar(Func<int, bool, string> f) { }
+    string Quux(int i, bool b) => default;
 }");
         }
 
@@ -474,7 +472,7 @@ class C
 {
     void Main()
     {
-        Func<string> a = () [||]=> new C().ToString();
+        Func<string> a = () => new C().ToString();
     }
 }");
         }
diff --git a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs
index 459ec65fb8aec..149c3e6de03a5 100644
--- a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs
@@ -45,7 +45,7 @@ public override Task RegisterCodeFixesAsync(CodeFixContext context)
             return Task.CompletedTask;
         }
 
-        protected override async Task FixAllAsync(
+        protected override Task FixAllAsync(
             Document document, ImmutableArray<Diagnostic> diagnostics,
             SyntaxEditor editor, CancellationToken cancellationToken)
         {

From 591e899025f1d4cf9bbb6e9af3ef82506b46f501 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: Fri, 14 Jan 2022 19:47:03 -0800
Subject: [PATCH 369/444] Formatter options refactoring - step 1 (#58807)

* Formatter options refactoring: Propagate options and remove dependency on Workspace

* Remove AllowDisjointSpanMerging
---
 ...CSharpRemoveUnusedValuesCodeFixProvider.cs |   7 ++
 ...stractRemoveUnusedValuesCodeFixProvider.cs |  40 +++++--
 ...UseConditionalExpressionCodeFixProvider.cs |  24 ++--
 ...lBasicRemoveUnusedValuesCodeFixProvider.vb |   8 ++
 .../Analyzers/AbstractFormattingAnalyzer.cs   |   6 +-
 .../Analyzers/Formatting/FormatterHelper.cs   | 107 +++--------------
 .../Analyzers/FormattingAnalyzerHelper.cs     |  13 +--
 .../Core/CodeFixes/FormattingCodeFixHelper.cs |  17 +--
 .../CodeFixes/FormattingCodeFixProvider.cs    |  16 +--
 .../AutomaticLineEnderCommandHandler.cs       |  10 +-
 ...utomaticLineEnderCommandHandler_Helpers.cs |  20 +++-
 .../CSharpDecompiledSourceService.cs          |   6 +-
 .../ExtractClass/ExtractClassTests.cs         |   3 +-
 .../Formatting/FormattingEngineTests.cs       | 107 ++---------------
 .../Indentation/CSharpFormatterTestsBase.cs   |   6 +-
 .../SmartIndenterEnterOnTokenTests.cs         |   4 +-
 .../SmartTokenFormatterFormatRangeTests.cs    |  14 +--
 .../Extensions/ITextSnapshotExtensions.cs     |   7 +-
 .../TestExtractInterfaceOptions.cs            |   4 +-
 .../Formatting/CoreFormatterTestsBase.cs      |  43 +++----
 .../VisualBasic/LineCommit/CommitFormatter.vb |  38 +-----
 .../CaseCorrectionServiceTests.vb             |   4 +-
 .../SmartTokenFormatter_FormatTokenTests.vb   |   5 +-
 .../VisualBasicFormatterTestBase.vb           |   7 +-
 .../CurlyBraceCompletionService.cs            |   4 +-
 .../CSharpSuppressionCodeFixProvider.cs       |  17 +--
 .../CSharpFormattingInteractionService.cs     |  53 ++++-----
 .../AbstractChangeSignatureService.cs         |   5 +-
 ...rovider.GlobalSuppressMessageCodeAction.cs |   7 +-
 ...r.GlobalSuppressMessageFixAllCodeAction.cs |   7 +-
 ...uppressionCodeFixProvider.PragmaHelpers.cs |  18 +--
 ...CodeFixProvider.PragmaWarningCodeAction.cs |  17 ++-
 ...FixProvider.RemoveSuppressionCodeAction.cs |   4 +-
 ...ider.RemoveSuppressionCodeAction_Pragma.cs |  26 +++--
 .../AbstractSuppressionCodeFixProvider.cs     |  13 ++-
 ...AbstractAddMissingImportsFeatureService.cs |  13 +--
 .../AbstractChangeNamespaceService.cs         |   4 +-
 .../ExtractClassWithDialogCodeAction.cs       |   2 +-
 .../IExtractClassOptionsService.cs            |   3 +-
 .../AbstractExtractInterfaceService.cs        |  10 +-
 .../IExtractInterfaceOptionsService.cs        |   4 +-
 .../ExtractMethod/ExtractMethodResult.cs      |   8 +-
 .../Formatting/FormattingCodeFixProvider.cs   |   4 +-
 .../FormattingDiagnosticAnalyzer.cs           |   6 +-
 .../AbstractMetadataAsSourceService.cs        |   8 +-
 .../Shared/Utilities/ExtractTypeHelpers.cs    |   4 +-
 .../AbstractUseAutoPropertyCodeFixProvider.cs |   4 +-
 ...oadBaseCodeFixProvider.AddKeywordAction.vb |   9 +-
 .../VisualBasicSuppressionCodeFixProvider.vb  |  29 +++--
 .../OmniSharpExtractClassOptionsService.cs    |   3 +-
 ...OmniSharpExtractInterfaceOptionsService.cs |  12 +-
 .../IdeBenchmarks/FormatterBenchmarks.cs      |   8 +-
 .../Implementation/AbstractEditorFactory.cs   |   6 +-
 .../VisualStudioExtractClassOptionsService.cs |  13 ++-
 ...ualStudioExtractInterfaceOptionsService.cs |   6 +-
 ...actLanguageService`2.IVsLanguageTextOps.cs |  10 +-
 .../Implementation/Venus/ContainedDocument.cs |  22 ++--
 .../Venus/ContainedLanguageCodeSupport.cs     |   5 +-
 .../CodeModel/AbstractCodeModelService.cs     |  17 ++-
 .../CSharpCaseCorrectionService.cs            |   1 -
 .../CSharpIndentationService.Indenter.cs      |   5 +-
 .../Indentation/CSharpSmartTokenFormatter.cs  |  25 ++--
 .../CodeGeneration/SyntaxGeneratorTests.cs    |   3 +-
 .../FormattingElasticTriviaTests.cs           |  18 +--
 .../Formatting/FormattingMultipleSpanTests.cs |   3 +-
 .../CSharpTest/Formatting/FormattingTests.cs  |   9 +-
 .../Formatting/FormattingTreeEditTests.cs     |  16 ++-
 .../Formatting/FormattingTriviaTests.cs       |  18 ++-
 .../AbstractCaseCorrectionService.cs          |  14 ++-
 .../Portable/CaseCorrection/CaseCorrector.cs  |   6 +-
 .../CaseCorrection/ICaseCorrectionService.cs  |   3 +-
 .../CodeCleanup/AbstractCodeCleanerService.cs |  29 ++---
 .../Core/Portable/CodeCleanup/CodeCleaner.cs  |  19 +--
 .../CodeCleanup/ICodeCleanerService.cs        |   5 +-
 .../Providers/FormatCodeCleanupProvider.cs    |  59 +++++-----
 .../Providers/ICodeCleanupProvider.cs         |   6 +-
 .../Providers/SimpleCodeCleanupProvider.cs    |  72 ------------
 .../SimplificationCodeCleanupProvider.cs      |   6 +-
 .../Core/Portable/Editing/SyntaxGenerator.cs  |   3 +
 .../Formatting/AbstractFormattingService.cs   |   5 +-
 .../Core/Portable/Formatting/Formatter.cs     | 109 +++++++++---------
 .../Formatting/FormattingBehaviorOptions.cs   |   7 --
 .../AbstractIndentationService.Indenter.cs    |   2 +-
 .../Indentation/ISmartTokenFormatter.cs       |   3 +-
 .../CoreTest/CodeCleanup/CodeCleanupTests.cs  | 109 +++++++++++-------
 .../CodeCleanup/MockCodeCleanupProvider.cs    |  34 ++++++
 .../CoreTest/Editing/SyntaxEditorTests.cs     |   6 +-
 src/Workspaces/CoreTest/FormattingTests.cs    |  15 ++-
 .../Formatting/FormattingTestBase.cs          |  21 ++--
 .../AbstractSyntaxFormattingService.cs        | 100 +++-------------
 .../Core/Formatting/FormattingExtensions.cs   |  25 ++--
 .../Formatting/ISyntaxFormattingService.cs    |  25 +++-
 .../Core/Utilities/CommonFormattingHelpers.cs |   2 +-
 .../CSharpRemoveUnnecessaryImportsService.cs  |  35 ++++--
 .../VisualBasicCaseCorrectionService.vb       |   1 -
 .../AbstractTokensCodeCleanupProvider.vb      |  12 +-
 .../AddMissingTokensCodeCleanupProvider.vb    |   2 +-
 .../CaseCorrectionCodeCleanupProvider.vb      |   8 +-
 .../FixIncorrectTokensCodeCleanupProvider.vb  |   2 +-
 ...ModifiersOrOperatorsCodeCleanupProvider.vb |   8 +-
 .../ReduceTokensCodeCleanupProvider.vb        |   2 +-
 ...saryLineContinuationCodeCleanupProvider.vb |   8 +-
 .../VisualBasicIndentationService.Indenter.vb |   8 +-
 .../VisualBasicSmartTokenFormatter.vb         |  12 +-
 .../Formatting/FormattingTests.vb             |  30 +++--
 .../VisualBasicFormattingTestBase.vb          |  10 +-
 106 files changed, 879 insertions(+), 939 deletions(-)
 delete mode 100644 src/Workspaces/Core/Portable/CodeCleanup/Providers/SimpleCodeCleanupProvider.cs
 create mode 100644 src/Workspaces/CoreTest/CodeCleanup/MockCodeCleanupProvider.cs

diff --git a/src/Analyzers/CSharp/CodeFixes/RemoveUnusedParametersAndValues/CSharpRemoveUnusedValuesCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/RemoveUnusedParametersAndValues/CSharpRemoveUnusedValuesCodeFixProvider.cs
index 24f21e1674b39..d5479027826e2 100644
--- a/src/Analyzers/CSharp/CodeFixes/RemoveUnusedParametersAndValues/CSharpRemoveUnusedValuesCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/RemoveUnusedParametersAndValues/CSharpRemoveUnusedValuesCodeFixProvider.cs
@@ -10,9 +10,11 @@
 using System.Diagnostics.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
+using Microsoft.CodeAnalysis.CSharp.Formatting;
 using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.RemoveUnusedParametersAndValues;
 
@@ -31,6 +33,11 @@ public CSharpRemoveUnusedValuesCodeFixProvider()
         {
         }
 
+#if CODE_STYLE
+        protected override ISyntaxFormattingService GetSyntaxFormattingService()
+            => CSharpSyntaxFormattingService.Instance;
+#endif
+
         protected override BlockSyntax WrapWithBlockIfNecessary(IEnumerable<StatementSyntax> statements)
             => SyntaxFactory.Block(statements);
 
diff --git a/src/Analyzers/Core/CodeFixes/RemoveUnusedParametersAndValues/AbstractRemoveUnusedValuesCodeFixProvider.cs b/src/Analyzers/Core/CodeFixes/RemoveUnusedParametersAndValues/AbstractRemoveUnusedValuesCodeFixProvider.cs
index 0b133d8db6d5f..ca46244be1c03 100644
--- a/src/Analyzers/Core/CodeFixes/RemoveUnusedParametersAndValues/AbstractRemoveUnusedValuesCodeFixProvider.cs
+++ b/src/Analyzers/Core/CodeFixes/RemoveUnusedParametersAndValues/AbstractRemoveUnusedValuesCodeFixProvider.cs
@@ -20,6 +20,7 @@
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.MoveDeclarationNearReference;
 using Microsoft.CodeAnalysis.Operations;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.ReplaceDiscardDeclarationsWithAssignments;
 using Microsoft.CodeAnalysis.Shared.Extensions;
@@ -66,6 +67,9 @@ public sealed override ImmutableArray<string> FixableDiagnosticIds
 
         internal sealed override CodeFixCategory CodeFixCategory => CodeFixCategory.CodeQuality;
 
+#if CODE_STYLE
+        protected abstract ISyntaxFormattingService GetSyntaxFormattingService();
+#endif
         /// <summary>
         /// Method to update the identifier token for the local/parameter declaration or reference
         /// that was flagged as an unused value write by the analyzer.
@@ -268,14 +272,21 @@ private static async Task<Document> PreprocessDocumentAsync(Document document, I
 
         protected sealed override async Task FixAllAsync(Document document, ImmutableArray<Diagnostic> diagnostics, SyntaxEditor editor, CancellationToken cancellationToken)
         {
-            var newRoot = await GetNewRootAsync(
-                await PreprocessDocumentAsync(document, diagnostics, cancellationToken).ConfigureAwait(false),
-                diagnostics, cancellationToken).ConfigureAwait(false);
+#if CODE_STYLE
+            var provider = GetSyntaxFormattingService();
+            var options = SyntaxFormattingOptions.Create(document.Project.AnalyzerOptions.GetAnalyzerOptionSet(editor.OriginalRoot.SyntaxTree, cancellationToken));
+#else
+            var provider = document.Project.Solution.Workspace.Services;
+            var options = await SyntaxFormattingOptions.FromDocumentAsync(document, cancellationToken).ConfigureAwait(false);
+#endif
+            var preprocessedDocument = await PreprocessDocumentAsync(document, diagnostics, cancellationToken).ConfigureAwait(false);
+            var newRoot = await GetNewRootAsync(preprocessedDocument, options, diagnostics, cancellationToken).ConfigureAwait(false);
             editor.ReplaceNode(editor.OriginalRoot, newRoot);
         }
 
         private async Task<SyntaxNode> GetNewRootAsync(
             Document document,
+            SyntaxFormattingOptions options,
             ImmutableArray<Diagnostic> diagnostics,
             CancellationToken cancellationToken)
         {
@@ -314,7 +325,7 @@ await FixAllAsync(diagnosticId, diagnosticsToFix.Select(d => d), document, seman
 
             // Second pass to post process the document.
             var currentRoot = editor.GetChangedRoot();
-            var newRoot = await PostProcessDocumentAsync(document, currentRoot,
+            var newRoot = await PostProcessDocumentAsync(document, options, currentRoot,
                 diagnosticId, preference, cancellationToken).ConfigureAwait(false);
 
             if (currentRoot != newRoot)
@@ -719,6 +730,7 @@ bool ShouldRemoveStatement(TLocalDeclarationStatementSyntax localDeclarationStat
 
         private async Task<SyntaxNode> PostProcessDocumentAsync(
             Document document,
+            SyntaxFormattingOptions options,
             SyntaxNode currentRoot,
             string diagnosticId,
             UnusedValuePreference preference,
@@ -731,7 +743,7 @@ private async Task<SyntaxNode> PostProcessDocumentAsync(
             if (preference == UnusedValuePreference.DiscardVariable)
             {
                 currentRoot = await PostProcessDocumentCoreAsync(
-                    ReplaceDiscardDeclarationsWithAssignmentsAsync, currentRoot, document, cancellationToken).ConfigureAwait(false);
+                    ReplaceDiscardDeclarationsWithAssignmentsAsync, currentRoot, document, options, cancellationToken).ConfigureAwait(false);
             }
 
             // If we added new variable declaration statements, move these as close as possible to their
@@ -739,16 +751,17 @@ private async Task<SyntaxNode> PostProcessDocumentAsync(
             if (NeedsToMoveNewLocalDeclarationsNearReference(diagnosticId))
             {
                 currentRoot = await PostProcessDocumentCoreAsync(
-                    AdjustLocalDeclarationsAsync, currentRoot, document, cancellationToken).ConfigureAwait(false);
+                    AdjustLocalDeclarationsAsync, currentRoot, document, options, cancellationToken).ConfigureAwait(false);
             }
 
             return currentRoot;
         }
 
         private static async Task<SyntaxNode> PostProcessDocumentCoreAsync(
-            Func<SyntaxNode, Document, CancellationToken, Task<SyntaxNode>> processMemberDeclarationAsync,
+            Func<SyntaxNode, Document, SyntaxFormattingOptions, CancellationToken, Task<SyntaxNode>> processMemberDeclarationAsync,
             SyntaxNode currentRoot,
             Document document,
+            SyntaxFormattingOptions options,
             CancellationToken cancellationToken)
         {
             // Process each member declaration which had at least one diagnostic reported in the original tree and hence
@@ -760,7 +773,7 @@ private static async Task<SyntaxNode> PostProcessDocumentCoreAsync(
 
             foreach (var memberDecl in newRoot.DescendantNodes().Where(n => n.HasAnnotation(s_memberAnnotation)))
             {
-                var newMemberDecl = await processMemberDeclarationAsync(memberDecl, newDocument, cancellationToken).ConfigureAwait(false);
+                var newMemberDecl = await processMemberDeclarationAsync(memberDecl, newDocument, options, cancellationToken).ConfigureAwait(false);
                 memberDeclReplacementsMap.Add(memberDecl, newMemberDecl);
             }
 
@@ -776,7 +789,7 @@ private static async Task<SyntaxNode> PostProcessDocumentCoreAsync(
         /// This is needed to prevent the code fix/FixAll from generating code with
         /// multiple local variables named '_', which is a compiler error.
         /// </summary>
-        private async Task<SyntaxNode> ReplaceDiscardDeclarationsWithAssignmentsAsync(SyntaxNode memberDeclaration, Document document, CancellationToken cancellationToken)
+        private async Task<SyntaxNode> ReplaceDiscardDeclarationsWithAssignmentsAsync(SyntaxNode memberDeclaration, Document document, SyntaxFormattingOptions options, CancellationToken cancellationToken)
         {
             var service = document.GetLanguageService<IReplaceDiscardDeclarationsWithAssignmentsService>();
             if (service == null)
@@ -798,6 +811,7 @@ private async Task<SyntaxNode> ReplaceDiscardDeclarationsWithAssignmentsAsync(Sy
         private async Task<SyntaxNode> AdjustLocalDeclarationsAsync(
             SyntaxNode memberDeclaration,
             Document document,
+            SyntaxFormattingOptions options,
             CancellationToken cancellationToken)
         {
             var moveDeclarationService = document.GetRequiredLanguageService<IMoveDeclarationNearReferenceService>();
@@ -821,7 +835,13 @@ private async Task<SyntaxNode> AdjustLocalDeclarationsAsync(
             var rootWithTrackedNodes = root.TrackNodes(originalDeclStatementsToMoveOrRemove);
 
             // Run formatter prior to invoking IMoveDeclarationNearReferenceService.
-            rootWithTrackedNodes = Formatter.Format(rootWithTrackedNodes, originalDeclStatementsToMoveOrRemove.Select(s => s.Span), document.Project.Solution.Workspace, cancellationToken: cancellationToken);
+#if CODE_STYLE
+            var provider = GetSyntaxFormattingService();
+            rootWithTrackedNodes = FormatterHelper.Format(rootWithTrackedNodes, originalDeclStatementsToMoveOrRemove.Select(s => s.Span), provider, options, rules: null, cancellationToken);
+#else
+            var provider = document.Project.Solution.Workspace.Services;
+            rootWithTrackedNodes = Formatter.Format(rootWithTrackedNodes, originalDeclStatementsToMoveOrRemove.Select(s => s.Span), provider, options, rules: null, cancellationToken);
+#endif
 
             document = document.WithSyntaxRoot(rootWithTrackedNodes);
             await OnDocumentUpdatedAsync().ConfigureAwait(false);
diff --git a/src/Analyzers/Core/CodeFixes/UseConditionalExpression/AbstractUseConditionalExpressionCodeFixProvider.cs b/src/Analyzers/Core/CodeFixes/UseConditionalExpression/AbstractUseConditionalExpressionCodeFixProvider.cs
index 385a3eae9ab3d..41a90a1ceb2a6 100644
--- a/src/Analyzers/Core/CodeFixes/UseConditionalExpression/AbstractUseConditionalExpressionCodeFixProvider.cs
+++ b/src/Analyzers/Core/CodeFixes/UseConditionalExpression/AbstractUseConditionalExpressionCodeFixProvider.cs
@@ -17,6 +17,12 @@
 using Microsoft.CodeAnalysis.Simplification;
 using static Microsoft.CodeAnalysis.UseConditionalExpression.UseConditionalExpressionCodeFixHelpers;
 
+#if CODE_STYLE
+using Formatter = Microsoft.CodeAnalysis.Formatting.FormatterHelper;
+#else
+using Formatter = Microsoft.CodeAnalysis.Formatting.Formatter;
+#endif
+
 namespace Microsoft.CodeAnalysis.UseConditionalExpression
 {
     internal abstract class AbstractUseConditionalExpressionCodeFixProvider<
@@ -70,21 +76,15 @@ await FixOneAsync(
             // annotation on it.
             var rules = new List<AbstractFormattingRule> { GetMultiLineFormattingRule() };
 
-            var options = document.Project.AnalyzerOptions.GetAnalyzerOptionSet(root.SyntaxTree, cancellationToken);
-
 #if CODE_STYLE
-            var formattedRoot = FormatterHelper.Format(changedRoot,
-                GetSyntaxFormattingService(),
-                SpecializedFormattingAnnotation,
-                options,
-                rules, cancellationToken);
+            var provider = GetSyntaxFormattingService();
+            var options = SyntaxFormattingOptions.Create(document.Project.AnalyzerOptions.GetAnalyzerOptionSet(root.SyntaxTree, cancellationToken));
 #else
-            var formattedRoot = Formatter.Format(changedRoot,
-                SpecializedFormattingAnnotation,
-                document.Project.Solution.Workspace,
-                options,
-                rules, cancellationToken);
+            var provider = document.Project.Solution.Workspace.Services;
+            var options = await SyntaxFormattingOptions.FromDocumentAsync(document, cancellationToken).ConfigureAwait(false);
 #endif
+            var formattedRoot = Formatter.Format(changedRoot, SpecializedFormattingAnnotation, provider, options, rules, cancellationToken);
+
             changedRoot = formattedRoot;
 
             editor.ReplaceNode(root, changedRoot);
diff --git a/src/Analyzers/VisualBasic/CodeFixes/RemoveUnusedParametersAndValues/VisualBasicRemoveUnusedValuesCodeFixProvider.vb b/src/Analyzers/VisualBasic/CodeFixes/RemoveUnusedParametersAndValues/VisualBasicRemoveUnusedValuesCodeFixProvider.vb
index 0dabee3281c7b..a751f08efa9a1 100644
--- a/src/Analyzers/VisualBasic/CodeFixes/RemoveUnusedParametersAndValues/VisualBasicRemoveUnusedValuesCodeFixProvider.vb
+++ b/src/Analyzers/VisualBasic/CodeFixes/RemoveUnusedParametersAndValues/VisualBasicRemoveUnusedValuesCodeFixProvider.vb
@@ -6,8 +6,10 @@ Imports System.Composition
 Imports System.Diagnostics.CodeAnalysis
 Imports Microsoft.CodeAnalysis.CodeFixes
 Imports Microsoft.CodeAnalysis.Editing
+Imports Microsoft.CodeAnalysis.Formatting
 Imports Microsoft.CodeAnalysis.LanguageServices
 Imports Microsoft.CodeAnalysis.RemoveUnusedParametersAndValues
+Imports Microsoft.CodeAnalysis.VisualBasic.Formatting
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.RemoveUnusedParametersAndValues
@@ -23,6 +25,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.RemoveUnusedParametersAndValues
         Public Sub New()
         End Sub
 
+#If CODE_STYLE Then
+        Protected Overrides Function GetSyntaxFormattingService() As ISyntaxFormattingService
+            Return VisualBasicSyntaxFormattingService.Instance
+        End Function
+#End If
+
         Protected Overrides Function WrapWithBlockIfNecessary(statements As IEnumerable(Of StatementSyntax)) As StatementSyntax
             ' Unreachable code path as VB statements don't need to be wrapped in special BlockSyntax.
             Throw ExceptionUtilities.Unreachable
diff --git a/src/CodeStyle/Core/Analyzers/AbstractFormattingAnalyzer.cs b/src/CodeStyle/Core/Analyzers/AbstractFormattingAnalyzer.cs
index 31b9440b912d8..3b51c026c3ec0 100644
--- a/src/CodeStyle/Core/Analyzers/AbstractFormattingAnalyzer.cs
+++ b/src/CodeStyle/Core/Analyzers/AbstractFormattingAnalyzer.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Formatting;
@@ -36,8 +34,8 @@ protected sealed override void InitializeWorker(AnalysisContext context)
 
         private void AnalyzeSyntaxTree(SyntaxTreeAnalysisContext context)
         {
-            var analyzerConfigOptions = context.Options.AnalyzerConfigOptionsProvider.GetOptions(context.Tree);
-            FormattingAnalyzerHelper.AnalyzeSyntaxTree(context, SyntaxFormattingService, Descriptor, analyzerConfigOptions);
+            var options = SyntaxFormattingOptions.Create(context.Options.AnalyzerConfigOptionsProvider.GetOptions(context.Tree));
+            FormattingAnalyzerHelper.AnalyzeSyntaxTree(context, SyntaxFormattingService, Descriptor, options);
         }
     }
 }
diff --git a/src/CodeStyle/Core/Analyzers/Formatting/FormatterHelper.cs b/src/CodeStyle/Core/Analyzers/Formatting/FormatterHelper.cs
index 7485698d79ac6..54db1c6918b95 100644
--- a/src/CodeStyle/Core/Analyzers/Formatting/FormatterHelper.cs
+++ b/src/CodeStyle/Core/Analyzers/Formatting/FormatterHelper.cs
@@ -2,17 +2,11 @@
 // 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.Generic;
 using System.Threading;
-using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Formatting.Rules;
 using Microsoft.CodeAnalysis.Text;
-using Microsoft.CodeAnalysis.Diagnostics;
 using Roslyn.Utilities;
-using OptionSet = Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions;
 using static Microsoft.CodeAnalysis.Formatting.FormattingExtensions;
 
 namespace Microsoft.CodeAnalysis.Formatting
@@ -26,50 +20,7 @@ internal static class FormatterHelper
         /// Gets the formatting rules that would be applied if left unspecified.
         /// </summary>
         internal static IEnumerable<AbstractFormattingRule> GetDefaultFormattingRules(ISyntaxFormattingService syntaxFormattingService)
-        {
-            if (syntaxFormattingService != null)
-            {
-                return syntaxFormattingService.GetDefaultFormattingRules();
-            }
-            else
-            {
-                return SpecializedCollections.EmptyEnumerable<AbstractFormattingRule>();
-            }
-        }
-
-        /// <summary>
-        /// Formats the whitespace in an area of a document corresponding to a text span.
-        /// </summary>
-        /// <param name="syntaxTree">The document to format.</param>
-        /// <param name="span">The span of the document's text to format.</param>
-        /// <param name="options">An optional set of formatting options. If these options are not supplied the current set of options from the document's workspace will be used.</param>
-        /// <param name="cancellationToken">An optional cancellation token.</param>
-        /// <returns>The formatted document.</returns>
-        public static Task<SyntaxTree> FormatAsync(SyntaxTree syntaxTree, ISyntaxFormattingService syntaxFormattingService, TextSpan span, OptionSet options, CancellationToken cancellationToken)
-            => FormatAsync(syntaxTree, syntaxFormattingService, SpecializedCollections.SingletonEnumerable(span), options, cancellationToken);
-
-        /// <summary>
-        /// Formats the whitespace in areas of a document corresponding to multiple non-overlapping spans.
-        /// </summary>
-        /// <param name="syntaxTree">The document to format.</param>
-        /// <param name="spans">The spans of the document's text to format.</param>
-        /// <param name="options">An optional set of formatting options. If these options are not supplied the current set of options from the document's workspace will be used.</param>
-        /// <param name="cancellationToken">An optional cancellation token.</param>
-        /// <returns>The formatted document.</returns>
-        public static Task<SyntaxTree> FormatAsync(SyntaxTree syntaxTree, ISyntaxFormattingService syntaxFormattingService, IEnumerable<TextSpan> spans, OptionSet options, CancellationToken cancellationToken)
-            => FormatAsync(syntaxTree, syntaxFormattingService, spans, options, rules: null, cancellationToken);
-
-        internal static async Task<SyntaxTree> FormatAsync(SyntaxTree syntaxTree, ISyntaxFormattingService syntaxFormattingService, IEnumerable<TextSpan> spans, OptionSet options, IEnumerable<AbstractFormattingRule> rules, CancellationToken cancellationToken)
-        {
-            if (syntaxTree == null)
-            {
-                throw new ArgumentNullException(nameof(syntaxTree));
-            }
-
-            var root = await syntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
-            var documentOptions = options ?? DictionaryAnalyzerConfigOptions.Empty;
-            return syntaxTree.WithRootAndOptions(Format(root, syntaxFormattingService, spans, documentOptions, rules, cancellationToken), syntaxTree.Options);
-        }
+            => syntaxFormattingService.GetDefaultFormattingRules();
 
         /// <summary>
         /// Formats the whitespace of a syntax tree.
@@ -78,8 +29,11 @@ internal static async Task<SyntaxTree> FormatAsync(SyntaxTree syntaxTree, ISynta
         /// <param name="options">An optional set of formatting options. If these options are not supplied the current set of options from the workspace will be used.</param>
         /// <param name="cancellationToken">An optional cancellation token.</param>
         /// <returns>The formatted tree's root node.</returns>
-        public static SyntaxNode Format(SyntaxNode node, ISyntaxFormattingService syntaxFormattingService, OptionSet options, CancellationToken cancellationToken)
-            => Format(node, syntaxFormattingService, SpecializedCollections.SingletonEnumerable(node.FullSpan), options, rules: null, cancellationToken: cancellationToken);
+        public static SyntaxNode Format(SyntaxNode node, ISyntaxFormattingService syntaxFormattingService, SyntaxFormattingOptions options, CancellationToken cancellationToken)
+            => Format(node, SpecializedCollections.SingletonEnumerable(node.FullSpan), syntaxFormattingService, options, rules: null, cancellationToken: cancellationToken);
+
+        public static SyntaxNode Format(SyntaxNode node, TextSpan spanToFormat, ISyntaxFormattingService syntaxFormattingService, SyntaxFormattingOptions options, CancellationToken cancellationToken)
+            => Format(node, SpecializedCollections.SingletonEnumerable(spanToFormat), syntaxFormattingService, options, rules: null, cancellationToken: cancellationToken);
 
         /// <summary>
         /// Formats the whitespace of a syntax tree.
@@ -89,46 +43,17 @@ public static SyntaxNode Format(SyntaxNode node, ISyntaxFormattingService syntax
         /// <param name="options">An optional set of formatting options. If these options are not supplied the current set of options from the workspace will be used.</param>
         /// <param name="cancellationToken">An optional cancellation token.</param>
         /// <returns>The formatted tree's root node.</returns>
-        public static SyntaxNode Format(SyntaxNode node, ISyntaxFormattingService syntaxFormattingService, SyntaxAnnotation annotation, OptionSet options, IEnumerable<AbstractFormattingRule> rules, CancellationToken cancellationToken)
-        {
-            var spans = (annotation == SyntaxAnnotation.ElasticAnnotation)
-                ? GetElasticSpans(node)
-                : GetAnnotatedSpans(node, annotation);
-
-            return Format(node, syntaxFormattingService, spans, options, rules, cancellationToken: cancellationToken);
-        }
-
-        internal static SyntaxNode Format(SyntaxNode node, ISyntaxFormattingService syntaxFormattingService, IEnumerable<TextSpan> spans, OptionSet options, IEnumerable<AbstractFormattingRule> rules, CancellationToken cancellationToken)
-        {
-            var formattingResult = GetFormattingResult(node, syntaxFormattingService, spans, options, rules, cancellationToken);
-            return formattingResult == null ? node : formattingResult.GetFormattedRoot(cancellationToken);
-        }
-
-        internal static IList<TextChange> GetFormattedTextChanges(SyntaxNode node, ISyntaxFormattingService syntaxFormattingService, IEnumerable<TextSpan> spans, OptionSet options, IEnumerable<AbstractFormattingRule> rules, CancellationToken cancellationToken)
-        {
-            var formattingResult = GetFormattingResult(node, syntaxFormattingService, spans, options, rules, cancellationToken);
-            return formattingResult == null
-                ? SpecializedCollections.EmptyList<TextChange>()
-                : formattingResult.GetTextChanges(cancellationToken);
-        }
+        public static SyntaxNode Format(SyntaxNode node, SyntaxAnnotation annotation, ISyntaxFormattingService syntaxFormattingService, SyntaxFormattingOptions options, IEnumerable<AbstractFormattingRule>? rules, CancellationToken cancellationToken)
+            => Format(node, GetAnnotatedSpans(node, annotation), syntaxFormattingService, options, rules, cancellationToken: cancellationToken);
 
-        internal static IFormattingResult GetFormattingResult(SyntaxNode node, ISyntaxFormattingService syntaxFormattingService, IEnumerable<TextSpan> spans, OptionSet options, IEnumerable<AbstractFormattingRule> rules, CancellationToken cancellationToken)
-        {
-            if (node == null)
-            {
-                throw new ArgumentNullException(nameof(node));
-            }
+        internal static SyntaxNode Format(SyntaxNode node, IEnumerable<TextSpan> spans, ISyntaxFormattingService syntaxFormattingService, SyntaxFormattingOptions options, IEnumerable<AbstractFormattingRule>? rules, CancellationToken cancellationToken)
+            => GetFormattingResult(node, spans, syntaxFormattingService, options, rules, cancellationToken).GetFormattedRoot(cancellationToken);
 
-            if (syntaxFormattingService is null)
-            {
-                return null;
-            }
+        internal static IList<TextChange> GetFormattedTextChanges(SyntaxNode node, IEnumerable<TextSpan> spans, ISyntaxFormattingService syntaxFormattingService, SyntaxFormattingOptions options, IEnumerable<AbstractFormattingRule>? rules, CancellationToken cancellationToken)
+            => GetFormattingResult(node, spans, syntaxFormattingService, options, rules, cancellationToken).GetTextChanges(cancellationToken);
 
-            options ??= DictionaryAnalyzerConfigOptions.Empty;
-            rules ??= GetDefaultFormattingRules(syntaxFormattingService);
-            spans ??= SpecializedCollections.SingletonEnumerable(node.FullSpan);
-            return syntaxFormattingService.Format(node, spans, shouldUseFormattingSpanCollapse: false, options, rules, cancellationToken);
-        }
+        internal static IFormattingResult GetFormattingResult(SyntaxNode node, IEnumerable<TextSpan> spans, ISyntaxFormattingService syntaxFormattingService, SyntaxFormattingOptions options, IEnumerable<AbstractFormattingRule>? rules, CancellationToken cancellationToken)
+            => syntaxFormattingService.GetFormattingResult(node, spans, options, rules, cancellationToken);
 
         /// <summary>
         /// Determines the changes necessary to format the whitespace of a syntax tree.
@@ -137,7 +62,7 @@ internal static IFormattingResult GetFormattingResult(SyntaxNode node, ISyntaxFo
         /// <param name="options">An optional set of formatting options. If these options are not supplied the current set of options from the workspace will be used.</param>
         /// <param name="cancellationToken">An optional cancellation token.</param>
         /// <returns>The changes necessary to format the tree.</returns>
-        public static IList<TextChange> GetFormattedTextChanges(SyntaxNode node, ISyntaxFormattingService syntaxFormattingService, OptionSet options, CancellationToken cancellationToken)
-            => GetFormattedTextChanges(node, syntaxFormattingService, SpecializedCollections.SingletonEnumerable(node.FullSpan), options, rules: null, cancellationToken: cancellationToken);
+        public static IList<TextChange> GetFormattedTextChanges(SyntaxNode node, ISyntaxFormattingService syntaxFormattingService, SyntaxFormattingOptions options, CancellationToken cancellationToken)
+            => GetFormattedTextChanges(node, SpecializedCollections.SingletonEnumerable(node.FullSpan), syntaxFormattingService, options, rules: null, cancellationToken: cancellationToken);
     }
 }
diff --git a/src/CodeStyle/Core/Analyzers/FormattingAnalyzerHelper.cs b/src/CodeStyle/Core/Analyzers/FormattingAnalyzerHelper.cs
index 0913f35235778..e6a0dd174a082 100644
--- a/src/CodeStyle/Core/Analyzers/FormattingAnalyzerHelper.cs
+++ b/src/CodeStyle/Core/Analyzers/FormattingAnalyzerHelper.cs
@@ -5,29 +5,28 @@
 #nullable disable
 
 using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Text;
 
 #if CODE_STYLE
 using Formatter = Microsoft.CodeAnalysis.Formatting.FormatterHelper;
-using FormatterState = Microsoft.CodeAnalysis.Formatting.ISyntaxFormattingService;
-using OptionSet = Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions;
+using FormattingProvider = Microsoft.CodeAnalysis.Formatting.ISyntaxFormattingService;
 #else
-using Microsoft.CodeAnalysis.Options;
-using Microsoft.CodeAnalysis.Formatting;
-using FormatterState = Microsoft.CodeAnalysis.Workspace;
+using FormattingProvider = Microsoft.CodeAnalysis.Host.HostWorkspaceServices;
 #endif
 
 namespace Microsoft.CodeAnalysis.CodeStyle
 {
     internal static class FormattingAnalyzerHelper
     {
-        internal static void AnalyzeSyntaxTree(SyntaxTreeAnalysisContext context, FormatterState formatterState, DiagnosticDescriptor descriptor, OptionSet options)
+        internal static void AnalyzeSyntaxTree(SyntaxTreeAnalysisContext context, FormattingProvider formattingProvider, DiagnosticDescriptor descriptor, SyntaxFormattingOptions options)
         {
             var tree = context.Tree;
             var cancellationToken = context.CancellationToken;
 
             var oldText = tree.GetText(cancellationToken);
-            var formattingChanges = Formatter.GetFormattedTextChanges(tree.GetRoot(cancellationToken), formatterState, options, cancellationToken);
+
+            var formattingChanges = Formatter.GetFormattedTextChanges(tree.GetRoot(cancellationToken), formattingProvider, options, cancellationToken);
 
             // formattingChanges could include changes that impact a larger section of the original document than
             // necessary. Before reporting diagnostics, process the changes to minimize the span of individual
diff --git a/src/CodeStyle/Core/CodeFixes/FormattingCodeFixHelper.cs b/src/CodeStyle/Core/CodeFixes/FormattingCodeFixHelper.cs
index e3b7be03eac26..c6f074a545a51 100644
--- a/src/CodeStyle/Core/CodeFixes/FormattingCodeFixHelper.cs
+++ b/src/CodeStyle/Core/CodeFixes/FormattingCodeFixHelper.cs
@@ -2,27 +2,24 @@
 // 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.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Text;
 
 #if CODE_STYLE
 using Formatter = Microsoft.CodeAnalysis.Formatting.FormatterHelper;
-using FormatterState = Microsoft.CodeAnalysis.Formatting.ISyntaxFormattingService;
-using OptionSet = Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions;
+using FormattingProvider = Microsoft.CodeAnalysis.Formatting.ISyntaxFormattingService;
 #else
-using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Options;
-using FormatterState = Microsoft.CodeAnalysis.Workspace;
+using FormattingProvider = Microsoft.CodeAnalysis.Host.HostWorkspaceServices;
 #endif
 
 namespace Microsoft.CodeAnalysis
 {
     internal static class FormattingCodeFixHelper
     {
-        internal static async Task<SyntaxTree> FixOneAsync(SyntaxTree syntaxTree, FormatterState formatterState, OptionSet options, Diagnostic diagnostic, CancellationToken cancellationToken)
+        internal static async Task<SyntaxTree> FixOneAsync(SyntaxTree syntaxTree, FormattingProvider formattingProvider, SyntaxFormattingOptions options, Diagnostic diagnostic, CancellationToken cancellationToken)
         {
             // The span to format is the full line(s) containing the diagnostic
             var text = await syntaxTree.GetTextAsync(cancellationToken).ConfigureAwait(false);
@@ -33,11 +30,7 @@ internal static async Task<SyntaxTree> FixOneAsync(SyntaxTree syntaxTree, Format
                 text.Lines[diagnosticLinePositionSpan.End.Line].End);
 
             var root = await syntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
-#if CODE_STYLE
-            var formattedRoot = Formatter.Format(root, formatterState, new[] { spanToFormat }, options, Formatter.GetDefaultFormattingRules(formatterState), cancellationToken);
-#else
-            var formattedRoot = Formatter.Format(root, spanToFormat, formatterState, options, cancellationToken);
-#endif
+            var formattedRoot = Formatter.Format(root, spanToFormat, formattingProvider, options, cancellationToken);
 
             return syntaxTree.WithRootAndOptions(formattedRoot, syntaxTree.Options);
         }
diff --git a/src/CodeStyle/Core/CodeFixes/FormattingCodeFixProvider.cs b/src/CodeStyle/Core/CodeFixes/FormattingCodeFixProvider.cs
index dbffe192f1881..b2782fc2ace61 100644
--- a/src/CodeStyle/Core/CodeFixes/FormattingCodeFixProvider.cs
+++ b/src/CodeStyle/Core/CodeFixes/FormattingCodeFixProvider.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System.Collections.Immutable;
 using System.Threading;
 using System.Threading.Tasks;
@@ -11,16 +9,14 @@
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Formatting;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 
 #if CODE_STYLE
-using OptionSet = Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions;
 using Formatter = Microsoft.CodeAnalysis.Formatting.FormatterHelper;
 #endif
 
 namespace Microsoft.CodeAnalysis.CodeStyle
 {
-    using ISyntaxFormattingService = ISyntaxFormattingService;
-
     internal abstract class AbstractFormattingCodeFixProvider : CodeFixProvider
     {
         public sealed override ImmutableArray<string> FixableDiagnosticIds
@@ -46,17 +42,17 @@ public sealed override Task RegisterCodeFixesAsync(CodeFixContext context)
         private async Task<Document> FixOneAsync(CodeFixContext context, Diagnostic diagnostic, CancellationToken cancellationToken)
         {
             var options = await GetOptionsAsync(context.Document, cancellationToken).ConfigureAwait(false);
-            var tree = await context.Document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
+            var tree = await context.Document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
             var updatedTree = await FormattingCodeFixHelper.FixOneAsync(tree, SyntaxFormattingService, options, diagnostic, cancellationToken).ConfigureAwait(false);
             return context.Document.WithText(await updatedTree.GetTextAsync(cancellationToken).ConfigureAwait(false));
         }
 
-        private static async Task<OptionSet> GetOptionsAsync(Document document, CancellationToken cancellationToken)
+        private static async Task<SyntaxFormattingOptions> GetOptionsAsync(Document document, CancellationToken cancellationToken)
         {
-            var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
+            var tree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
             var analyzerConfigOptions = document.Project.AnalyzerOptions.AnalyzerConfigOptionsProvider.GetOptions(tree);
 
-            return analyzerConfigOptions;
+            return SyntaxFormattingOptions.Create(analyzerConfigOptions);
         }
 
         public sealed override FixAllProvider GetFixAllProvider()
@@ -64,7 +60,7 @@ public sealed override FixAllProvider GetFixAllProvider()
             {
                 var cancellationToken = context.CancellationToken;
                 var options = await GetOptionsAsync(document, cancellationToken).ConfigureAwait(false);
-                var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+                var syntaxRoot = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
                 var updatedSyntaxRoot = Formatter.Format(syntaxRoot, this.SyntaxFormattingService, options, cancellationToken);
                 return document.WithSyntaxRoot(updatedSyntaxRoot);
             });
diff --git a/src/EditorFeatures/CSharp/AutomaticCompletion/AutomaticLineEnderCommandHandler.cs b/src/EditorFeatures/CSharp/AutomaticCompletion/AutomaticLineEnderCommandHandler.cs
index 3462f253cac28..0962222aa5239 100644
--- a/src/EditorFeatures/CSharp/AutomaticCompletion/AutomaticLineEnderCommandHandler.cs
+++ b/src/EditorFeatures/CSharp/AutomaticCompletion/AutomaticLineEnderCommandHandler.cs
@@ -108,14 +108,14 @@ protected override Document FormatAndApplyBasedOnEndToken(Document document, int
                 return document;
             }
 
-            var options = document.GetOptionsAsync(cancellationToken).WaitAndGetResult(cancellationToken);
-
-            var changes = Formatter.GetFormattedTextChanges(
+            var options = SyntaxFormattingOptions.FromDocumentAsync(document, cancellationToken).WaitAndGetResult(cancellationToken);
+            var formatter = document.GetRequiredLanguageService<ISyntaxFormattingService>();
+            var changes = formatter.GetFormattingResult(
                 root,
                 SpecializedCollections.SingletonCollection(CommonFormattingHelpers.GetFormattingSpan(root, span.Value)),
-                document.Project.Solution.Workspace,
                 options,
-                cancellationToken: cancellationToken);
+                rules: null,
+                cancellationToken).GetTextChanges(cancellationToken);
 
             return document.ApplyTextChanges(changes, cancellationToken);
         }
diff --git a/src/EditorFeatures/CSharp/AutomaticCompletion/AutomaticLineEnderCommandHandler_Helpers.cs b/src/EditorFeatures/CSharp/AutomaticCompletion/AutomaticLineEnderCommandHandler_Helpers.cs
index 8584f95d56e60..282c438001c49 100644
--- a/src/EditorFeatures/CSharp/AutomaticCompletion/AutomaticLineEnderCommandHandler_Helpers.cs
+++ b/src/EditorFeatures/CSharp/AutomaticCompletion/AutomaticLineEnderCommandHandler_Helpers.cs
@@ -27,9 +27,11 @@ private static (SyntaxNode newRoot, int nextCaretPosition) ReplaceStatementOwner
             SyntaxNode newNode,
             SyntaxNode anchorNode,
             ImmutableArray<StatementSyntax> nodesToInsert,
+            DocumentOptionSet documentOptions,
             CancellationToken cancellationToken)
         {
-            var rootEditor = new SyntaxEditor(root, document.Project.Solution.Workspace.Services);
+            var services = document.Project.Solution.Workspace.Services;
+            var rootEditor = new SyntaxEditor(root, services);
 
             // 1. Insert the node before anchor node
             rootEditor.InsertAfter(anchorNode, nodesToInsert);
@@ -40,11 +42,15 @@ private static (SyntaxNode newRoot, int nextCaretPosition) ReplaceStatementOwner
 
             // 4. Format the new node so that the inserted braces/blocks would have correct indentation and formatting.
             var newNodeAfterInsertion = newRoot.GetAnnotatedNodes(s_replacementNodeAnnotation).Single();
+
+            var options = SyntaxFormattingOptions.Create(documentOptions, services, root.Language);
+
             var formattedNewRoot = Formatter.Format(
                 newRoot,
                 newNodeAfterInsertion.Span,
-                document.Project.Solution.Workspace,
-                cancellationToken: cancellationToken);
+                services,
+                options,
+                cancellationToken);
 
             // 4. Use the annotation to find the end of the open brace, it would be the new caret position
             var nextCaretPosition = formattedNewRoot.GetAnnotatedTokens(s_openBracePositionAnnotation).Single().Span.End;
@@ -70,11 +76,11 @@ private static SyntaxNode ReplaceNodeAndFormat(
             var newNodeAfterInsertion = newRoot.GetAnnotatedNodes(s_replacementNodeAnnotation).Single();
 
             // 4. Format the new node so that the inserted braces/blocks would have correct indentation and formatting.
-            var options = document.GetOptionsAsync(cancellationToken).WaitAndGetResult(cancellationToken);
+            var options = SyntaxFormattingOptions.FromDocumentAsync(document, cancellationToken).WaitAndGetResult(cancellationToken);
             var formattedNewRoot = Formatter.Format(
                 newRoot,
                 newNodeAfterInsertion.Span,
-                document.Project.Solution.Workspace,
+                document.Project.Solution.Workspace.Services,
                 options,
                 cancellationToken: cancellationToken);
             return formattedNewRoot;
@@ -145,6 +151,7 @@ WhileStatementSyntax or ForEachStatementSyntax or ForStatementSyntax or LockStat
                           newNode: AddBlockToEmbeddedStatementOwner(embeddedStatementOwner, documentOptions),
                           anchorNode: embeddedStatementOwner,
                           nodesToInsert: ImmutableArray<StatementSyntax>.Empty.Add(statement),
+                          documentOptions,
                           cancellationToken),
                 DoStatementSyntax doStatementNode => AddBraceToDoStatement(document, root, doStatementNode, documentOptions, statement, cancellationToken),
                 IfStatementSyntax ifStatementNode => AddBraceToIfStatement(document, root, ifStatementNode, documentOptions, statement, cancellationToken),
@@ -184,6 +191,7 @@ private static (SyntaxNode newRoot, int nextCaretPosition) AddBraceToDoStatement
                     newNode: AddBlockToEmbeddedStatementOwner(doStatementNode, documentOptions),
                     anchorNode: doStatementNode,
                     nodesToInsert: ImmutableArray<StatementSyntax>.Empty.Add(innerStatement),
+                    documentOptions,
                     cancellationToken);
             }
 
@@ -236,6 +244,7 @@ private static (SyntaxNode newRoot, int nextCaretPosition) AddBraceToIfStatement
                     AddBlockToEmbeddedStatementOwner(ifStatementNode, documentOptions),
                     ifStatementNode,
                     ImmutableArray<StatementSyntax>.Empty.Add(innerStatement),
+                    documentOptions,
                     cancellationToken);
             }
 
@@ -300,6 +309,7 @@ private static (SyntaxNode newRoot, int nextCaretPosition) AddBraceToElseClause(
                     WithBraces(elseClauseNode, documentOptions),
                     elseClauseNode.Parent!,
                     ImmutableArray<StatementSyntax>.Empty.Add(innerStatement),
+                    documentOptions,
                     cancellationToken);
             }
 
diff --git a/src/EditorFeatures/CSharp/DecompiledSource/CSharpDecompiledSourceService.cs b/src/EditorFeatures/CSharp/DecompiledSource/CSharpDecompiledSourceService.cs
index 965cd834f56e8..8aa9d86ee763f 100644
--- a/src/EditorFeatures/CSharp/DecompiledSource/CSharpDecompiledSourceService.cs
+++ b/src/EditorFeatures/CSharp/DecompiledSource/CSharpDecompiledSourceService.cs
@@ -85,11 +85,13 @@ public async Task<Document> AddSourceToAsync(Document document, Compilation symb
         public static async Task<Document> FormatDocumentAsync(Document document, CancellationToken cancellationToken)
         {
             var node = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var options = await SyntaxFormattingOptions.FromDocumentAsync(document, cancellationToken).ConfigureAwait(false);
 
             // Apply formatting rules
             var formattedDoc = await Formatter.FormatAsync(
-                 document, SpecializedCollections.SingletonEnumerable(node.FullSpan),
-                 options: null,
+                 document,
+                 SpecializedCollections.SingletonEnumerable(node.FullSpan),
+                 options,
                  CSharpDecompiledSourceFormattingRule.Instance.Concat(Formatter.GetDefaultFormattingRules(document)),
                  cancellationToken).ConfigureAwait(false);
 
diff --git a/src/EditorFeatures/CSharpTest/ExtractClass/ExtractClassTests.cs b/src/EditorFeatures/CSharpTest/ExtractClass/ExtractClassTests.cs
index 6bcb5af3edb70..07c98c2a46c2c 100644
--- a/src/EditorFeatures/CSharpTest/ExtractClass/ExtractClassTests.cs
+++ b/src/EditorFeatures/CSharpTest/ExtractClass/ExtractClassTests.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeRefactorings;
 using Microsoft.CodeAnalysis.CodeStyle;
@@ -2043,7 +2044,7 @@ public TestExtractClassOptionsService(IEnumerable<(string name, bool makeAbstrac
             public string FileName { get; set; } = "MyBase.cs";
             public string BaseName { get; set; } = "MyBase";
 
-            public Task<ExtractClassOptions?> GetExtractClassOptionsAsync(Document document, INamedTypeSymbol originalSymbol, ISymbol? selectedMember)
+            public Task<ExtractClassOptions?> GetExtractClassOptionsAsync(Document document, INamedTypeSymbol originalSymbol, ISymbol? selectedMember, CancellationToken cancellationToken)
             {
                 var availableMembers = originalSymbol.GetMembers().Where(member => MemberAndDestinationValidator.IsMemberValid(member));
 
diff --git a/src/EditorFeatures/CSharpTest/Formatting/FormattingEngineTests.cs b/src/EditorFeatures/CSharpTest/Formatting/FormattingEngineTests.cs
index c1384e96d1c75..9405a023ae8af 100644
--- a/src/EditorFeatures/CSharpTest/Formatting/FormattingEngineTests.cs
+++ b/src/EditorFeatures/CSharpTest/Formatting/FormattingEngineTests.cs
@@ -6,10 +6,12 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.BraceCompletion;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Editor.Implementation.Formatting;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Utilities;
@@ -423,103 +425,8 @@ public void M()
 
             var document = workspace.CurrentSolution.Projects.Single().Documents.Single();
             var syntaxRoot = await document.GetSyntaxRootAsync();
-
-            var node = Formatter.Format(syntaxRoot, spans, workspace);
-            Assert.Equal(expected, node.ToFullString());
-        }
-
-        [WorkItem(987373, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/987373")]
-        [WpfFact, Trait(Traits.Feature, Traits.Features.Formatting)]
-        public async Task FormatSpansWithCollapsing()
-        {
-            var code = @"class C
-{
-    public void M()
-    {
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        [|if(true){}|]
-        while(true){}
-        [|if(true){}|]
-    }
-}";
-            var expected = @"class C
-{
-    public void M()
-    {
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        if (true) { }
-        while (true) { }
-        if (true) { }
-    }
-}";
-            using var workspace = TestWorkspace.CreateCSharp(code);
-            var subjectDocument = workspace.Documents.Single();
-            var spans = subjectDocument.SelectedSpans;
-            workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options
-                .WithChangedOption(FormattingBehaviorOptions.AllowDisjointSpanMerging, true)));
-
-            var document = workspace.CurrentSolution.Projects.Single().Documents.Single();
-            var syntaxRoot = await document.GetSyntaxRootAsync();
-
-            var node = Formatter.Format(syntaxRoot, spans, workspace);
+            var options = await SyntaxFormattingOptions.FromDocumentAsync(document, CancellationToken.None).ConfigureAwait(false);
+            var node = Formatter.Format(syntaxRoot, spans, workspace.Services, options, rules: null, CancellationToken.None);
             Assert.Equal(expected, node.ToFullString());
         }
 
@@ -2284,7 +2191,11 @@ class Test
             var annotatedMarkerTrivia = markerTrivia.WithAdditionalAnnotations(annotation);
             root = root.ReplaceTrivia(markerTrivia, annotatedMarkerTrivia);
 
-            var formattedRoot = Formatter.Format(root, new AdhocWorkspace());
+            using var workspace = new AdhocWorkspace();
+
+            var options = SyntaxFormattingOptions.Default;
+
+            var formattedRoot = Formatter.Format(root, workspace.Services, options, CancellationToken.None);
             var annotatedTrivia = formattedRoot.GetAnnotatedTrivia("marker");
 
             Assert.Single(annotatedTrivia);
diff --git a/src/EditorFeatures/CSharpTest/Formatting/Indentation/CSharpFormatterTestsBase.cs b/src/EditorFeatures/CSharpTest/Formatting/Indentation/CSharpFormatterTestsBase.cs
index bbd7278095aa0..a69d3d6ab615d 100644
--- a/src/EditorFeatures/CSharpTest/Formatting/Indentation/CSharpFormatterTestsBase.cs
+++ b/src/EditorFeatures/CSharpTest/Formatting/Indentation/CSharpFormatterTestsBase.cs
@@ -81,9 +81,9 @@ private static async Task TokenFormatWorkerAsync(TestWorkspace workspace, ITextB
 
             var rules = formattingRuleProvider.CreateRule(document, position).Concat(Formatter.GetDefaultFormattingRules(document));
 
-            var documentOptions = await document.GetOptionsAsync();
-            var formatter = new CSharpSmartTokenFormatter(documentOptions, rules, root);
-            var changes = await formatter.FormatTokenAsync(workspace, token, CancellationToken.None);
+            var options = await document.GetOptionsAsync();
+            var formatter = new CSharpSmartTokenFormatter(options, rules, root);
+            var changes = await formatter.FormatTokenAsync(workspace.Services, token, CancellationToken.None);
 
             ApplyChanges(buffer, changes);
         }
diff --git a/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartIndenterEnterOnTokenTests.cs b/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartIndenterEnterOnTokenTests.cs
index 00957a31eb98f..0607bbaa86c1a 100644
--- a/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartIndenterEnterOnTokenTests.cs
+++ b/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartIndenterEnterOnTokenTests.cs
@@ -1519,7 +1519,7 @@ private static async Task AssertIndentUsingSmartTokenFormatterAsync(
 
             Assert.True(
                 CSharpIndentationService.ShouldUseSmartTokenFormatterInsteadOfIndenter(
-                    Formatter.GetDefaultFormattingRules(workspace, root.Language),
+                    Formatter.GetDefaultFormattingRules(document),
                     root, line.AsTextLine(), optionService, await document.GetOptionsAsync(), out _));
 
             var actualIndentation = await GetSmartTokenFormatterIndentationWorkerAsync(workspace, buffer, indentationLine, ch);
@@ -1562,7 +1562,7 @@ private static async Task AssertIndentNotUsingSmartTokenFormatterButUsingIndente
 
             Assert.False(
                 CSharpIndentationService.ShouldUseSmartTokenFormatterInsteadOfIndenter(
-                    Formatter.GetDefaultFormattingRules(workspace, root.Language),
+                    Formatter.GetDefaultFormattingRules(document),
                     root, line.AsTextLine(), optionService, await document.GetOptionsAsync(), out _));
 
             TestIndentation(workspace, indentationLine, expectedIndentation);
diff --git a/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartTokenFormatterFormatRangeTests.cs b/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartTokenFormatterFormatRangeTests.cs
index 4599073a45c36..335d635ebff08 100644
--- a/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartTokenFormatterFormatRangeTests.cs
+++ b/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartTokenFormatterFormatRangeTests.cs
@@ -3551,13 +3551,6 @@ internal static void AutoFormatToken(string markup, string expected, bool useTab
             Assert.Equal(expected, newSnapshot.GetText());
         }
 
-        private static Tuple<OptionSet, IEnumerable<AbstractFormattingRule>> GetService(
-            TestWorkspace workspace)
-        {
-            var options = workspace.Options;
-            return Tuple.Create(options, Formatter.GetDefaultFormattingRules(workspace, LanguageNames.CSharp));
-        }
-
         private static Task AutoFormatOnColonAsync(string codeWithMarker, string expected, SyntaxKind startTokenKind)
             => AutoFormatOnMarkerAsync(codeWithMarker, expected, SyntaxKind.ColonToken, startTokenKind);
 
@@ -3580,12 +3573,12 @@ private static async Task AutoFormatOnMarkerAsync(string initialMarkup, string e
             workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options
                 .WithChangedOption(FormattingOptions2.UseTabs, LanguageNames.CSharp, useTabs)));
 
-            var tuple = GetService(workspace);
             var testDocument = workspace.Documents.Single();
             var buffer = testDocument.GetTextBuffer();
             var position = testDocument.CursorPosition.Value;
 
             var document = workspace.CurrentSolution.GetDocument(testDocument.Id);
+            var rules = Formatter.GetDefaultFormattingRules(document);
 
             var root = (CompilationUnitSyntax)await document.GetSyntaxRootAsync();
             var endToken = root.FindToken(position);
@@ -3595,7 +3588,8 @@ private static async Task AutoFormatOnMarkerAsync(string initialMarkup, string e
             }
 
             Assert.Equal(tokenKind, endToken.Kind());
-            var formatter = new CSharpSmartTokenFormatter(tuple.Item1, tuple.Item2, root);
+            var options = await document.GetOptionsAsync();
+            var formatter = new CSharpSmartTokenFormatter(options, rules, root);
 
             var tokenRange = FormattingRangeHelper.FindAppropriateRange(endToken);
             if (tokenRange == null)
@@ -3610,7 +3604,7 @@ private static async Task AutoFormatOnMarkerAsync(string initialMarkup, string e
                 return;
             }
 
-            var changes = formatter.FormatRange(workspace, tokenRange.Value.Item1, tokenRange.Value.Item2, CancellationToken.None);
+            var changes = formatter.FormatRange(workspace.Services, tokenRange.Value.Item1, tokenRange.Value.Item2, CancellationToken.None);
             var actual = GetFormattedText(buffer, changes);
             Assert.Equal(expected, actual);
         }
diff --git a/src/EditorFeatures/Core/Shared/Extensions/ITextSnapshotExtensions.cs b/src/EditorFeatures/Core/Shared/Extensions/ITextSnapshotExtensions.cs
index 1237d796cacf5..4e87d9398d842 100644
--- a/src/EditorFeatures/Core/Shared/Extensions/ITextSnapshotExtensions.cs
+++ b/src/EditorFeatures/Core/Shared/Extensions/ITextSnapshotExtensions.cs
@@ -41,8 +41,11 @@ public static void FormatAndApplyToBuffer(this ITextSnapshot snapshot, TextSpan
             rules = document.GetFormattingRules(span, rules);
 
             var root = document.GetRequiredSyntaxRootSynchronously(cancellationToken);
-            var documentOptions = document.GetOptionsAsync(cancellationToken).WaitAndGetResult(cancellationToken);
-            var changes = Formatter.GetFormattedTextChanges(root, SpecializedCollections.SingletonEnumerable(span), document.Project.Solution.Workspace, documentOptions, rules, cancellationToken);
+            var formatter = document.GetRequiredLanguageService<ISyntaxFormattingService>();
+
+            var options = SyntaxFormattingOptions.FromDocumentAsync(document, cancellationToken).WaitAndGetResult(cancellationToken);
+            var result = formatter.GetFormattingResult(root, SpecializedCollections.SingletonEnumerable(span), options, rules, cancellationToken);
+            var changes = result.GetTextChanges(cancellationToken);
 
             using (Logger.LogBlock(FunctionId.Formatting_ApplyResultToBuffer, cancellationToken))
             {
diff --git a/src/EditorFeatures/TestUtilities/ExtractInterface/TestExtractInterfaceOptions.cs b/src/EditorFeatures/TestUtilities/ExtractInterface/TestExtractInterfaceOptions.cs
index 22f4c525fae87..e0f799d2b1bc1 100644
--- a/src/EditorFeatures/TestUtilities/ExtractInterface/TestExtractInterfaceOptions.cs
+++ b/src/EditorFeatures/TestUtilities/ExtractInterface/TestExtractInterfaceOptions.cs
@@ -7,6 +7,7 @@
 using System;
 using System.Collections.Generic;
 using System.Composition;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.ExtractInterface;
 using Microsoft.CodeAnalysis.Host.Mef;
@@ -44,7 +45,8 @@ public Task<ExtractInterfaceOptionsResult> GetExtractInterfaceOptionsAsync(
             List<string> conflictingTypeNames,
             string defaultNamespace,
             string generatedNameTypeParameterSuffix,
-            string languageName)
+            string languageName,
+            CancellationToken cancellationToken)
         {
             this.AllExtractableMembers = extractableMembers;
             this.DefaultInterfaceName = defaultInterfaceName;
diff --git a/src/EditorFeatures/TestUtilities/Formatting/CoreFormatterTestsBase.cs b/src/EditorFeatures/TestUtilities/Formatting/CoreFormatterTestsBase.cs
index 1437707b5a6b4..94a610785dc8e 100644
--- a/src/EditorFeatures/TestUtilities/Formatting/CoreFormatterTestsBase.cs
+++ b/src/EditorFeatures/TestUtilities/Formatting/CoreFormatterTestsBase.cs
@@ -8,6 +8,7 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editor.Implementation.Formatting;
 using Microsoft.CodeAnalysis.Editor.Implementation.SmartIndent;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Utilities;
@@ -140,27 +141,6 @@ private TestWorkspace CreateWorkspace(string codeWithMarker)
                 ? TestWorkspace.CreateCSharp(codeWithMarker, composition: s_composition)
                 : TestWorkspace.CreateVisualBasic(codeWithMarker, composition: s_composition);
 
-        internal void AssertFormatWithTransformation(Workspace workspace, string expected, OptionSet optionSet, IEnumerable<AbstractFormattingRule> rules, SyntaxNode root)
-        {
-            var newRootNode = Formatter.Format(root, SpecializedCollections.SingletonEnumerable(root.FullSpan), workspace, optionSet, rules, CancellationToken.None);
-
-            Assert.Equal(expected, newRootNode.ToFullString());
-
-            // test doesn't use parsing option. add one if needed later
-            var newRootNodeFromString = ParseCompilationUnit(expected);
-
-            // simple check to see whether two nodes are equivalent each other.
-            Assert.True(newRootNodeFromString.IsEquivalentTo(newRootNode));
-        }
-
-        internal static void AssertFormat(Workspace workspace, string expected, OptionSet optionSet, IEnumerable<AbstractFormattingRule> rules, ITextBuffer clonedBuffer, SyntaxNode root)
-        {
-            var changes = Formatter.GetFormattedTextChanges(root, SpecializedCollections.SingletonEnumerable(root.FullSpan), workspace, optionSet, rules, CancellationToken.None);
-            var actual = ApplyResultAndGetFormattedText(clonedBuffer, changes);
-
-            Assert.Equal(expected, actual);
-        }
-
         private static string ApplyResultAndGetFormattedText(ITextBuffer buffer, IList<TextChange> changes)
         {
             using (var edit = buffer.CreateEdit())
@@ -199,26 +179,29 @@ protected async Task AssertFormatAsync(string expected, string code, IEnumerable
                 factory.TextSpan = spans.First();
             }
 
-            var options = workspace.Options;
+            var optionSet = workspace.Options;
             if (changedOptionSet != null)
             {
                 foreach (var entry in changedOptionSet)
                 {
-                    options = options.WithChangedOption(entry.Key, entry.Value);
+                    optionSet = optionSet.WithChangedOption(entry.Key, entry.Value);
                 }
             }
 
             var root = await syntaxTree.GetRootAsync();
-            var rules = formattingRuleProvider.CreateRule(workspace.CurrentSolution.GetDocument(syntaxTree), 0).Concat(Formatter.GetDefaultFormattingRules(workspace, root.Language));
+            var options = SyntaxFormattingOptions.Create(optionSet, workspace.Services, root.Language);
+
+            document = workspace.CurrentSolution.GetDocument(syntaxTree);
+            var rules = formattingRuleProvider.CreateRule(document, 0).Concat(Formatter.GetDefaultFormattingRules(document));
             AssertFormat(workspace, expected, options, rules, clonedBuffer, root, spans);
 
             // format with node and transform
             AssertFormatWithTransformation(workspace, expected, options, rules, root, spans);
         }
 
-        internal void AssertFormatWithTransformation(Workspace workspace, string expected, OptionSet optionSet, IEnumerable<AbstractFormattingRule> rules, SyntaxNode root, IEnumerable<TextSpan> spans)
+        internal void AssertFormatWithTransformation(Workspace workspace, string expected, SyntaxFormattingOptions options, IEnumerable<AbstractFormattingRule> rules, SyntaxNode root, IEnumerable<TextSpan> spans)
         {
-            var newRootNode = Formatter.Format(root, spans, workspace, optionSet, rules, CancellationToken.None);
+            var newRootNode = Formatter.Format(root, spans, workspace.Services, options, rules, CancellationToken.None);
 
             Assert.Equal(expected, newRootNode.ToFullString());
 
@@ -229,9 +212,9 @@ internal void AssertFormatWithTransformation(Workspace workspace, string expecte
             Assert.True(newRootNodeFromString.IsEquivalentTo(newRootNode));
         }
 
-        internal void AssertFormat(Workspace workspace, string expected, OptionSet optionSet, IEnumerable<AbstractFormattingRule> rules, ITextBuffer clonedBuffer, SyntaxNode root, IEnumerable<TextSpan> spans)
+        internal void AssertFormat(Workspace workspace, string expected, SyntaxFormattingOptions options, IEnumerable<AbstractFormattingRule> rules, ITextBuffer clonedBuffer, SyntaxNode root, IEnumerable<TextSpan> spans)
         {
-            var result = Formatter.GetFormattedTextChanges(root, spans, workspace, optionSet, rules, CancellationToken.None);
+            var result = Formatter.GetFormattedTextChanges(root, spans, workspace.Services, options, rules, CancellationToken.None);
             var actual = ApplyResultAndGetFormattedText(clonedBuffer, result);
 
             if (actual != expected)
@@ -298,7 +281,9 @@ await AssertFormatAsync(
         /// <remarks>uses an <see cref="AdhocWorkspace"/> for formatting context, since the <paramref name="node"/> is not associated with a <see cref="SyntaxTree"/> </remarks>
         protected static void AssertFormatOnArbitraryNode(SyntaxNode node, string expected)
         {
-            var result = Formatter.Format(node, new AdhocWorkspace());
+            using var workspace = new AdhocWorkspace();
+            var options = SyntaxFormattingOptions.Default;
+            var result = Formatter.Format(node, workspace.Services, options, CancellationToken.None);
             var actual = result.GetText().ToString();
 
             Assert.Equal(expected, actual);
diff --git a/src/EditorFeatures/VisualBasic/LineCommit/CommitFormatter.vb b/src/EditorFeatures/VisualBasic/LineCommit/CommitFormatter.vb
index 8edbfac6ee5b1..33467f212507f 100644
--- a/src/EditorFeatures/VisualBasic/LineCommit/CommitFormatter.vb
+++ b/src/EditorFeatures/VisualBasic/LineCommit/CommitFormatter.vb
@@ -94,7 +94,8 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.LineCommit
                     Dim root = document.GetSyntaxRootSynchronously(cancellationToken)
                     Dim newRoot = CodeCleaner.CleanupAsync(root,
                                                            textSpanToFormat,
-                                                           document.Project.Solution.Workspace,
+                                                           documentOptions,
+                                                           document.Project.Solution.Workspace.Services,
                                                            codeCleanups,
                                                            cancellationToken).WaitAndGetResult(cancellationToken)
                     If root Is newRoot Then
@@ -142,40 +143,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.LineCommit
             ' based on changes made to dirty spans, get right formatting rules to apply
             Dim rules = GetFormattingRules(document, documentOptions, spanToFormat, oldDirtySpan, oldTree, newDirtySpan, newTree, cancellationToken)
 
-            Return New SimpleCodeCleanupProvider(PredefinedCodeCleanupProviderNames.Format,
-                                                 Function(doc, spans, c) FormatAsync(doc, spans, documentOptions, rules, c),
-                                                 Function(r, spans, w, c) Format(r, spans, w, documentOptions, rules, c))
-        End Function
-
-        Private Shared Async Function FormatAsync(document As Document, spans As ImmutableArray(Of TextSpan), options As OptionSet, rules As IEnumerable(Of AbstractFormattingRule), cancellationToken As CancellationToken) As Task(Of Document)
-            ' if old text already exist, use fast path for formatting
-            Dim oldText As SourceText = Nothing
-
-            If document.TryGetText(oldText) Then
-                Dim root = Await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(False)
-                Dim newText = oldText.WithChanges(Formatter.GetFormattedTextChanges(root, spans, document.Project.Solution.Workspace, options, rules, cancellationToken))
-                Return document.WithText(newText)
-            End If
-
-            Return Await Formatter.FormatAsync(document, spans, options, rules, cancellationToken).ConfigureAwait(False)
-        End Function
-
-        Private Shared Function Format(root As SyntaxNode, spans As ImmutableArray(Of TextSpan), workspace As Workspace, options As OptionSet, rules As IEnumerable(Of AbstractFormattingRule), cancellationToken As CancellationToken) As SyntaxNode
-            ' if old text already exist, use fast path for formatting
-            Dim oldText As SourceText = Nothing
-
-            If root.SyntaxTree IsNot Nothing AndAlso root.SyntaxTree.TryGetText(oldText) Then
-                Dim changes = Formatter.GetFormattedTextChanges(root, spans, workspace, options, rules, cancellationToken)
-
-                ' no change
-                If changes.Count = 0 Then
-                    Return root
-                End If
-
-                Return root.SyntaxTree.WithChangedText(oldText.WithChanges(changes)).GetRoot(cancellationToken)
-            End If
-
-            Return Formatter.Format(root, spans, workspace, options, rules, cancellationToken)
+            Return New FormatCodeCleanupProvider(rules)
         End Function
 
         Private Shared Function GetFormattingRules(
diff --git a/src/EditorFeatures/VisualBasicTest/CaseCorrecting/CaseCorrectionServiceTests.vb b/src/EditorFeatures/VisualBasicTest/CaseCorrecting/CaseCorrectionServiceTests.vb
index 3435ad3a48814..3ef31c1fa05ec 100644
--- a/src/EditorFeatures/VisualBasicTest/CaseCorrecting/CaseCorrectionServiceTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/CaseCorrecting/CaseCorrectionServiceTests.vb
@@ -10,6 +10,7 @@ Imports Microsoft.CodeAnalysis.CodeCleanup
 Imports Microsoft.CodeAnalysis.CodeCleanup.Providers
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.Extensions
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
+Imports Microsoft.CodeAnalysis.Formatting
 
 Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CaseCorrecting
     <[UseExportProvider]>
@@ -33,10 +34,11 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CaseCorrecting
             Dim buffer = hostDocument.GetTextBuffer()
             Dim document = workspace.CurrentSolution.GetDocument(hostDocument.Id)
             Dim span = (Await document.GetSyntaxRootAsync()).FullSpan
+            Dim options = Await SyntaxFormattingOptions.FromDocumentAsync(document, CancellationToken.None)
 
             Dim service = document.GetLanguageService(Of ICodeCleanerService)
             Dim newDocument = Await service.CleanupAsync(
-                document, ImmutableArray.Create(span),
+                document, ImmutableArray.Create(span), options,
                 ImmutableArray.Create(Of ICodeCleanupProvider)(New CaseCorrectionCodeCleanupProvider()),
                 CancellationToken.None)
 
diff --git a/src/EditorFeatures/VisualBasicTest/Formatting/Indentation/SmartTokenFormatter_FormatTokenTests.vb b/src/EditorFeatures/VisualBasicTest/Formatting/Indentation/SmartTokenFormatter_FormatTokenTests.vb
index 13f9f9c369a03..e2502f5158345 100644
--- a/src/EditorFeatures/VisualBasicTest/Formatting/Indentation/SmartTokenFormatter_FormatTokenTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/Formatting/Indentation/SmartTokenFormatter_FormatTokenTests.vb
@@ -207,8 +207,9 @@ End Class
                             formattingRules, root, line.AsTextLine, optionService, workspace.Options,
                             Nothing, ignoreMissingToken))
 
-                Dim smartFormatter = New VisualBasicSmartTokenFormatter(Await document.GetOptionsAsync(CancellationToken.None), formattingRules, root)
-                Dim changes = Await smartFormatter.FormatTokenAsync(workspace, token, Nothing)
+                Dim formatOptions = Await SyntaxFormattingOptions.FromDocumentAsync(document, CancellationToken.None)
+                Dim smartFormatter = New VisualBasicSmartTokenFormatter(formatOptions, formattingRules, root)
+                Dim changes = Await smartFormatter.FormatTokenAsync(workspace.Services, token, Nothing)
 
                 Using edit = buffer.CreateEdit()
                     For Each change In changes
diff --git a/src/EditorFeatures/VisualBasicTest/Formatting/VisualBasicFormatterTestBase.vb b/src/EditorFeatures/VisualBasicTest/Formatting/VisualBasicFormatterTestBase.vb
index 8f292b13e5798..370541bae9212 100644
--- a/src/EditorFeatures/VisualBasicTest/Formatting/VisualBasicFormatterTestBase.vb
+++ b/src/EditorFeatures/VisualBasicTest/Formatting/VisualBasicFormatterTestBase.vb
@@ -58,11 +58,16 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Formatting
                 End If
 
                 Dim rules = formattingRuleProvider.CreateRule(document, 0).Concat(Formatter.GetDefaultFormattingRules(document))
+                Dim options = Await SyntaxFormattingOptions.FromDocumentAsync(document, CancellationToken.None)
 
                 Dim changes = Formatter.GetFormattedTextChanges(
                     Await syntaxTree.GetRootAsync(),
                     workspace.Documents.First(Function(d) d.SelectedSpans.Any()).SelectedSpans,
-                    workspace, Await document.GetOptionsAsync(CancellationToken.None), rules, CancellationToken.None)
+                    workspace.Services,
+                    options,
+                    rules,
+                    CancellationToken.None)
+
                 AssertResult(expected, clonedBuffer, changes)
             End Using
         End Function
diff --git a/src/Features/CSharp/Portable/BraceCompletion/CurlyBraceCompletionService.cs b/src/Features/CSharp/Portable/BraceCompletion/CurlyBraceCompletionService.cs
index c4f71d2592a47..c6f03c8f89987 100644
--- a/src/Features/CSharp/Portable/BraceCompletion/CurlyBraceCompletionService.cs
+++ b/src/Features/CSharp/Portable/BraceCompletion/CurlyBraceCompletionService.cs
@@ -296,8 +296,10 @@ private static bool ContainsOnlyWhitespace(SourceText text, int openingPosition,
 
             var spanToFormat = TextSpan.FromBounds(Math.Max(startPoint, 0), endPoint);
             var rules = document.GetFormattingRules(spanToFormat, braceFormattingIndentationRules);
+            var services = document.Project.Solution.Workspace.Services;
+            var formattingOptions = SyntaxFormattingOptions.Create(documentOptions, services, document.Project.Language);
             var result = Formatter.GetFormattingResult(
-                root, SpecializedCollections.SingletonEnumerable(spanToFormat), document.Project.Solution.Workspace, documentOptions, rules, cancellationToken);
+                root, SpecializedCollections.SingletonEnumerable(spanToFormat), services, formattingOptions, rules, cancellationToken);
             if (result == null)
             {
                 return (ImmutableArray<TextChange>.Empty, closingPoint);
diff --git a/src/Features/CSharp/Portable/CodeFixes/Suppression/CSharpSuppressionCodeFixProvider.cs b/src/Features/CSharp/Portable/CodeFixes/Suppression/CSharpSuppressionCodeFixProvider.cs
index 5c7f149b05ce2..60a557cfeb8c3 100644
--- a/src/Features/CSharp/Portable/CodeFixes/Suppression/CSharpSuppressionCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/CodeFixes/Suppression/CSharpSuppressionCodeFixProvider.cs
@@ -16,6 +16,7 @@
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Formatting;
+using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Simplification;
 using Microsoft.CodeAnalysis.Text;
@@ -31,27 +32,27 @@ public CSharpSuppressionCodeFixProvider()
         {
         }
 
-        protected override SyntaxTriviaList CreatePragmaRestoreDirectiveTrivia(Diagnostic diagnostic, Func<SyntaxNode, SyntaxNode> formatNode, bool needsLeadingEndOfLine, bool needsTrailingEndOfLine)
+        protected override SyntaxTriviaList CreatePragmaRestoreDirectiveTrivia(Diagnostic diagnostic, Func<SyntaxNode, CancellationToken, SyntaxNode> formatNode, bool needsLeadingEndOfLine, bool needsTrailingEndOfLine, CancellationToken cancellationToken)
         {
             var restoreKeyword = SyntaxFactory.Token(SyntaxKind.RestoreKeyword);
-            return CreatePragmaDirectiveTrivia(restoreKeyword, diagnostic, formatNode, needsLeadingEndOfLine, needsTrailingEndOfLine);
+            return CreatePragmaDirectiveTrivia(restoreKeyword, diagnostic, formatNode, needsLeadingEndOfLine, needsTrailingEndOfLine, cancellationToken);
         }
 
         protected override SyntaxTriviaList CreatePragmaDisableDirectiveTrivia(
-            Diagnostic diagnostic, Func<SyntaxNode, SyntaxNode> formatNode, bool needsLeadingEndOfLine, bool needsTrailingEndOfLine)
+            Diagnostic diagnostic, Func<SyntaxNode, CancellationToken, SyntaxNode> formatNode, bool needsLeadingEndOfLine, bool needsTrailingEndOfLine, CancellationToken cancellationToken)
         {
             var disableKeyword = SyntaxFactory.Token(SyntaxKind.DisableKeyword);
-            return CreatePragmaDirectiveTrivia(disableKeyword, diagnostic, formatNode, needsLeadingEndOfLine, needsTrailingEndOfLine);
+            return CreatePragmaDirectiveTrivia(disableKeyword, diagnostic, formatNode, needsLeadingEndOfLine, needsTrailingEndOfLine, cancellationToken);
         }
 
         private static SyntaxTriviaList CreatePragmaDirectiveTrivia(
-            SyntaxToken disableOrRestoreKeyword, Diagnostic diagnostic, Func<SyntaxNode, SyntaxNode> formatNode, bool needsLeadingEndOfLine, bool needsTrailingEndOfLine)
+            SyntaxToken disableOrRestoreKeyword, Diagnostic diagnostic, Func<SyntaxNode, CancellationToken, SyntaxNode> formatNode, bool needsLeadingEndOfLine, bool needsTrailingEndOfLine, CancellationToken cancellationToken)
         {
             var diagnosticId = GetOrMapDiagnosticId(diagnostic, out var includeTitle);
             var id = SyntaxFactory.IdentifierName(diagnosticId);
             var ids = new SeparatedSyntaxList<ExpressionSyntax>().Add(id);
             var pragmaDirective = SyntaxFactory.PragmaWarningDirectiveTrivia(disableOrRestoreKeyword, ids, true);
-            pragmaDirective = (PragmaWarningDirectiveTriviaSyntax)formatNode(pragmaDirective);
+            pragmaDirective = (PragmaWarningDirectiveTriviaSyntax)formatNode(pragmaDirective, cancellationToken);
             var pragmaDirectiveTrivia = SyntaxFactory.Trivia(pragmaDirective);
             var endOfLineTrivia = SyntaxFactory.CarriageReturnLineFeed;
             var triviaList = SyntaxFactory.TriviaList(pragmaDirectiveTrivia);
@@ -98,8 +99,8 @@ protected override SyntaxNode AddGlobalSuppressMessageAttribute(
             ISymbol targetSymbol,
             INamedTypeSymbol suppressMessageAttribute,
             Diagnostic diagnostic,
-            Workspace workspace,
-            Compilation compilation,
+            HostWorkspaceServices services,
+            SyntaxFormattingOptions options,
             IAddImportsService addImportsService,
             CancellationToken cancellationToken)
         {
diff --git a/src/Features/CSharp/Portable/Formatting/CSharpFormattingInteractionService.cs b/src/Features/CSharp/Portable/Formatting/CSharpFormattingInteractionService.cs
index 366877442ed69..205f41e2e3885 100644
--- a/src/Features/CSharp/Portable/Formatting/CSharpFormattingInteractionService.cs
+++ b/src/Features/CSharp/Portable/Formatting/CSharpFormattingInteractionService.cs
@@ -103,16 +103,15 @@ public async Task<ImmutableArray<TextChange>> GetFormattingChangesAsync(
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             var span = textSpan ?? new TextSpan(0, root.FullSpan.Length);
             var formattingSpan = CommonFormattingHelpers.GetFormattingSpan(root, span);
-            var options = documentOptions;
-            if (options == null)
+            if (documentOptions == null)
             {
                 var inferredIndentationService = document.Project.Solution.Workspace.Services.GetRequiredService<IInferredIndentationService>();
-                options = await inferredIndentationService.GetDocumentOptionsWithInferredIndentationAsync(document, explicitFormat: true, cancellationToken: cancellationToken).ConfigureAwait(false);
+                documentOptions = await inferredIndentationService.GetDocumentOptionsWithInferredIndentationAsync(document, explicitFormat: true, cancellationToken: cancellationToken).ConfigureAwait(false);
             }
 
-            return Formatter.GetFormattedTextChanges(root,
-                SpecializedCollections.SingletonEnumerable(formattingSpan),
-                document.Project.Solution.Workspace, options, cancellationToken).ToImmutableArray();
+            var services = document.Project.Solution.Workspace.Services;
+            var formattingOptions = SyntaxFormattingOptions.Create(documentOptions, services, document.Project.Language);
+            return Formatter.GetFormattedTextChanges(root, SpecializedCollections.SingletonEnumerable(formattingSpan), services, formattingOptions, cancellationToken).ToImmutableArray();
         }
 
         public async Task<ImmutableArray<TextChange>> GetFormattingChangesOnPasteAsync(
@@ -124,23 +123,20 @@ public async Task<ImmutableArray<TextChange>> GetFormattingChangesOnPasteAsync(
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
             var formattingSpan = CommonFormattingHelpers.GetFormattingSpan(root, textSpan);
-            var service = document.GetLanguageService<ISyntaxFormattingService>();
-            if (service == null)
-            {
-                return ImmutableArray<TextChange>.Empty;
-            }
+            var service = document.GetRequiredLanguageService<ISyntaxFormattingService>();
 
             var rules = new List<AbstractFormattingRule>() { new PasteFormattingRule() };
             rules.AddRange(service.GetDefaultFormattingRules());
 
-            var options = documentOptions;
-            if (options == null)
+            if (documentOptions == null)
             {
                 var inferredIndentationService = document.Project.Solution.Workspace.Services.GetRequiredService<IInferredIndentationService>();
-                options = await inferredIndentationService.GetDocumentOptionsWithInferredIndentationAsync(document, explicitFormat: false, cancellationToken: cancellationToken).ConfigureAwait(false);
+                documentOptions = await inferredIndentationService.GetDocumentOptionsWithInferredIndentationAsync(document, explicitFormat: false, cancellationToken: cancellationToken).ConfigureAwait(false);
             }
 
-            return Formatter.GetFormattedTextChanges(root, SpecializedCollections.SingletonEnumerable(formattingSpan), document.Project.Solution.Workspace, options, rules, cancellationToken).ToImmutableArray();
+            var formattingOptions = SyntaxFormattingOptions.Create(documentOptions, document.Project.Solution.Workspace.Services, document.Project.Language);
+            var result = service.GetFormattingResult(root, SpecializedCollections.SingletonEnumerable(formattingSpan), formattingOptions, rules, cancellationToken);
+            return result.GetTextChanges(cancellationToken).ToImmutableArray();
         }
 
         private static IEnumerable<AbstractFormattingRule> GetFormattingRules(Document document, int position, SyntaxToken tokenBeforeCaret)
@@ -218,11 +214,12 @@ public async Task<ImmutableArray<TextChange>> GetFormattingChangesAsync(
                 return ImmutableArray<TextChange>.Empty;
             }
 
-            var options = documentOptions;
-            if (options == null)
+            var services = document.Project.Solution.Workspace.Services;
+
+            if (documentOptions == null)
             {
-                var inferredIndentationService = document.Project.Solution.Workspace.Services.GetRequiredService<IInferredIndentationService>();
-                options = await inferredIndentationService.GetDocumentOptionsWithInferredIndentationAsync(document, explicitFormat: false, cancellationToken: cancellationToken).ConfigureAwait(false);
+                var inferredIndentationService = services.GetRequiredService<IInferredIndentationService>();
+                documentOptions = await inferredIndentationService.GetDocumentOptionsWithInferredIndentationAsync(document, explicitFormat: false, cancellationToken: cancellationToken).ConfigureAwait(false);
             }
 
             // Do not attempt to format on open/close brace if autoformat on close brace feature is
@@ -254,26 +251,26 @@ public async Task<ImmutableArray<TextChange>> GetFormattingChangesAsync(
             // However, we won't touch any of the other code in that block, unlike if we were
             // formatting.
             var onlySmartIndent =
-                (token.IsKind(SyntaxKind.CloseBraceToken) && OnlySmartIndentCloseBrace(options)) ||
-                (token.IsKind(SyntaxKind.OpenBraceToken) && OnlySmartIndentOpenBrace(options));
+                (token.IsKind(SyntaxKind.CloseBraceToken) && OnlySmartIndentCloseBrace(documentOptions)) ||
+                (token.IsKind(SyntaxKind.OpenBraceToken) && OnlySmartIndentOpenBrace(documentOptions));
 
             if (onlySmartIndent)
             {
                 // if we're only doing smart indent, then ignore all edits to this token that occur before
                 // the span of the token. They're irrelevant and may screw up other code the user doesn't 
                 // want touched.
-                var tokenEdits = await FormatTokenAsync(document, options, token, formattingRules, cancellationToken).ConfigureAwait(false);
+                var tokenEdits = await FormatTokenAsync(document, documentOptions, token, formattingRules, cancellationToken).ConfigureAwait(false);
                 return tokenEdits.Where(t => t.Span.Start >= token.FullSpan.Start).ToImmutableArray();
             }
 
             // if formatting range fails, do format token one at least
-            var changes = await FormatRangeAsync(document, options, token, formattingRules, cancellationToken).ConfigureAwait(false);
+            var changes = await FormatRangeAsync(document, documentOptions, token, formattingRules, cancellationToken).ConfigureAwait(false);
             if (changes.Length > 0)
             {
                 return changes;
             }
 
-            return (await FormatTokenAsync(document, options, token, formattingRules, cancellationToken).ConfigureAwait(false)).ToImmutableArray();
+            return (await FormatTokenAsync(document, documentOptions, token, formattingRules, cancellationToken).ConfigureAwait(false)).ToImmutableArray();
         }
 
         private static bool OnlySmartIndentCloseBrace(DocumentOptionSet options)
@@ -306,12 +303,12 @@ private static async Task<IList<TextChange>> FormatTokenAsync(Document document,
         {
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             var formatter = CreateSmartTokenFormatter(options, formattingRules, root);
-            var changes = await formatter.FormatTokenAsync(document.Project.Solution.Workspace, token, cancellationToken).ConfigureAwait(false);
+            var changes = await formatter.FormatTokenAsync(document.Project.Solution.Workspace.Services, token, cancellationToken).ConfigureAwait(false);
             return changes;
         }
 
-        private static ISmartTokenFormatter CreateSmartTokenFormatter(OptionSet optionSet, IEnumerable<AbstractFormattingRule> formattingRules, SyntaxNode root)
-            => new CSharpSmartTokenFormatter(optionSet, formattingRules, (CompilationUnitSyntax)root);
+        private static ISmartTokenFormatter CreateSmartTokenFormatter(OptionSet options, IEnumerable<AbstractFormattingRule> formattingRules, SyntaxNode root)
+            => new CSharpSmartTokenFormatter(options, formattingRules, (CompilationUnitSyntax)root);
 
         private static async Task<ImmutableArray<TextChange>> FormatRangeAsync(
             Document document,
@@ -340,7 +337,7 @@ private static async Task<ImmutableArray<TextChange>> FormatRangeAsync(
 
             var formatter = new CSharpSmartTokenFormatter(options, formattingRules, (CompilationUnitSyntax)root);
 
-            var changes = formatter.FormatRange(document.Project.Solution.Workspace, tokenRange.Value.Item1, tokenRange.Value.Item2, cancellationToken);
+            var changes = formatter.FormatRange(document.Project.Solution.Workspace.Services, tokenRange.Value.Item1, tokenRange.Value.Item2, cancellationToken);
             return changes.ToImmutableArray();
         }
 
diff --git a/src/Features/Core/Portable/ChangeSignature/AbstractChangeSignatureService.cs b/src/Features/Core/Portable/ChangeSignature/AbstractChangeSignatureService.cs
index b27637de58c64..f79d2c37b6f84 100644
--- a/src/Features/Core/Portable/ChangeSignature/AbstractChangeSignatureService.cs
+++ b/src/Features/Core/Portable/ChangeSignature/AbstractChangeSignatureService.cs
@@ -398,12 +398,13 @@ private static async Task<ImmutableArray<ReferencedSymbol>> FindChangeSignatureR
                 });
 
                 var annotatedNodes = newRoot.GetAnnotatedNodes<SyntaxNode>(syntaxAnnotation: changeSignatureFormattingAnnotation);
+                var formattingOptions = await SyntaxFormattingOptions.FromDocumentAsync(doc, cancellationToken).ConfigureAwait(false);
 
                 var formattedRoot = Formatter.Format(
                     newRoot,
                     changeSignatureFormattingAnnotation,
-                    doc.Project.Solution.Workspace,
-                    options: await doc.GetOptionsAsync(cancellationToken).ConfigureAwait(false),
+                    doc.Project.Solution.Workspace.Services,
+                    options: formattingOptions,
                     rules: GetFormattingRules(doc),
                     cancellationToken: CancellationToken.None);
 
diff --git a/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.GlobalSuppressMessageCodeAction.cs b/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.GlobalSuppressMessageCodeAction.cs
index 8a39bb7fd11b5..64e706190a356 100644
--- a/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.GlobalSuppressMessageCodeAction.cs
+++ b/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.GlobalSuppressMessageCodeAction.cs
@@ -7,6 +7,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.AddImports;
+using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 
 namespace Microsoft.CodeAnalysis.CodeFixes.Suppression
@@ -33,13 +34,13 @@ public GlobalSuppressMessageCodeAction(
             protected override async Task<Document> GetChangedSuppressionDocumentAsync(CancellationToken cancellationToken)
             {
                 var suppressionsDoc = await GetOrCreateSuppressionsDocumentAsync(cancellationToken).ConfigureAwait(false);
-                var workspace = suppressionsDoc.Project.Solution.Workspace;
+                var services = suppressionsDoc.Project.Solution.Workspace.Services;
                 var suppressionsRoot = await suppressionsDoc.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-                var compilation = await suppressionsDoc.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
                 var addImportsService = suppressionsDoc.GetRequiredLanguageService<IAddImportsService>();
+                var options = await SyntaxFormattingOptions.FromDocumentAsync(suppressionsDoc, cancellationToken).ConfigureAwait(false);
 
                 suppressionsRoot = Fixer.AddGlobalSuppressMessageAttribute(
-                    suppressionsRoot, _targetSymbol, _suppressMessageAttribute, _diagnostic, workspace, compilation, addImportsService, cancellationToken);
+                    suppressionsRoot, _targetSymbol, _suppressMessageAttribute, _diagnostic, services, options, addImportsService, cancellationToken);
                 return suppressionsDoc.WithSyntaxRoot(suppressionsRoot);
             }
 
diff --git a/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.GlobalSuppressMessageFixAllCodeAction.cs b/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.GlobalSuppressMessageFixAllCodeAction.cs
index b6a23d39b77e7..9cb4dbad654bd 100644
--- a/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.GlobalSuppressMessageFixAllCodeAction.cs
+++ b/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.GlobalSuppressMessageFixAllCodeAction.cs
@@ -15,6 +15,7 @@
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Formatting;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CodeFixes.Suppression
@@ -120,10 +121,10 @@ private static async Task<Solution> CreateChangedSolutionAsync(AbstractSuppressi
             protected override async Task<Document> GetChangedSuppressionDocumentAsync(CancellationToken cancellationToken)
             {
                 var suppressionsDoc = await GetOrCreateSuppressionsDocumentAsync(cancellationToken).ConfigureAwait(false);
-                var workspace = suppressionsDoc.Project.Solution.Workspace;
+                var services = suppressionsDoc.Project.Solution.Workspace.Services;
                 var suppressionsRoot = await suppressionsDoc.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-                var compilation = await suppressionsDoc.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
                 var addImportsService = suppressionsDoc.GetRequiredLanguageService<IAddImportsService>();
+                var options = await SyntaxFormattingOptions.FromDocumentAsync(suppressionsDoc, cancellationToken).ConfigureAwait(false);
 
                 foreach (var (targetSymbol, diagnostics) in _diagnosticsBySymbol)
                 {
@@ -132,7 +133,7 @@ protected override async Task<Document> GetChangedSuppressionDocumentAsync(Cance
                         Contract.ThrowIfFalse(!diagnostic.IsSuppressed);
                         suppressionsRoot = Fixer.AddGlobalSuppressMessageAttribute(
                             suppressionsRoot, targetSymbol, _suppressMessageAttribute, diagnostic,
-                            workspace, compilation, addImportsService, cancellationToken);
+                            services, options, addImportsService, cancellationToken);
                     }
                 }
 
diff --git a/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.PragmaHelpers.cs b/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.PragmaHelpers.cs
index 5a1bf7eed6ac2..20e102c4bfaab 100644
--- a/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.PragmaHelpers.cs
+++ b/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.PragmaHelpers.cs
@@ -104,8 +104,9 @@ internal static SyntaxToken GetNewStartTokenWithAddedPragma(
                 TextSpan currentDiagnosticSpan,
                 Diagnostic diagnostic,
                 AbstractSuppressionCodeFixProvider fixer,
-                Func<SyntaxNode, SyntaxNode> formatNode,
-                bool isRemoveSuppression = false)
+                Func<SyntaxNode, CancellationToken, SyntaxNode> formatNode,
+                bool isRemoveSuppression,
+                CancellationToken cancellationToken)
             {
                 var trivia = startToken.LeadingTrivia.ToImmutableArray();
                 var index = GetPositionForPragmaInsertion(trivia, currentDiagnosticSpan, fixer, isStartToken: true, triviaAtIndex: out var insertAfterTrivia);
@@ -126,8 +127,8 @@ internal static SyntaxToken GetNewStartTokenWithAddedPragma(
                 }
 
                 var pragmaTrivia = !isRemoveSuppression
-                    ? fixer.CreatePragmaDisableDirectiveTrivia(diagnostic, formatNode, needsLeadingEOL, needsTrailingEndOfLine: true)
-                    : fixer.CreatePragmaRestoreDirectiveTrivia(diagnostic, formatNode, needsLeadingEOL, needsTrailingEndOfLine: true);
+                    ? fixer.CreatePragmaDisableDirectiveTrivia(diagnostic, formatNode, needsLeadingEOL, needsTrailingEndOfLine: true, cancellationToken)
+                    : fixer.CreatePragmaRestoreDirectiveTrivia(diagnostic, formatNode, needsLeadingEOL, needsTrailingEndOfLine: true, cancellationToken);
 
                 return startToken.WithLeadingTrivia(trivia.InsertRange(index, pragmaTrivia));
             }
@@ -155,8 +156,9 @@ internal static SyntaxToken GetNewEndTokenWithAddedPragma(
                 TextSpan currentDiagnosticSpan,
                 Diagnostic diagnostic,
                 AbstractSuppressionCodeFixProvider fixer,
-                Func<SyntaxNode, SyntaxNode> formatNode,
-                bool isRemoveSuppression = false)
+                Func<SyntaxNode, CancellationToken, SyntaxNode> formatNode,
+                bool isRemoveSuppression,
+                CancellationToken cancellationToken)
             {
                 ImmutableArray<SyntaxTrivia> trivia;
                 var isEOF = fixer.IsEndOfFileToken(endToken);
@@ -186,8 +188,8 @@ internal static SyntaxToken GetNewEndTokenWithAddedPragma(
                 }
 
                 var pragmaTrivia = !isRemoveSuppression
-                    ? fixer.CreatePragmaRestoreDirectiveTrivia(diagnostic, formatNode, needsLeadingEndOfLine: true, needsTrailingEndOfLine: needsTrailingEOL)
-                    : fixer.CreatePragmaDisableDirectiveTrivia(diagnostic, formatNode, needsLeadingEndOfLine: true, needsTrailingEndOfLine: needsTrailingEOL);
+                    ? fixer.CreatePragmaRestoreDirectiveTrivia(diagnostic, formatNode, needsLeadingEndOfLine: true, needsTrailingEndOfLine: needsTrailingEOL, cancellationToken)
+                    : fixer.CreatePragmaDisableDirectiveTrivia(diagnostic, formatNode, needsLeadingEndOfLine: true, needsTrailingEndOfLine: needsTrailingEOL, cancellationToken);
 
                 if (isEOF)
                 {
diff --git a/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.PragmaWarningCodeAction.cs b/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.PragmaWarningCodeAction.cs
index 3ceb8b0e9ddcf..bb2f8de920e15 100644
--- a/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.PragmaWarningCodeAction.cs
+++ b/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.PragmaWarningCodeAction.cs
@@ -16,12 +16,14 @@ internal sealed class PragmaWarningCodeAction : AbstractSuppressionCodeAction, I
         {
             private readonly SuppressionTargetInfo _suppressionTargetInfo;
             private readonly Document _document;
+            private readonly SyntaxFormattingOptions _options;
             private readonly Diagnostic _diagnostic;
             private readonly bool _forFixMultipleContext;
 
             public static PragmaWarningCodeAction Create(
                 SuppressionTargetInfo suppressionTargetInfo,
                 Document document,
+                SyntaxFormattingOptions options,
                 Diagnostic diagnostic,
                 AbstractSuppressionCodeFixProvider fixer)
             {
@@ -29,12 +31,13 @@ public static PragmaWarningCodeAction Create(
                 // the trailing trivia on its previous token (and similarly normalize trailing trivia for end token).
                 PragmaHelpers.NormalizeTriviaOnTokens(fixer, ref document, ref suppressionTargetInfo);
 
-                return new PragmaWarningCodeAction(suppressionTargetInfo, document, diagnostic, fixer);
+                return new PragmaWarningCodeAction(suppressionTargetInfo, document, options, diagnostic, fixer);
             }
 
             private PragmaWarningCodeAction(
                 SuppressionTargetInfo suppressionTargetInfo,
                 Document document,
+                SyntaxFormattingOptions options,
                 Diagnostic diagnostic,
                 AbstractSuppressionCodeFixProvider fixer,
                 bool forFixMultipleContext = false)
@@ -42,12 +45,14 @@ private PragmaWarningCodeAction(
             {
                 _suppressionTargetInfo = suppressionTargetInfo;
                 _document = document;
+                _options = options;
                 _diagnostic = diagnostic;
                 _forFixMultipleContext = forFixMultipleContext;
             }
 
             public PragmaWarningCodeAction CloneForFixMultipleContext()
-                => new(_suppressionTargetInfo, _document, _diagnostic, Fixer, forFixMultipleContext: true);
+                => new(_suppressionTargetInfo, _document, _options, _diagnostic, Fixer, forFixMultipleContext: true);
+
             protected override string DiagnosticIdForEquivalenceKey =>
                 _forFixMultipleContext ? string.Empty : _diagnostic.Id;
 
@@ -63,13 +68,13 @@ public async Task<Document> GetChangedDocumentAsync(bool includeStartTokenChange
                     (startToken, currentDiagnosticSpan) =>
                     {
                         return includeStartTokenChange
-                            ? PragmaHelpers.GetNewStartTokenWithAddedPragma(startToken, currentDiagnosticSpan, _diagnostic, Fixer, FormatNode)
+                            ? PragmaHelpers.GetNewStartTokenWithAddedPragma(startToken, currentDiagnosticSpan, _diagnostic, Fixer, FormatNode, isRemoveSuppression: false, cancellationToken)
                             : startToken;
                     },
                     (endToken, currentDiagnosticSpan) =>
                     {
                         return includeEndTokenChange
-                            ? PragmaHelpers.GetNewEndTokenWithAddedPragma(endToken, currentDiagnosticSpan, _diagnostic, Fixer, FormatNode)
+                            ? PragmaHelpers.GetNewEndTokenWithAddedPragma(endToken, currentDiagnosticSpan, _diagnostic, Fixer, FormatNode, isRemoveSuppression: false, cancellationToken)
                             : endToken;
                     },
                     cancellationToken).ConfigureAwait(false);
@@ -78,8 +83,8 @@ public async Task<Document> GetChangedDocumentAsync(bool includeStartTokenChange
             public SyntaxToken StartToken_TestOnly => _suppressionTargetInfo.StartToken;
             public SyntaxToken EndToken_TestOnly => _suppressionTargetInfo.EndToken;
 
-            private SyntaxNode FormatNode(SyntaxNode node)
-                => Formatter.Format(node, _document.Project.Solution.Workspace);
+            private SyntaxNode FormatNode(SyntaxNode node, CancellationToken cancellationToken)
+                => Formatter.Format(node, _document.Project.Solution.Workspace.Services, _options, cancellationToken);
         }
     }
 }
diff --git a/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.RemoveSuppressionCodeAction.cs b/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.RemoveSuppressionCodeAction.cs
index 52df1bf737b14..c1d861e38b421 100644
--- a/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.RemoveSuppressionCodeAction.cs
+++ b/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.RemoveSuppressionCodeAction.cs
@@ -6,6 +6,7 @@
 
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Formatting;
 
 namespace Microsoft.CodeAnalysis.CodeFixes.Suppression
 {
@@ -35,7 +36,8 @@ public static async Task<RemoveSuppressionCodeAction> CreateAsync(
                 }
                 else if (documentOpt != null && !SuppressionHelpers.IsSynthesizedExternalSourceDiagnostic(diagnostic))
                 {
-                    return PragmaRemoveAction.Create(suppressionTargetInfo, documentOpt, diagnostic, fixer);
+                    var options = await SyntaxFormattingOptions.FromDocumentAsync(documentOpt, cancellationToken).ConfigureAwait(false);
+                    return PragmaRemoveAction.Create(suppressionTargetInfo, documentOpt, options, diagnostic, fixer);
                 }
                 else
                 {
diff --git a/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.RemoveSuppressionCodeAction_Pragma.cs b/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.RemoveSuppressionCodeAction_Pragma.cs
index 23155cd268212..856de08fb5619 100644
--- a/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.RemoveSuppressionCodeAction_Pragma.cs
+++ b/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.RemoveSuppressionCodeAction_Pragma.cs
@@ -25,11 +25,13 @@ internal abstract partial class RemoveSuppressionCodeAction
             private class PragmaRemoveAction : RemoveSuppressionCodeAction, IPragmaBasedCodeAction
             {
                 private readonly Document _document;
+                private readonly SyntaxFormattingOptions _options;
                 private readonly SuppressionTargetInfo _suppressionTargetInfo;
 
                 public static PragmaRemoveAction Create(
                     SuppressionTargetInfo suppressionTargetInfo,
                     Document document,
+                    SyntaxFormattingOptions options,
                     Diagnostic diagnostic,
                     AbstractSuppressionCodeFixProvider fixer)
                 {
@@ -37,23 +39,25 @@ public static PragmaRemoveAction Create(
                     // the trailing trivia on its previous token (and similarly normalize trailing trivia for end token).
                     PragmaHelpers.NormalizeTriviaOnTokens(fixer, ref document, ref suppressionTargetInfo);
 
-                    return new PragmaRemoveAction(suppressionTargetInfo, document, diagnostic, fixer);
+                    return new PragmaRemoveAction(suppressionTargetInfo, document, options, diagnostic, fixer);
                 }
 
                 private PragmaRemoveAction(
                     SuppressionTargetInfo suppressionTargetInfo,
                     Document document,
+                    SyntaxFormattingOptions options,
                     Diagnostic diagnostic,
                     AbstractSuppressionCodeFixProvider fixer,
                     bool forFixMultipleContext = false)
                     : base(diagnostic, fixer, forFixMultipleContext)
                 {
                     _document = document;
+                    _options = options;
                     _suppressionTargetInfo = suppressionTargetInfo;
                 }
 
                 public override RemoveSuppressionCodeAction CloneForFixMultipleContext()
-                    => new PragmaRemoveAction(_suppressionTargetInfo, _document, _diagnostic, Fixer, forFixMultipleContext: true);
+                    => new PragmaRemoveAction(_suppressionTargetInfo, _document, _options, _diagnostic, Fixer, forFixMultipleContext: true);
 
                 public override SyntaxTree SyntaxTreeToModify => _suppressionTargetInfo.StartToken.SyntaxTree;
 
@@ -81,11 +85,11 @@ public async Task<Document> GetChangedDocumentAsync(bool includeStartTokenChange
                     }
 
                     SyntaxToken getNewStartToken(SyntaxToken startToken, TextSpan currentDiagnosticSpan) => includeStartTokenChange
-                        ? GetNewTokenWithModifiedPragma(startToken, currentDiagnosticSpan, add, toggle, indexOfLeadingPragmaDisableToRemove, isStartToken: true)
+                        ? GetNewTokenWithModifiedPragma(startToken, currentDiagnosticSpan, add, toggle, indexOfLeadingPragmaDisableToRemove, isStartToken: true, cancellationToken)
                         : startToken;
 
                     SyntaxToken getNewEndToken(SyntaxToken endToken, TextSpan currentDiagnosticSpan) => includeEndTokenChange
-                        ? GetNewTokenWithModifiedPragma(endToken, currentDiagnosticSpan, add, toggle, indexOfTrailingPragmaEnableToRemove, isStartToken: false)
+                        ? GetNewTokenWithModifiedPragma(endToken, currentDiagnosticSpan, add, toggle, indexOfTrailingPragmaEnableToRemove, isStartToken: false, cancellationToken)
                         : endToken;
 
                     return await PragmaHelpers.GetChangeDocumentWithPragmaAdjustedAsync(
@@ -151,22 +155,22 @@ private static bool CanRemovePragmaTrivia(SyntaxToken token, Diagnostic diagnost
                     return false;
                 }
 
-                private SyntaxToken GetNewTokenWithModifiedPragma(SyntaxToken token, TextSpan currentDiagnosticSpan, bool add, bool toggle, int indexOfTriviaToRemoveOrToggle, bool isStartToken)
+                private SyntaxToken GetNewTokenWithModifiedPragma(SyntaxToken token, TextSpan currentDiagnosticSpan, bool add, bool toggle, int indexOfTriviaToRemoveOrToggle, bool isStartToken, CancellationToken cancellationToken)
                 {
                     return add
-                        ? GetNewTokenWithAddedPragma(token, currentDiagnosticSpan, isStartToken)
+                        ? GetNewTokenWithAddedPragma(token, currentDiagnosticSpan, isStartToken, cancellationToken)
                         : GetNewTokenWithRemovedOrToggledPragma(token, indexOfTriviaToRemoveOrToggle, isStartToken, toggle);
                 }
 
-                private SyntaxToken GetNewTokenWithAddedPragma(SyntaxToken token, TextSpan currentDiagnosticSpan, bool isStartToken)
+                private SyntaxToken GetNewTokenWithAddedPragma(SyntaxToken token, TextSpan currentDiagnosticSpan, bool isStartToken, CancellationToken cancellationToken)
                 {
                     if (isStartToken)
                     {
-                        return PragmaHelpers.GetNewStartTokenWithAddedPragma(token, currentDiagnosticSpan, _diagnostic, Fixer, FormatNode, isRemoveSuppression: true);
+                        return PragmaHelpers.GetNewStartTokenWithAddedPragma(token, currentDiagnosticSpan, _diagnostic, Fixer, FormatNode, isRemoveSuppression: true, cancellationToken);
                     }
                     else
                     {
-                        return PragmaHelpers.GetNewEndTokenWithAddedPragma(token, currentDiagnosticSpan, _diagnostic, Fixer, FormatNode, isRemoveSuppression: true);
+                        return PragmaHelpers.GetNewEndTokenWithAddedPragma(token, currentDiagnosticSpan, _diagnostic, Fixer, FormatNode, isRemoveSuppression: true, cancellationToken);
                     }
                 }
 
@@ -213,8 +217,8 @@ private async Task<bool> IsDiagnosticSuppressedBeforeLeadingPragmaAsync(int inde
                 public SyntaxToken StartToken_TestOnly => _suppressionTargetInfo.StartToken;
                 public SyntaxToken EndToken_TestOnly => _suppressionTargetInfo.EndToken;
 
-                private SyntaxNode FormatNode(SyntaxNode node)
-                    => Formatter.Format(node, _document.Project.Solution.Workspace);
+                private SyntaxNode FormatNode(SyntaxNode node, CancellationToken cancellationToken)
+                    => Formatter.Format(node, _document.Project.Solution.Workspace.Services, _options, cancellationToken);
             }
         }
     }
diff --git a/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.cs b/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.cs
index 68c9393666f94..63d8a83d48eec 100644
--- a/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.cs
+++ b/src/Features/Core/Portable/CodeFixes/Suppression/AbstractSuppressionCodeFixProvider.cs
@@ -13,6 +13,7 @@
 using Microsoft.CodeAnalysis.AddImports;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Formatting;
+using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
@@ -42,16 +43,16 @@ public FixAllProvider GetFixAllProvider()
         public bool IsFixableDiagnostic(Diagnostic diagnostic)
             => SuppressionHelpers.CanBeSuppressed(diagnostic) || SuppressionHelpers.CanBeUnsuppressed(diagnostic);
 
-        protected abstract SyntaxTriviaList CreatePragmaDisableDirectiveTrivia(Diagnostic diagnostic, Func<SyntaxNode, SyntaxNode> formatNode, bool needsLeadingEndOfLine, bool needsTrailingEndOfLine);
-        protected abstract SyntaxTriviaList CreatePragmaRestoreDirectiveTrivia(Diagnostic diagnostic, Func<SyntaxNode, SyntaxNode> formatNode, bool needsLeadingEndOfLine, bool needsTrailingEndOfLine);
+        protected abstract SyntaxTriviaList CreatePragmaDisableDirectiveTrivia(Diagnostic diagnostic, Func<SyntaxNode, CancellationToken, SyntaxNode> formatNode, bool needsLeadingEndOfLine, bool needsTrailingEndOfLine, CancellationToken cancellationToken);
+        protected abstract SyntaxTriviaList CreatePragmaRestoreDirectiveTrivia(Diagnostic diagnostic, Func<SyntaxNode, CancellationToken, SyntaxNode> formatNode, bool needsLeadingEndOfLine, bool needsTrailingEndOfLine, CancellationToken cancellationToken);
 
         protected abstract SyntaxNode AddGlobalSuppressMessageAttribute(
             SyntaxNode newRoot,
             ISymbol targetSymbol,
             INamedTypeSymbol suppressMessageAttribute,
             Diagnostic diagnostic,
-            Workspace workspace,
-            Compilation compilation,
+            HostWorkspaceServices services,
+            SyntaxFormattingOptions options,
             IAddImportsService addImportsService,
             CancellationToken cancellationToken);
 
@@ -199,6 +200,7 @@ private async Task<ImmutableArray<CodeFix>> GetSuppressionsAsync(
                 skipSuppressMessage = suppressMessageAttribute == null || !suppressMessageAttribute.IsAttribute();
             }
 
+            var lazyFormattingOptions = (SyntaxFormattingOptions?)null;
             var result = ArrayBuilder<CodeFix>.GetInstance();
             foreach (var diagnostic in diagnostics)
             {
@@ -208,7 +210,8 @@ private async Task<ImmutableArray<CodeFix>> GetSuppressionsAsync(
                     if (diagnostic.Location.IsInSource && documentOpt != null)
                     {
                         // pragma warning disable.
-                        nestedActions.Add(PragmaWarningCodeAction.Create(suppressionTargetInfo, documentOpt, diagnostic, this));
+                        lazyFormattingOptions ??= await SyntaxFormattingOptions.FromDocumentAsync(documentOpt, cancellationToken).ConfigureAwait(false);
+                        nestedActions.Add(PragmaWarningCodeAction.Create(suppressionTargetInfo, documentOpt, lazyFormattingOptions.Value, diagnostic, this));
                     }
 
                     // SuppressMessageAttribute suppression is not supported for compiler diagnostics.
diff --git a/src/Features/Core/Portable/CodeRefactorings/AddMissingImports/AbstractAddMissingImportsFeatureService.cs b/src/Features/Core/Portable/CodeRefactorings/AddMissingImports/AbstractAddMissingImportsFeatureService.cs
index 55d6bdcacbbb5..eaa49c241a508 100644
--- a/src/Features/Core/Portable/CodeRefactorings/AddMissingImports/AbstractAddMissingImportsFeatureService.cs
+++ b/src/Features/Core/Portable/CodeRefactorings/AddMissingImports/AbstractAddMissingImportsFeatureService.cs
@@ -140,8 +140,7 @@ private static async Task<Document> ApplyFixesAsync(Document document, Immutable
 
         private static async Task<Document> CleanUpNewLinesAsync(Document document, IEnumerable<TextSpan> insertSpans, CancellationToken cancellationToken)
         {
-            var languageFormatter = document.GetRequiredLanguageService<ISyntaxFormattingService>();
-            var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
+            var options = await SyntaxFormattingOptions.FromDocumentAsync(document, cancellationToken).ConfigureAwait(false);
 
             var newDocument = document;
 
@@ -150,21 +149,19 @@ private static async Task<Document> CleanUpNewLinesAsync(Document document, IEnu
             // to separate the import section from the other content.
             foreach (var insertSpan in insertSpans)
             {
-                newDocument = await CleanUpNewLinesAsync(newDocument, insertSpan, languageFormatter, options, cancellationToken).ConfigureAwait(false);
+                newDocument = await CleanUpNewLinesAsync(newDocument, insertSpan, options, cancellationToken).ConfigureAwait(false);
             }
 
             return newDocument;
         }
 
-        private static async Task<Document> CleanUpNewLinesAsync(Document document, TextSpan insertSpan, ISyntaxFormattingService languageFormatter, OptionSet optionSet, CancellationToken cancellationToken)
+        private static async Task<Document> CleanUpNewLinesAsync(Document document, TextSpan insertSpan, SyntaxFormattingOptions options, CancellationToken cancellationToken)
         {
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
-            var optionService = document.Project.Solution.Workspace.Services.GetRequiredService<IOptionService>();
-            var shouldUseFormattingSpanCollapse = optionSet.GetOption(FormattingBehaviorOptions.AllowDisjointSpanMerging);
-            var options = optionSet.AsAnalyzerConfigOptions(optionService, root.Language);
+            var services = document.Project.Solution.Workspace.Services;
 
-            var textChanges = languageFormatter.Format(root, new[] { insertSpan }, shouldUseFormattingSpanCollapse, options, new[] { new CleanUpNewLinesFormatter(text) }, cancellationToken).GetTextChanges(cancellationToken);
+            var textChanges = Formatter.GetFormattedTextChanges(root, new[] { insertSpan }, services, options, rules: new[] { new CleanUpNewLinesFormatter(text) }, cancellationToken);
 
             // If there are no changes then, do less work.
             if (textChanges.Count == 0)
diff --git a/src/Features/Core/Portable/CodeRefactorings/SyncNamespace/AbstractChangeNamespaceService.cs b/src/Features/Core/Portable/CodeRefactorings/SyncNamespace/AbstractChangeNamespaceService.cs
index b2c6802a6bddd..92c99eb637d8c 100644
--- a/src/Features/Core/Portable/CodeRefactorings/SyncNamespace/AbstractChangeNamespaceService.cs
+++ b/src/Features/Core/Portable/CodeRefactorings/SyncNamespace/AbstractChangeNamespaceService.cs
@@ -623,7 +623,9 @@ private async Task<Document> FixDeclarationDocumentAsync(
                 .WithAdditionalAnnotations(Formatter.Annotation);
 
             // Need to invoke formatter explicitly since we are doing the diff merge ourselves.
-            root = Formatter.Format(root, Formatter.Annotation, documentWithAddedImports.Project.Solution.Workspace, optionSet, cancellationToken);
+            var services = documentWithAddedImports.Project.Solution.Workspace.Services;
+            var formattingOptions = SyntaxFormattingOptions.Create(optionSet, services, root.Language);
+            root = Formatter.Format(root, Formatter.Annotation, services, formattingOptions, cancellationToken);
 
             root = root.WithAdditionalAnnotations(Simplifier.Annotation);
             var formattedDocument = documentWithAddedImports.WithSyntaxRoot(root);
diff --git a/src/Features/Core/Portable/ExtractClass/ExtractClassWithDialogCodeAction.cs b/src/Features/Core/Portable/ExtractClass/ExtractClassWithDialogCodeAction.cs
index bc64f943536de..623c9595854f5 100644
--- a/src/Features/Core/Portable/ExtractClass/ExtractClassWithDialogCodeAction.cs
+++ b/src/Features/Core/Portable/ExtractClass/ExtractClassWithDialogCodeAction.cs
@@ -52,7 +52,7 @@ public ExtractClassWithDialogCodeAction(
         public override object? GetOptions(CancellationToken cancellationToken)
         {
             var extractClassService = _service ?? _document.Project.Solution.Workspace.Services.GetRequiredService<IExtractClassOptionsService>();
-            return extractClassService.GetExtractClassOptionsAsync(_document, _selectedType, _selectedMember)
+            return extractClassService.GetExtractClassOptionsAsync(_document, _selectedType, _selectedMember, cancellationToken)
                 .WaitAndGetResult_CanCallOnBackground(cancellationToken);
         }
 
diff --git a/src/Features/Core/Portable/ExtractClass/IExtractClassOptionsService.cs b/src/Features/Core/Portable/ExtractClass/IExtractClassOptionsService.cs
index 32d5a353dcceb..3a8fb90d91357 100644
--- a/src/Features/Core/Portable/ExtractClass/IExtractClassOptionsService.cs
+++ b/src/Features/Core/Portable/ExtractClass/IExtractClassOptionsService.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.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
 
@@ -9,6 +10,6 @@ namespace Microsoft.CodeAnalysis.ExtractClass
 {
     internal interface IExtractClassOptionsService : IWorkspaceService
     {
-        Task<ExtractClassOptions?> GetExtractClassOptionsAsync(Document document, INamedTypeSymbol originalType, ISymbol? selectedMember);
+        Task<ExtractClassOptions?> GetExtractClassOptionsAsync(Document document, INamedTypeSymbol originalType, ISymbol? selectedMember, CancellationToken cancellationToken);
     }
 }
diff --git a/src/Features/Core/Portable/ExtractInterface/AbstractExtractInterfaceService.cs b/src/Features/Core/Portable/ExtractInterface/AbstractExtractInterfaceService.cs
index fbefd43962602..11ca09855708a 100644
--- a/src/Features/Core/Portable/ExtractInterface/AbstractExtractInterfaceService.cs
+++ b/src/Features/Core/Portable/ExtractInterface/AbstractExtractInterfaceService.cs
@@ -250,7 +250,7 @@ private async Task<ExtractInterfaceResult> ExtractInterfaceToSameFileAsync(
                 navigationDocumentId: refactoringResult.DocumentToExtractFrom.Id);
         }
 
-        internal static Task<ExtractInterfaceOptionsResult> GetExtractInterfaceOptionsAsync(
+        internal static async Task<ExtractInterfaceOptionsResult> GetExtractInterfaceOptionsAsync(
             Document document,
             INamedTypeSymbol type,
             IEnumerable<ISymbol> extractableMembers,
@@ -262,10 +262,11 @@ internal static Task<ExtractInterfaceOptionsResult> GetExtractInterfaceOptionsAs
             var defaultInterfaceName = NameGenerator.GenerateUniqueName(candidateInterfaceName, name => !conflictingTypeNames.Contains(name));
             var syntaxFactsService = document.GetLanguageService<ISyntaxFactsService>();
             var notificationService = document.Project.Solution.Workspace.Services.GetService<INotificationService>();
-            var generatedNameTypeParameterSuffix = ExtractTypeHelpers.GetTypeParameterSuffix(document, type, extractableMembers);
+            var formattingOptions = await SyntaxFormattingOptions.FromDocumentAsync(document, cancellationToken).ConfigureAwait(false);
+            var generatedNameTypeParameterSuffix = ExtractTypeHelpers.GetTypeParameterSuffix(document, formattingOptions, type, extractableMembers, cancellationToken);
 
             var service = document.Project.Solution.Workspace.Services.GetService<IExtractInterfaceOptionsService>();
-            return service.GetExtractInterfaceOptionsAsync(
+            return await service.GetExtractInterfaceOptionsAsync(
                 syntaxFactsService,
                 notificationService,
                 extractableMembers.ToList(),
@@ -273,7 +274,8 @@ internal static Task<ExtractInterfaceOptionsResult> GetExtractInterfaceOptionsAs
                 conflictingTypeNames.ToList(),
                 containingNamespace,
                 generatedNameTypeParameterSuffix,
-                document.Project.Language);
+                document.Project.Language,
+                cancellationToken).ConfigureAwait(false);
         }
 
         private static async Task<Solution> GetFormattedSolutionAsync(Solution unformattedSolution, IEnumerable<DocumentId> documentIds, CancellationToken cancellationToken)
diff --git a/src/Features/Core/Portable/ExtractInterface/IExtractInterfaceOptionsService.cs b/src/Features/Core/Portable/ExtractInterface/IExtractInterfaceOptionsService.cs
index 4bf9ed0dd0eb8..025edd6135834 100644
--- a/src/Features/Core/Portable/ExtractInterface/IExtractInterfaceOptionsService.cs
+++ b/src/Features/Core/Portable/ExtractInterface/IExtractInterfaceOptionsService.cs
@@ -5,6 +5,7 @@
 #nullable disable
 
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.LanguageServices;
@@ -22,6 +23,7 @@ Task<ExtractInterfaceOptionsResult> GetExtractInterfaceOptionsAsync(
             List<string> conflictingTypeNames,
             string defaultNamespace,
             string generatedNameTypeParameterSuffix,
-            string languageName);
+            string languageName,
+            CancellationToken cancellationToken);
     }
 }
diff --git a/src/Features/Core/Portable/ExtractMethod/ExtractMethodResult.cs b/src/Features/Core/Portable/ExtractMethod/ExtractMethodResult.cs
index a4344dbd5a215..b47327e345306 100644
--- a/src/Features/Core/Portable/ExtractMethod/ExtractMethodResult.cs
+++ b/src/Features/Core/Portable/ExtractMethod/ExtractMethodResult.cs
@@ -94,8 +94,12 @@ internal ExtractMethodResult(
             var simplifiedDocument = await Simplifier.ReduceAsync(annotatedDocument, Simplifier.Annotation, optionSet: null, cancellationToken).ConfigureAwait(false);
             var simplifiedRoot = await simplifiedDocument.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
-            var documentOptions = await DocumentWithoutFinalFormatting.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
-            var formattedDocument = simplifiedDocument.WithSyntaxRoot(Formatter.Format(simplifiedRoot, Formatter.Annotation, DocumentWithoutFinalFormatting.Project.Solution.Workspace, documentOptions, FormattingRules, cancellationToken));
+            var options = await SyntaxFormattingOptions.FromDocumentAsync(DocumentWithoutFinalFormatting, cancellationToken).ConfigureAwait(false);
+            var services = DocumentWithoutFinalFormatting.Project.Solution.Workspace.Services;
+
+            var formattedDocument = simplifiedDocument.WithSyntaxRoot(
+                Formatter.Format(simplifiedRoot, Formatter.Annotation, services, options, FormattingRules, cancellationToken));
+
             var formattedRoot = await formattedDocument.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             return (formattedDocument, formattedRoot.GetAnnotatedTokens(annotation).Single());
         }
diff --git a/src/Features/Core/Portable/Formatting/FormattingCodeFixProvider.cs b/src/Features/Core/Portable/Formatting/FormattingCodeFixProvider.cs
index 961e87a83bdb5..ba339b3690055 100644
--- a/src/Features/Core/Portable/Formatting/FormattingCodeFixProvider.cs
+++ b/src/Features/Core/Portable/Formatting/FormattingCodeFixProvider.cs
@@ -46,9 +46,9 @@ public override Task RegisterCodeFixesAsync(CodeFixContext context)
 
         private static async Task<Document> FixOneAsync(CodeFixContext context, Diagnostic diagnostic, CancellationToken cancellationToken)
         {
-            var options = await context.Document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
+            var options = await SyntaxFormattingOptions.FromDocumentAsync(context.Document, cancellationToken).ConfigureAwait(false);
             var tree = await context.Document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
-            var formattedTree = await FormattingCodeFixHelper.FixOneAsync(tree, context.Document.Project.Solution.Workspace, options, diagnostic, cancellationToken).ConfigureAwait(false);
+            var formattedTree = await FormattingCodeFixHelper.FixOneAsync(tree, context.Document.Project.Solution.Workspace.Services, options, diagnostic, cancellationToken).ConfigureAwait(false);
             return context.Document.WithSyntaxRoot(await formattedTree.GetRootAsync(cancellationToken).ConfigureAwait(false));
         }
 
diff --git a/src/Features/Core/Portable/Formatting/FormattingDiagnosticAnalyzer.cs b/src/Features/Core/Portable/Formatting/FormattingDiagnosticAnalyzer.cs
index ab0ee07a389fb..61acf0f0ccee5 100644
--- a/src/Features/Core/Portable/Formatting/FormattingDiagnosticAnalyzer.cs
+++ b/src/Features/Core/Portable/Formatting/FormattingDiagnosticAnalyzer.cs
@@ -38,10 +38,10 @@ private void AnalyzeSyntaxTree(SyntaxTreeAnalysisContext context)
 
             var tree = context.Tree;
             var cancellationToken = context.CancellationToken;
+            var optionSet = context.Options.GetAnalyzerOptionSet(tree, cancellationToken);
+            var options = SyntaxFormattingOptions.Create(optionSet, workspaceAnalyzerOptions.Services, tree.Options.Language);
 
-            var options = context.Options.GetAnalyzerOptionSet(tree, cancellationToken);
-            var workspace = workspaceAnalyzerOptions.Services.Workspace;
-            FormattingAnalyzerHelper.AnalyzeSyntaxTree(context, workspace, Descriptor, options);
+            FormattingAnalyzerHelper.AnalyzeSyntaxTree(context, workspaceAnalyzerOptions.Services, Descriptor, options);
         }
     }
 }
diff --git a/src/Features/Core/Portable/MetadataAsSource/AbstractMetadataAsSourceService.cs b/src/Features/Core/Portable/MetadataAsSource/AbstractMetadataAsSourceService.cs
index 3886be3109624..3854307a217fc 100644
--- a/src/Features/Core/Portable/MetadataAsSource/AbstractMetadataAsSourceService.cs
+++ b/src/Features/Core/Portable/MetadataAsSource/AbstractMetadataAsSourceService.cs
@@ -56,8 +56,14 @@ public async Task<Document> AddSourceToAsync(Document document, Compilation symb
 
             var docWithAssemblyInfo = await AddAssemblyInfoRegionAsync(docWithDocComments, symbolCompilation, symbol.GetOriginalUnreducedDefinition(), cancellationToken).ConfigureAwait(false);
             var node = await docWithAssemblyInfo.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var options = await SyntaxFormattingOptions.FromDocumentAsync(docWithAssemblyInfo, cancellationToken).ConfigureAwait(false);
+
             var formattedDoc = await Formatter.FormatAsync(
-                docWithAssemblyInfo, SpecializedCollections.SingletonEnumerable(node.FullSpan), options: null, rules: GetFormattingRules(docWithAssemblyInfo), cancellationToken: cancellationToken).ConfigureAwait(false);
+                docWithAssemblyInfo,
+                SpecializedCollections.SingletonEnumerable(node.FullSpan),
+                options,
+                GetFormattingRules(docWithAssemblyInfo),
+                cancellationToken).ConfigureAwait(false);
 
             var reducers = GetReducers();
             return await Simplifier.ReduceAsync(formattedDoc, reducers, null, cancellationToken).ConfigureAwait(false);
diff --git a/src/Features/Core/Portable/Shared/Utilities/ExtractTypeHelpers.cs b/src/Features/Core/Portable/Shared/Utilities/ExtractTypeHelpers.cs
index f61368657e11f..c075b5a90e15c 100644
--- a/src/Features/Core/Portable/Shared/Utilities/ExtractTypeHelpers.cs
+++ b/src/Features/Core/Portable/Shared/Utilities/ExtractTypeHelpers.cs
@@ -109,7 +109,7 @@ internal static class ExtractTypeHelpers
             return (formattedDocument, typeAnnotation);
         }
 
-        public static string GetTypeParameterSuffix(Document document, INamedTypeSymbol type, IEnumerable<ISymbol> extractableMembers)
+        public static string GetTypeParameterSuffix(Document document, SyntaxFormattingOptions options, INamedTypeSymbol type, IEnumerable<ISymbol> extractableMembers, CancellationToken cancellationToken)
         {
             var typeParameters = GetRequiredTypeParametersForMembers(type, extractableMembers);
 
@@ -121,7 +121,7 @@ public static string GetTypeParameterSuffix(Document document, INamedTypeSymbol
             var typeParameterNames = typeParameters.SelectAsArray(p => p.Name);
             var syntaxGenerator = SyntaxGenerator.GetGenerator(document);
 
-            return Formatter.Format(syntaxGenerator.SyntaxGeneratorInternal.TypeParameterList(typeParameterNames), document.Project.Solution.Workspace).ToString();
+            return Formatter.Format(syntaxGenerator.SyntaxGeneratorInternal.TypeParameterList(typeParameterNames), document.Project.Solution.Workspace.Services, options, cancellationToken).ToString();
         }
 
         public static ImmutableArray<ITypeParameterSymbol> GetRequiredTypeParametersForMembers(INamedTypeSymbol type, IEnumerable<ISymbol> includedMembers)
diff --git a/src/Features/Core/Portable/UseAutoProperty/AbstractUseAutoPropertyCodeFixProvider.cs b/src/Features/Core/Portable/UseAutoProperty/AbstractUseAutoPropertyCodeFixProvider.cs
index 795ebf87b57bf..1da942098fcb3 100644
--- a/src/Features/Core/Portable/UseAutoProperty/AbstractUseAutoPropertyCodeFixProvider.cs
+++ b/src/Features/Core/Portable/UseAutoProperty/AbstractUseAutoPropertyCodeFixProvider.cs
@@ -280,8 +280,8 @@ private async Task<SyntaxNode> FormatAsync(SyntaxNode newRoot, Document document
                 return newRoot;
             }
 
-            var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
-            return Formatter.Format(newRoot, SpecializedFormattingAnnotation, document.Project.Solution.Workspace, options, formattingRules, cancellationToken);
+            var options = await SyntaxFormattingOptions.FromDocumentAsync(document, cancellationToken).ConfigureAwait(false);
+            return Formatter.Format(newRoot, SpecializedFormattingAnnotation, document.Project.Solution.Workspace.Services, options, formattingRules, cancellationToken);
         }
 
         private static bool IsWrittenToOutsideOfConstructorOrProperty(
diff --git a/src/Features/VisualBasic/Portable/CodeFixes/OverloadBase/OverloadBaseCodeFixProvider.AddKeywordAction.vb b/src/Features/VisualBasic/Portable/CodeFixes/OverloadBase/OverloadBaseCodeFixProvider.AddKeywordAction.vb
index f8dfca13b6c34..778a7bbe68d2e 100644
--- a/src/Features/VisualBasic/Portable/CodeFixes/OverloadBase/OverloadBaseCodeFixProvider.AddKeywordAction.vb
+++ b/src/Features/VisualBasic/Portable/CodeFixes/OverloadBase/OverloadBaseCodeFixProvider.AddKeywordAction.vb
@@ -8,6 +8,7 @@ Imports Microsoft.CodeAnalysis.CodeActions
 Imports Microsoft.CodeAnalysis.CodeCleanup
 Imports Microsoft.CodeAnalysis.Editing
 Imports Microsoft.CodeAnalysis.Formatting
+Imports Microsoft.CodeAnalysis.Options
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.OverloadBase
@@ -41,14 +42,15 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.OverloadBase
 
             Protected Overrides Async Function GetChangedDocumentAsync(cancellationToken As CancellationToken) As Task(Of Document)
                 Dim root = Await _document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(False)
+                Dim options = Await SyntaxFormattingOptions.FromDocumentAsync(_document, cancellationToken).ConfigureAwait(False)
 
-                Dim newNode = Await GetNewNodeAsync(_document, _node, cancellationToken).ConfigureAwait(False)
+                Dim newNode = Await GetNewNodeAsync(_document, _node, options, cancellationToken).ConfigureAwait(False)
                 Dim newRoot = root.ReplaceNode(_node, newNode)
 
                 Return _document.WithSyntaxRoot(newRoot)
             End Function
 
-            Private Async Function GetNewNodeAsync(document As Document, node As SyntaxNode, cancellationToken As CancellationToken) As Task(Of SyntaxNode)
+            Private Async Function GetNewNodeAsync(document As Document, node As SyntaxNode, options As SyntaxFormattingOptions, cancellationToken As CancellationToken) As Task(Of SyntaxNode)
                 Dim newNode As SyntaxNode = Nothing
                 Dim trivia As SyntaxTriviaList = node.GetLeadingTrivia()
                 node = node.WithoutLeadingTrivia()
@@ -70,7 +72,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.OverloadBase
                 Dim cleanupService = document.GetLanguageService(Of ICodeCleanerService)
 
                 If cleanupService IsNot Nothing AndAlso newNode IsNot Nothing Then
-                    newNode = Await cleanupService.CleanupAsync(newNode, ImmutableArray.Create(newNode.Span), document.Project.Solution.Workspace, cleanupService.GetDefaultProviders(), cancellationToken).ConfigureAwait(False)
+                    Dim services = document.Project.Solution.Workspace.Services
+                    newNode = Await cleanupService.CleanupAsync(newNode, ImmutableArray.Create(newNode.Span), options, services, cleanupService.GetDefaultProviders(), cancellationToken).ConfigureAwait(False)
                 End If
 
                 Return newNode.WithAdditionalAnnotations(Formatter.Annotation)
diff --git a/src/Features/VisualBasic/Portable/CodeFixes/Suppression/VisualBasicSuppressionCodeFixProvider.vb b/src/Features/VisualBasic/Portable/CodeFixes/Suppression/VisualBasicSuppressionCodeFixProvider.vb
index ee3efba7ebf94..8e03fe3750f60 100644
--- a/src/Features/VisualBasic/Portable/CodeFixes/Suppression/VisualBasicSuppressionCodeFixProvider.vb
+++ b/src/Features/VisualBasic/Portable/CodeFixes/Suppression/VisualBasicSuppressionCodeFixProvider.vb
@@ -10,6 +10,7 @@ Imports Microsoft.CodeAnalysis.AddImports
 Imports Microsoft.CodeAnalysis.CodeFixes
 Imports Microsoft.CodeAnalysis.CodeFixes.Suppression
 Imports Microsoft.CodeAnalysis.Formatting
+Imports Microsoft.CodeAnalysis.Host
 Imports Microsoft.CodeAnalysis.Simplification
 Imports Microsoft.CodeAnalysis.Text
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
@@ -24,18 +25,18 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.Suppression
         Public Sub New()
         End Sub
 
-        Protected Overrides Function CreatePragmaRestoreDirectiveTrivia(diagnostic As Diagnostic, formatNode As Func(Of SyntaxNode, SyntaxNode), needsLeadingEndOfLine As Boolean, needsTrailingEndOfLine As Boolean) As SyntaxTriviaList
+        Protected Overrides Function CreatePragmaRestoreDirectiveTrivia(diagnostic As Diagnostic, formatNode As Func(Of SyntaxNode, CancellationToken, SyntaxNode), needsLeadingEndOfLine As Boolean, needsTrailingEndOfLine As Boolean, cancellationToken As CancellationToken) As SyntaxTriviaList
             Dim includeTitle As Boolean
             Dim errorCodes = GetErrorCodes(diagnostic, includeTitle)
             Dim pragmaDirective = SyntaxFactory.EnableWarningDirectiveTrivia(errorCodes)
-            Return CreatePragmaDirectiveTrivia(pragmaDirective, includeTitle, diagnostic, formatNode, needsLeadingEndOfLine, needsTrailingEndOfLine)
+            Return CreatePragmaDirectiveTrivia(pragmaDirective, includeTitle, diagnostic, formatNode, needsLeadingEndOfLine, needsTrailingEndOfLine, cancellationToken)
         End Function
 
-        Protected Overrides Function CreatePragmaDisableDirectiveTrivia(diagnostic As Diagnostic, formatNode As Func(Of SyntaxNode, SyntaxNode), needsLeadingEndOfLine As Boolean, needsTrailingEndOfLine As Boolean) As SyntaxTriviaList
+        Protected Overrides Function CreatePragmaDisableDirectiveTrivia(diagnostic As Diagnostic, formatNode As Func(Of SyntaxNode, CancellationToken, SyntaxNode), needsLeadingEndOfLine As Boolean, needsTrailingEndOfLine As Boolean, cancellationToken As CancellationToken) As SyntaxTriviaList
             Dim includeTitle As Boolean
             Dim errorCodes = GetErrorCodes(diagnostic, includeTitle)
             Dim pragmaDirective = SyntaxFactory.DisableWarningDirectiveTrivia(errorCodes)
-            Return CreatePragmaDirectiveTrivia(pragmaDirective, includeTitle, diagnostic, formatNode, needsLeadingEndOfLine, needsTrailingEndOfLine)
+            Return CreatePragmaDirectiveTrivia(pragmaDirective, includeTitle, diagnostic, formatNode, needsLeadingEndOfLine, needsTrailingEndOfLine, cancellationToken)
         End Function
 
         Private Shared Function GetErrorCodes(diagnostic As Diagnostic, ByRef includeTitle As Boolean) As SeparatedSyntaxList(Of IdentifierNameSyntax)
@@ -47,8 +48,16 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.Suppression
             Return New SeparatedSyntaxList(Of IdentifierNameSyntax)().Add(SyntaxFactory.IdentifierName(text))
         End Function
 
-        Private Shared Function CreatePragmaDirectiveTrivia(enableOrDisablePragmaDirective As StructuredTriviaSyntax, includeTitle As Boolean, diagnostic As Diagnostic, formatNode As Func(Of SyntaxNode, SyntaxNode), needsLeadingEndOfLine As Boolean, needsTrailingEndOfLine As Boolean) As SyntaxTriviaList
-            enableOrDisablePragmaDirective = CType(formatNode(enableOrDisablePragmaDirective), StructuredTriviaSyntax)
+        Private Shared Function CreatePragmaDirectiveTrivia(
+                enableOrDisablePragmaDirective As StructuredTriviaSyntax,
+                includeTitle As Boolean,
+                diagnostic As Diagnostic,
+                formatNode As Func(Of SyntaxNode, CancellationToken, SyntaxNode),
+                needsLeadingEndOfLine As Boolean,
+                needsTrailingEndOfLine As Boolean,
+                cancellationToken As CancellationToken) As SyntaxTriviaList
+
+            enableOrDisablePragmaDirective = CType(formatNode(enableOrDisablePragmaDirective, cancellationToken), StructuredTriviaSyntax)
             Dim pragmaDirectiveTrivia = SyntaxFactory.Trivia(enableOrDisablePragmaDirective)
             Dim endOfLineTrivia = SyntaxFactory.ElasticCarriageReturnLineFeed
             Dim triviaList = SyntaxFactory.TriviaList(pragmaDirectiveTrivia)
@@ -109,8 +118,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.Suppression
                 targetSymbol As ISymbol,
                 suppressMessageAttribute As INamedTypeSymbol,
                 diagnostic As Diagnostic,
-                workspace As Workspace,
-                compilation As Compilation,
+                services As HostWorkspaceServices,
+                options As SyntaxFormattingOptions,
                 addImportsService As IAddImportsService,
                 cancellationToken As CancellationToken) As SyntaxNode
             Dim compilationRoot = DirectCast(newRoot, CompilationUnitSyntax)
@@ -129,7 +138,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.Suppression
                 End If
             End If
 
-            attributeStatement = CType(Formatter.Format(attributeStatement, workspace, cancellationToken:=cancellationToken), AttributesStatementSyntax)
+            attributeStatement = CType(Formatter.Format(attributeStatement, services, options, cancellationToken), AttributesStatementSyntax)
 
             Dim leadingTrivia = If(isFirst AndAlso Not compilationRoot.HasLeadingTrivia,
                 SyntaxFactory.TriviaList(SyntaxFactory.CommentTrivia(GlobalSuppressionsFileHeaderComment)),
@@ -252,7 +261,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.Suppression
                     Return SyntaxFactory.Trivia(newPragmaWarning)
 
                 Case Else
-                    throw ExceptionUtilities.UnexpectedValue(trivia.Kind())
+                    Throw ExceptionUtilities.UnexpectedValue(trivia.Kind())
             End Select
         End Function
     End Class
diff --git a/src/Tools/ExternalAccess/OmniSharp/Internal/ExtractClass/OmniSharpExtractClassOptionsService.cs b/src/Tools/ExternalAccess/OmniSharp/Internal/ExtractClass/OmniSharpExtractClassOptionsService.cs
index a60eda3cfa1d3..6d4abad23938a 100644
--- a/src/Tools/ExternalAccess/OmniSharp/Internal/ExtractClass/OmniSharpExtractClassOptionsService.cs
+++ b/src/Tools/ExternalAccess/OmniSharp/Internal/ExtractClass/OmniSharpExtractClassOptionsService.cs
@@ -4,6 +4,7 @@
 
 using System;
 using System.Composition;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.ExternalAccess.OmniSharp.ExtractClass;
 using Microsoft.CodeAnalysis.ExtractClass;
@@ -24,7 +25,7 @@ public OmniSharpExtractClassOptionsService(IOmniSharpExtractClassOptionsService
             _omniSharpExtractClassOptionsService = omniSharpExtractClassOptionsService;
         }
 
-        public async Task<ExtractClassOptions?> GetExtractClassOptionsAsync(Document document, INamedTypeSymbol originalType, ISymbol? selectedMember)
+        public async Task<ExtractClassOptions?> GetExtractClassOptionsAsync(Document document, INamedTypeSymbol originalType, ISymbol? selectedMember, CancellationToken cancellationToken)
         {
             var result = await _omniSharpExtractClassOptionsService.GetExtractClassOptionsAsync(document, originalType, selectedMember).ConfigureAwait(false);
             return result == null
diff --git a/src/Tools/ExternalAccess/OmniSharp/Internal/ExtractInterface/OmniSharpExtractInterfaceOptionsService.cs b/src/Tools/ExternalAccess/OmniSharp/Internal/ExtractInterface/OmniSharpExtractInterfaceOptionsService.cs
index ffcb263fbf3d4..08a2264ccfe8c 100644
--- a/src/Tools/ExternalAccess/OmniSharp/Internal/ExtractInterface/OmniSharpExtractInterfaceOptionsService.cs
+++ b/src/Tools/ExternalAccess/OmniSharp/Internal/ExtractInterface/OmniSharpExtractInterfaceOptionsService.cs
@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using System.Composition;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.ExternalAccess.OmniSharp.ExtractInterface;
 using Microsoft.CodeAnalysis.ExtractInterface;
@@ -28,7 +29,16 @@ public OmniSharpExtractInterfaceOptionsService(IOmniSharpExtractInterfaceOptions
             _omniSharpExtractInterfaceOptionsService = omniSharpExtractInterfaceOptionsService;
         }
 
-        public async Task<ExtractInterfaceOptionsResult> GetExtractInterfaceOptionsAsync(ISyntaxFactsService syntaxFactsService, INotificationService notificationService, List<ISymbol> extractableMembers, string defaultInterfaceName, List<string> conflictingTypeNames, string defaultNamespace, string generatedNameTypeParameterSuffix, string languageName)
+        public async Task<ExtractInterfaceOptionsResult> GetExtractInterfaceOptionsAsync(
+            ISyntaxFactsService syntaxFactsService,
+            INotificationService notificationService,
+            List<ISymbol> extractableMembers,
+            string defaultInterfaceName,
+            List<string> conflictingTypeNames,
+            string defaultNamespace,
+            string generatedNameTypeParameterSuffix,
+            string languageName,
+            CancellationToken cancellationToken)
         {
             var result = await _omniSharpExtractInterfaceOptionsService.GetExtractInterfaceOptionsAsync(extractableMembers, defaultInterfaceName).ConfigureAwait(false);
             return new(
diff --git a/src/Tools/IdeBenchmarks/FormatterBenchmarks.cs b/src/Tools/IdeBenchmarks/FormatterBenchmarks.cs
index 2c3dc828bdee3..801a4d2ad8ea4 100644
--- a/src/Tools/IdeBenchmarks/FormatterBenchmarks.cs
+++ b/src/Tools/IdeBenchmarks/FormatterBenchmarks.cs
@@ -43,7 +43,9 @@ public object FormatCSharp()
 
             using var workspace = TestWorkspace.CreateCSharp(text);
             var document = workspace.CurrentSolution.GetDocument(workspace.Documents.First().Id);
-            return Formatter.GetFormattedTextChanges(document.GetSyntaxRootSynchronously(CancellationToken.None), workspace);
+            var root = document.GetSyntaxRootSynchronously(CancellationToken.None);
+            var options = SyntaxFormattingOptions.Default;
+            return Formatter.GetFormattedTextChanges(root, workspace.Services, options, CancellationToken.None);
         }
 
         [Benchmark]
@@ -54,7 +56,9 @@ public object FormatVisualBasic()
 
             using var workspace = TestWorkspace.CreateVisualBasic(text);
             var document = workspace.CurrentSolution.GetDocument(workspace.Documents.First().Id);
-            return Formatter.GetFormattedTextChanges(document.GetSyntaxRootSynchronously(CancellationToken.None), workspace);
+            var root = document.GetSyntaxRootSynchronously(CancellationToken.None);
+            var options = SyntaxFormattingOptions.Default;
+            return Formatter.GetFormattedTextChanges(root, workspace.Services, options, CancellationToken.None);
         }
     }
 }
diff --git a/src/VisualStudio/Core/Def/Implementation/AbstractEditorFactory.cs b/src/VisualStudio/Core/Def/Implementation/AbstractEditorFactory.cs
index 5d50180cff8ce..6efb4b55f0fba 100644
--- a/src/VisualStudio/Core/Def/Implementation/AbstractEditorFactory.cs
+++ b/src/VisualStudio/Core/Def/Implementation/AbstractEditorFactory.cs
@@ -328,15 +328,15 @@ private async Task FormatDocumentCreatedFromTemplateAsync(IVsHierarchy hierarchy
             }
 
             var rootToFormat = await addedDocument.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(true);
-            var documentOptions = await addedDocument.GetOptionsAsync(cancellationToken).ConfigureAwait(true);
+            var formattingOptions = await SyntaxFormattingOptions.FromDocumentAsync(addedDocument, cancellationToken).ConfigureAwait(true);
 
             // Format document
             var unformattedText = await addedDocument.GetTextAsync(cancellationToken).ConfigureAwait(true);
-            var formattedRoot = Formatter.Format(rootToFormat, workspace, documentOptions, cancellationToken);
+            var formattedRoot = Formatter.Format(rootToFormat, workspace.Services, formattingOptions, cancellationToken);
             var formattedText = formattedRoot.GetText(unformattedText.Encoding, unformattedText.ChecksumAlgorithm);
 
             // Ensure the line endings are normalized. The formatter doesn't touch everything if it doesn't need to.
-            var targetLineEnding = documentOptions.GetOption(FormattingOptions.NewLine)!;
+            var targetLineEnding = formattingOptions.Options.GetOption(FormattingOptions.NewLine)!;
 
             var originalText = formattedText;
             foreach (var originalLine in originalText.Lines)
diff --git a/src/VisualStudio/Core/Def/Implementation/ExtractClass/VisualStudioExtractClassOptionsService.cs b/src/VisualStudio/Core/Def/Implementation/ExtractClass/VisualStudioExtractClassOptionsService.cs
index 47956b2589d6f..8d338faf29c32 100644
--- a/src/VisualStudio/Core/Def/Implementation/ExtractClass/VisualStudioExtractClassOptionsService.cs
+++ b/src/VisualStudio/Core/Def/Implementation/ExtractClass/VisualStudioExtractClassOptionsService.cs
@@ -11,6 +11,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.ExtractClass;
+using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.Notification;
@@ -44,7 +45,7 @@ public VisualStudioExtractClassOptionsService(
             _uiThreadOperationExecutor = uiThreadOperationExecutor;
         }
 
-        public async Task<ExtractClassOptions?> GetExtractClassOptionsAsync(Document document, INamedTypeSymbol selectedType, ISymbol? selectedMember)
+        public async Task<ExtractClassOptions?> GetExtractClassOptionsAsync(Document document, INamedTypeSymbol selectedType, ISymbol? selectedMember, CancellationToken cancellationToken)
         {
             var notificationService = document.Project.Solution.Workspace.Services.GetRequiredService<INotificationService>();
 
@@ -62,10 +63,9 @@ public VisualStudioExtractClassOptionsService(
                         IsCheckable = true
                     });
 
-            using var cancellationTokenSource = new CancellationTokenSource();
-            var memberToDependentsMap = SymbolDependentsBuilder.FindMemberToDependentsMap(membersInType, document.Project, cancellationTokenSource.Token);
+            var memberToDependentsMap = SymbolDependentsBuilder.FindMemberToDependentsMap(membersInType, document.Project, cancellationToken);
 
-            var conflictingTypeNames = selectedType.ContainingNamespace.GetAllTypes(cancellationTokenSource.Token).Select(t => t.Name);
+            var conflictingTypeNames = selectedType.ContainingNamespace.GetAllTypes(cancellationToken).Select(t => t.Name);
             var candidateName = selectedType.Name + "Base";
             var defaultTypeName = NameGenerator.GenerateUniqueName(candidateName, name => !conflictingTypeNames.Contains(name));
 
@@ -73,7 +73,8 @@ public VisualStudioExtractClassOptionsService(
                 ? string.Empty
                 : selectedType.ContainingNamespace.ToDisplayString();
 
-            var generatedNameTypeParameterSuffix = ExtractTypeHelpers.GetTypeParameterSuffix(document, selectedType, membersInType);
+            var formattingOptions = await SyntaxFormattingOptions.FromDocumentAsync(document, cancellationToken).ConfigureAwait(false);
+            var generatedNameTypeParameterSuffix = ExtractTypeHelpers.GetTypeParameterSuffix(document, formattingOptions, selectedType, membersInType, cancellationToken);
 
             var viewModel = new ExtractClassViewModel(
                 _uiThreadOperationExecutor,
@@ -87,7 +88,7 @@ public VisualStudioExtractClassOptionsService(
                 conflictingTypeNames.ToImmutableArray(),
                 document.GetRequiredLanguageService<ISyntaxFactsService>());
 
-            await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync();
+            await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
             var dialog = new ExtractClassDialog(viewModel);
 
             var result = dialog.ShowModal();
diff --git a/src/VisualStudio/Core/Def/Implementation/ExtractInterface/VisualStudioExtractInterfaceOptionsService.cs b/src/VisualStudio/Core/Def/Implementation/ExtractInterface/VisualStudioExtractInterfaceOptionsService.cs
index 888947e05c4b5..91ac13f70a516 100644
--- a/src/VisualStudio/Core/Def/Implementation/ExtractInterface/VisualStudioExtractInterfaceOptionsService.cs
+++ b/src/VisualStudio/Core/Def/Implementation/ExtractInterface/VisualStudioExtractInterfaceOptionsService.cs
@@ -8,6 +8,7 @@
 using System.Collections.Generic;
 using System.Composition;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
@@ -43,9 +44,10 @@ public async Task<ExtractInterfaceOptionsResult> GetExtractInterfaceOptionsAsync
             List<string> allTypeNames,
             string defaultNamespace,
             string generatedNameTypeParameterSuffix,
-            string languageName)
+            string languageName,
+            CancellationToken cancellationToken)
         {
-            await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync();
+            await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
 
             var viewModel = new ExtractInterfaceDialogViewModel(
                 syntaxFactsService,
diff --git a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractLanguageService`2.IVsLanguageTextOps.cs b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractLanguageService`2.IVsLanguageTextOps.cs
index 62b22fb67ba6b..605558b60c14c 100644
--- a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractLanguageService`2.IVsLanguageTextOps.cs
+++ b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractLanguageService`2.IVsLanguageTextOps.cs
@@ -54,7 +54,7 @@ private int FormatWorker(IVsTextLayer textLayer, TextSpan[] selections, Cancella
 
             var root = document.GetSyntaxRootSynchronously(cancellationToken);
             var text = root.SyntaxTree.GetText(cancellationToken);
-            var options = document.GetOptionsAsync(cancellationToken).WaitAndGetResult(cancellationToken);
+            var options = SyntaxFormattingOptions.FromDocumentAsync(document, cancellationToken).WaitAndGetResult(cancellationToken);
 
             var ts = selections.Single();
             var start = text.Lines[ts.iStartLine].Start + ts.iStartIndex;
@@ -63,11 +63,13 @@ private int FormatWorker(IVsTextLayer textLayer, TextSpan[] selections, Cancella
 
             // Since we know we are on the UI thread, lets get the base indentation now, so that there is less
             // cleanup work to do later in Venus.
-            var ruleFactory = this.Workspace.Services.GetService<IHostDependentFormattingRuleFactoryService>();
+            var ruleFactory = Workspace.Services.GetService<IHostDependentFormattingRuleFactoryService>();
             var rules = ruleFactory.CreateRule(document, start).Concat(Formatter.GetDefaultFormattingRules(document));
 
             // use formatting that return text changes rather than tree rewrite which is more expensive
-            var originalChanges = Formatter.GetFormattedTextChanges(root, SpecializedCollections.SingletonEnumerable(adjustedSpan), document.Project.Solution.Workspace, options, rules, cancellationToken);
+            var formatter = document.GetRequiredLanguageService<ISyntaxFormattingService>();
+            var originalChanges = formatter.GetFormattingResult(root, SpecializedCollections.SingletonEnumerable(adjustedSpan), options, rules, cancellationToken)
+                .GetTextChanges(cancellationToken);
 
             var originalSpan = RoslynTextSpan.FromBounds(start, end);
             var formattedChanges = ruleFactory.FilterFormattedChanges(document, originalSpan, originalChanges);
@@ -78,7 +80,7 @@ private int FormatWorker(IVsTextLayer textLayer, TextSpan[] selections, Cancella
 
             // create new formatted document
             var formattedDocument = document.WithText(text.WithChanges(formattedChanges));
-            formattedDocument.Project.Solution.Workspace.ApplyDocumentChanges(formattedDocument, cancellationToken);
+            Workspace.ApplyDocumentChanges(formattedDocument, cancellationToken);
 
             return VSConstants.S_OK;
         }
diff --git a/src/VisualStudio/Core/Def/Implementation/Venus/ContainedDocument.cs b/src/VisualStudio/Core/Def/Implementation/Venus/ContainedDocument.cs
index d363c7ba77381..8caf624088bc9 100644
--- a/src/VisualStudio/Core/Def/Implementation/Venus/ContainedDocument.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Venus/ContainedDocument.cs
@@ -760,11 +760,14 @@ private void AdjustIndentation(IProjectionBuffer subjectBuffer, IEnumerable<int>
 
             var editorOptionsFactory = _componentModel.GetService<IEditorOptionsFactoryService>();
             var editorOptions = editorOptionsFactory.GetOptions(DataBuffer);
-            var options = _workspace.Options
-                                        .WithChangedOption(FormattingOptions.NewLine, root.Language, editorOptions.GetNewLineCharacter())
-                                        .WithChangedOption(FormattingOptions.UseTabs, root.Language, !editorOptions.IsConvertTabsToSpacesEnabled())
-                                        .WithChangedOption(FormattingOptions.TabSize, root.Language, editorOptions.GetTabSize())
-                                        .WithChangedOption(FormattingOptions.IndentationSize, root.Language, editorOptions.GetIndentSize());
+            var options = SyntaxFormattingOptions.Create(
+                _workspace.Options
+                    .WithChangedOption(FormattingOptions.NewLine, root.Language, editorOptions.GetNewLineCharacter())
+                    .WithChangedOption(FormattingOptions.UseTabs, root.Language, !editorOptions.IsConvertTabsToSpacesEnabled())
+                    .WithChangedOption(FormattingOptions.TabSize, root.Language, editorOptions.GetTabSize())
+                    .WithChangedOption(FormattingOptions.IndentationSize, root.Language, editorOptions.GetIndentSize()),
+                _workspace.Services,
+                document.Project.Language);
 
             using var pooledObject = SharedPools.Default<List<TextSpan>>().GetPooledObject();
 
@@ -785,7 +788,7 @@ private void AdjustIndentation(IProjectionBuffer subjectBuffer, IEnumerable<int>
         }
 
         private void AdjustIndentationForSpan(
-            Document document, ITextEdit edit, TextSpan visibleSpan, AbstractFormattingRule baseIndentationRule, OptionSet options)
+            Document document, ITextEdit edit, TextSpan visibleSpan, AbstractFormattingRule baseIndentationRule, SyntaxFormattingOptions options)
         {
             var root = document.GetSyntaxRootSynchronously(CancellationToken.None);
 
@@ -800,10 +803,11 @@ private void AdjustIndentationForSpan(
 
             var formattingRules = venusFormattingRules.Concat(Formatter.GetDefaultFormattingRules(document));
 
-            var workspace = document.Project.Solution.Workspace;
-            var changes = Formatter.GetFormattedTextChanges(
+            var services = document.Project.Solution.Workspace.Services;
+            var formatter = document.GetRequiredLanguageService<ISyntaxFormattingService>();
+            var changes = formatter.GetFormattingResult(
                 root, new TextSpan[] { CommonFormattingHelpers.GetFormattingSpan(root, visibleSpan) },
-                workspace, options, formattingRules, CancellationToken.None);
+                options, formattingRules, CancellationToken.None).GetTextChanges(CancellationToken.None);
 
             visibleSpans.Add(visibleSpan);
             var newChanges = FilterTextChanges(document.GetTextSynchronously(CancellationToken.None), visibleSpans, changes.ToReadOnlyCollection()).Where(t => visibleSpan.Contains(t.Span));
diff --git a/src/VisualStudio/Core/Def/Implementation/Venus/ContainedLanguageCodeSupport.cs b/src/VisualStudio/Core/Def/Implementation/Venus/ContainedLanguageCodeSupport.cs
index 50bb61eda988f..9f2d055f1b8d5 100644
--- a/src/VisualStudio/Core/Def/Implementation/Venus/ContainedLanguageCodeSupport.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Venus/ContainedLanguageCodeSupport.cs
@@ -229,12 +229,13 @@ public static Tuple<string, string, VsTextSpan> EnsureEventHandler(
                 targetDocument.WithSyntaxRoot(newRoot), Simplifier.Annotation, null, cancellationToken).WaitAndGetResult_Venus(cancellationToken).GetSyntaxRootSynchronously(cancellationToken);
 
             var formattingRules = additionalFormattingRule.Concat(Formatter.GetDefaultFormattingRules(targetDocument));
+            var formattingOptions = SyntaxFormattingOptions.FromDocumentAsync(targetDocument, cancellationToken).WaitAndGetResult_Venus(cancellationToken);
 
             newRoot = Formatter.Format(
                 newRoot,
                 Formatter.Annotation,
-                targetDocument.Project.Solution.Workspace,
-                targetDocument.GetOptionsAsync(cancellationToken).WaitAndGetResult_Venus(cancellationToken),
+                targetDocument.Project.Solution.Workspace.Services,
+                formattingOptions,
                 formattingRules,
                 cancellationToken);
 
diff --git a/src/VisualStudio/Core/Impl/CodeModel/AbstractCodeModelService.cs b/src/VisualStudio/Core/Impl/CodeModel/AbstractCodeModelService.cs
index 4bea4cbdbea50..0e496a9538361 100644
--- a/src/VisualStudio/Core/Impl/CodeModel/AbstractCodeModelService.cs
+++ b/src/VisualStudio/Core/Impl/CodeModel/AbstractCodeModelService.cs
@@ -1036,12 +1036,17 @@ private Document FormatAnnotatedNode(Document document, SyntaxAnnotation annotat
                 formattingRules = additionalRules.Concat(formattingRules);
             }
 
-            return _threadingContext.JoinableTaskFactory.Run(() => Formatter.FormatAsync(
-                document,
-                new TextSpan[] { formattingSpan },
-                options: null,
-                rules: formattingRules,
-                cancellationToken: cancellationToken));
+            return _threadingContext.JoinableTaskFactory.Run(async () =>
+            {
+                var options = await SyntaxFormattingOptions.FromDocumentAsync(document, cancellationToken).ConfigureAwait(false);
+
+                return await Formatter.FormatAsync(
+                    document,
+                    new TextSpan[] { formattingSpan },
+                    options,
+                    formattingRules,
+                    cancellationToken).ConfigureAwait(false);
+            });
         }
 
         private SyntaxNode InsertNode(
diff --git a/src/Workspaces/CSharp/Portable/CaseCorrection/CSharpCaseCorrectionService.cs b/src/Workspaces/CSharp/Portable/CaseCorrection/CSharpCaseCorrectionService.cs
index 41b41897aaf55..5c905e7d174f0 100644
--- a/src/Workspaces/CSharp/Portable/CaseCorrection/CSharpCaseCorrectionService.cs
+++ b/src/Workspaces/CSharp/Portable/CaseCorrection/CSharpCaseCorrectionService.cs
@@ -26,7 +26,6 @@ protected override void AddReplacements(
             SemanticModel? semanticModel,
             SyntaxNode root,
             ImmutableArray<TextSpan> spans,
-            Workspace workspace,
             ConcurrentDictionary<SyntaxToken, SyntaxToken> replacements,
             CancellationToken cancellationToken)
         {
diff --git a/src/Workspaces/CSharp/Portable/Indentation/CSharpIndentationService.Indenter.cs b/src/Workspaces/CSharp/Portable/Indentation/CSharpIndentationService.Indenter.cs
index 9768531512415..0c9deac40330b 100644
--- a/src/Workspaces/CSharp/Portable/Indentation/CSharpIndentationService.Indenter.cs
+++ b/src/Workspaces/CSharp/Portable/Indentation/CSharpIndentationService.Indenter.cs
@@ -24,10 +24,9 @@ protected override bool ShouldUseTokenIndenter(Indenter indenter, out SyntaxToke
 
         protected override ISmartTokenFormatter CreateSmartTokenFormatter(Indenter indenter)
         {
-            var workspace = indenter.Document.Project.Solution.Workspace;
-            var formattingRuleFactory = workspace.Services.GetRequiredService<IHostDependentFormattingRuleFactoryService>();
+            var services = indenter.Document.Project.Solution.Workspace.Services;
+            var formattingRuleFactory = services.GetRequiredService<IHostDependentFormattingRuleFactoryService>();
             var rules = formattingRuleFactory.CreateRule(indenter.Document.Document, indenter.LineToBeIndented.Start).Concat(Formatter.GetDefaultFormattingRules(indenter.Document.Document));
-
             return new CSharpSmartTokenFormatter(indenter.OptionSet, rules, indenter.Root);
         }
 
diff --git a/src/Workspaces/CSharp/Portable/Indentation/CSharpSmartTokenFormatter.cs b/src/Workspaces/CSharp/Portable/Indentation/CSharpSmartTokenFormatter.cs
index 713f9a5144969..f767038d07f6b 100644
--- a/src/Workspaces/CSharp/Portable/Indentation/CSharpSmartTokenFormatter.cs
+++ b/src/Workspaces/CSharp/Portable/Indentation/CSharpSmartTokenFormatter.cs
@@ -11,6 +11,7 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Formatting.Rules;
+using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Indentation;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
@@ -21,28 +22,28 @@ namespace Microsoft.CodeAnalysis.CSharp.Indentation
 {
     internal class CSharpSmartTokenFormatter : ISmartTokenFormatter
     {
-        private readonly OptionSet _optionSet;
+        private readonly OptionSet _options;
         private readonly IEnumerable<AbstractFormattingRule> _formattingRules;
 
         private readonly CompilationUnitSyntax _root;
 
         public CSharpSmartTokenFormatter(
-            OptionSet optionSet,
+            OptionSet options,
             IEnumerable<AbstractFormattingRule> formattingRules,
             CompilationUnitSyntax root)
         {
-            Contract.ThrowIfNull(optionSet);
+            Contract.ThrowIfNull(options);
             Contract.ThrowIfNull(formattingRules);
             Contract.ThrowIfNull(root);
 
-            _optionSet = optionSet;
+            _options = options;
             _formattingRules = formattingRules;
 
             _root = root;
         }
 
         public IList<TextChange> FormatRange(
-            Workspace workspace, SyntaxToken startToken, SyntaxToken endToken, CancellationToken cancellationToken)
+            HostWorkspaceServices services, SyntaxToken startToken, SyntaxToken endToken, CancellationToken cancellationToken)
         {
             Contract.ThrowIfTrue(startToken.Kind() is SyntaxKind.None or SyntaxKind.EndOfFileToken);
             Contract.ThrowIfTrue(endToken.Kind() is SyntaxKind.None or SyntaxKind.EndOfFileToken);
@@ -60,7 +61,8 @@ public IList<TextChange> FormatRange(
                 smartTokenformattingRules = (new NoLineChangeFormattingRule()).Concat(_formattingRules);
             }
 
-            return Formatter.GetFormattedTextChanges(_root, new TextSpan[] { TextSpan.FromBounds(startToken.SpanStart, endToken.Span.End) }, workspace, _optionSet, smartTokenformattingRules, cancellationToken);
+            var formattingOptions = SyntaxFormattingOptions.Create(_options, services, _root.Language);
+            return Formatter.GetFormattedTextChanges(_root, new[] { TextSpan.FromBounds(startToken.SpanStart, endToken.Span.End) }, services, formattingOptions, smartTokenformattingRules, cancellationToken);
         }
 
         private static bool CloseBraceOfTryOrDoBlock(SyntaxToken endToken)
@@ -71,7 +73,7 @@ private static bool CloseBraceOfTryOrDoBlock(SyntaxToken endToken)
         }
 
         public async Task<IList<TextChange>> FormatTokenAsync(
-            Workspace workspace, SyntaxToken token, CancellationToken cancellationToken)
+            HostWorkspaceServices services, SyntaxToken token, CancellationToken cancellationToken)
         {
             Contract.ThrowIfTrue(token.Kind() is SyntaxKind.None or SyntaxKind.EndOfFileToken);
 
@@ -100,9 +102,9 @@ public async Task<IList<TextChange>> FormatTokenAsync(
                 }
             }
 
-            var smartTokenformattingRules = (new SmartTokenFormattingRule()).Concat(_formattingRules);
+            var smartTokenformattingRules = new SmartTokenFormattingRule().Concat(_formattingRules);
             var adjustedStartPosition = previousToken.SpanStart;
-            var indentStyle = _optionSet.GetOption(FormattingOptions.SmartIndent, LanguageNames.CSharp);
+            var indentStyle = _options.GetOption(FormattingOptions.SmartIndent, LanguageNames.CSharp);
             if (token.IsKind(SyntaxKind.OpenBraceToken) &&
                 indentStyle != FormattingOptions.IndentStyle.Smart)
             {
@@ -114,9 +116,8 @@ public async Task<IList<TextChange>> FormatTokenAsync(
                 }
             }
 
-            return Formatter.GetFormattedTextChanges(_root,
-                new TextSpan[] { TextSpan.FromBounds(adjustedStartPosition, adjustedEndPosition) },
-                workspace, _optionSet, smartTokenformattingRules, cancellationToken);
+            var formattingOptions = SyntaxFormattingOptions.Create(_options, services, _root.Language);
+            return Formatter.GetFormattedTextChanges(_root, new[] { TextSpan.FromBounds(adjustedStartPosition, adjustedEndPosition) }, services, formattingOptions, smartTokenformattingRules, cancellationToken);
         }
 
         private class NoLineChangeFormattingRule : AbstractFormattingRule
diff --git a/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs b/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs
index fe2a1bedba472..43ebf73fbd137 100644
--- a/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs
+++ b/src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs
@@ -7,6 +7,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Formatting;
@@ -3536,7 +3537,7 @@ public class C : IDisposable
             var newDecl = Generator.AddInterfaceType(decl, Generator.IdentifierName("IDisposable"));
             var newRoot = root.ReplaceNode(decl, newDecl);
 
-            var elasticOnlyFormatted = Formatter.Format(newRoot, SyntaxAnnotation.ElasticAnnotation, _workspace).ToFullString();
+            var elasticOnlyFormatted = Formatter.Format(newRoot, SyntaxAnnotation.ElasticAnnotation, _workspace.Services, SyntaxFormattingOptions.Default, CancellationToken.None).ToFullString();
             Assert.Equal(expected, elasticOnlyFormatted);
         }
 
diff --git a/src/Workspaces/CSharpTest/Formatting/FormattingElasticTriviaTests.cs b/src/Workspaces/CSharpTest/Formatting/FormattingElasticTriviaTests.cs
index 7b6c3913cac1b..5691bf443d07a 100644
--- a/src/Workspaces/CSharpTest/Formatting/FormattingElasticTriviaTests.cs
+++ b/src/Workspaces/CSharpTest/Formatting/FormattingElasticTriviaTests.cs
@@ -5,6 +5,7 @@
 #nullable disable
 
 using System.Linq;
+using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Formatting;
@@ -88,7 +89,8 @@ class B
 
             Assert.NotNull(compilation);
 
-            var newCompilation = Formatter.Format(compilation, new AdhocWorkspace());
+            using var workspace = new AdhocWorkspace();
+            var newCompilation = Formatter.Format(compilation, workspace.Services, SyntaxFormattingOptions.Default, CancellationToken.None);
             Assert.Equal(expected, newCompilation.ToFullString());
         }
 
@@ -109,12 +111,13 @@ public class C
 public class SomeAttribute : System.Attribute { }
 ";
 
-            var ws = new AdhocWorkspace();
-            var generator = SyntaxGenerator.GetGenerator(ws, LanguageNames.CSharp);
+            var workspace = new AdhocWorkspace();
+            var generator = SyntaxGenerator.GetGenerator(workspace, LanguageNames.CSharp);
             var root = SyntaxFactory.ParseCompilationUnit(text);
             var decl = generator.GetDeclaration(root.DescendantNodes().OfType<VariableDeclaratorSyntax>().First(vd => vd.Identifier.Text == "f2"));
             var newDecl = generator.AddAttributes(decl, generator.Attribute("Some")).WithAdditionalAnnotations(Formatter.Annotation);
             var newRoot = root.ReplaceNode(decl, newDecl);
+            var options = SyntaxFormattingOptions.Default;
 
             var expected = @"
 public class C
@@ -129,13 +132,13 @@ public class C
 public class SomeAttribute : System.Attribute { }
 ";
 
-            var formatted = Formatter.Format(newRoot, ws).ToFullString();
+            var formatted = Formatter.Format(newRoot, workspace.Services, options, CancellationToken.None).ToFullString();
             Assert.Equal(expected, formatted);
 
-            var elasticOnlyFormatted = Formatter.Format(newRoot, SyntaxAnnotation.ElasticAnnotation, ws).ToFullString();
+            var elasticOnlyFormatted = Formatter.Format(newRoot, SyntaxAnnotation.ElasticAnnotation, workspace.Services, options, CancellationToken.None).ToFullString();
             Assert.Equal(expected, elasticOnlyFormatted);
 
-            var annotationFormatted = Formatter.Format(newRoot, Formatter.Annotation, ws).ToFullString();
+            var annotationFormatted = Formatter.Format(newRoot, Formatter.Annotation, workspace.Services, options, CancellationToken.None).ToFullString();
             Assert.Equal(expected, annotationFormatted);
         }
 
@@ -191,7 +194,8 @@ public void FormatElasticTriviaBetweenPropertiesWithoutAccessors()
 
             Assert.NotNull(compilation);
 
-            var newCompilation = Formatter.Format(compilation, new AdhocWorkspace());
+            using var workspace = new AdhocWorkspace();
+            var newCompilation = Formatter.Format(compilation, workspace.Services, SyntaxFormattingOptions.Default, CancellationToken.None);
             Assert.Equal(expected, newCompilation.ToFullString());
         }
     }
diff --git a/src/Workspaces/CSharpTest/Formatting/FormattingMultipleSpanTests.cs b/src/Workspaces/CSharpTest/Formatting/FormattingMultipleSpanTests.cs
index ebe635efbc802..06e04edf64408 100644
--- a/src/Workspaces/CSharpTest/Formatting/FormattingMultipleSpanTests.cs
+++ b/src/Workspaces/CSharpTest/Formatting/FormattingMultipleSpanTests.cs
@@ -169,7 +169,8 @@ public async Task EmptySpan()
             var document = project.AddDocument("Document", SourceText.From(""));
 
             var syntaxTree = await document.GetSyntaxTreeAsync();
-            var result = Formatter.Format(await syntaxTree.GetRootAsync(), TextSpan.FromBounds(0, 0), workspace, cancellationToken: CancellationToken.None);
+            var root = await syntaxTree.GetRootAsync();
+            var result = Formatter.Format(root, TextSpan.FromBounds(0, 0), workspace.Services, SyntaxFormattingOptions.Default, CancellationToken.None);
         }
 
         private Task AssertFormatAsync(string content, string expected, OptionsCollection changedOptionSet = null)
diff --git a/src/Workspaces/CSharpTest/Formatting/FormattingTests.cs b/src/Workspaces/CSharpTest/Formatting/FormattingTests.cs
index d33aca02deba6..dbe224461206c 100644
--- a/src/Workspaces/CSharpTest/Formatting/FormattingTests.cs
+++ b/src/Workspaces/CSharpTest/Formatting/FormattingTests.cs
@@ -6,6 +6,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CSharp.Formatting;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -4626,8 +4627,8 @@ public void FormatArbitaryNode()
                         })));
 
             Assert.NotNull(property);
-
-            var newProperty = Formatter.Format(property, new AdhocWorkspace());
+            using var workspace = new AdhocWorkspace();
+            var newProperty = Formatter.Format(property, workspace.Services, SyntaxFormattingOptions.Default, CancellationToken.None);
 
             Assert.Equal(expected, newProperty.ToFullString());
         }
@@ -8137,7 +8138,7 @@ static void Main(string[] args)
         public void DontAssumeCertainNodeAreAlwaysParented()
         {
             var block = SyntaxFactory.Block();
-            Formatter.Format(block, new AdhocWorkspace());
+            Formatter.Format(block, new AdhocWorkspace().Services, SyntaxFormattingOptions.Default, CancellationToken.None);
         }
 
         [WorkItem(776, "https://github.com/dotnet/roslyn/issues/776")]
@@ -9212,7 +9213,7 @@ public void M()
         [Fact, Trait(Traits.Feature, Traits.Features.Formatting)]
         [WorkItem(25098, "https://github.com/dotnet/roslyn/issues/25098")]
         public void FormatSingleStructDeclaration()
-            => Formatter.Format(SyntaxFactory.StructDeclaration("S"), DefaultWorkspace);
+            => Formatter.Format(SyntaxFactory.StructDeclaration("S"), DefaultWorkspace.Services, SyntaxFormattingOptions.Default, CancellationToken.None);
 
         [Fact, Trait(Traits.Feature, Traits.Features.Formatting)]
         public async Task FormatIndexExpression()
diff --git a/src/Workspaces/CSharpTest/Formatting/FormattingTreeEditTests.cs b/src/Workspaces/CSharpTest/Formatting/FormattingTreeEditTests.cs
index 5afbf7ff21cae..b179f3762aab8 100644
--- a/src/Workspaces/CSharpTest/Formatting/FormattingTreeEditTests.cs
+++ b/src/Workspaces/CSharpTest/Formatting/FormattingTreeEditTests.cs
@@ -5,6 +5,7 @@
 #nullable disable
 
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Editing;
@@ -36,26 +37,33 @@ void M(int? p) { }
             var g = SyntaxGenerator.GetGenerator(document);
             var root = await document.GetSyntaxRootAsync();
             var attr = g.Attribute("MyAttr");
+            var options = SyntaxFormattingOptions.Default;
 
             var param = root.DescendantNodes().OfType<ParameterSyntax>().First();
+            var root1 = root.ReplaceNode(param, g.AddAttributes(param, g.Attribute("MyAttr")));
+
+            var result1 = Formatter.Format(root1, document.Project.Solution.Workspace.Services, options, CancellationToken.None);
+
             Assert.Equal(@"
 public class C
 {
     void M([MyAttr] int? p) { }
 }
-", Formatter.Format(root.ReplaceNode(param, g.AddAttributes(param, g.Attribute("MyAttr"))),
-    document.Project.Solution.Workspace).ToFullString());
+", result1.ToFullString());
 
             // verify change doesn't affect how attributes appear before other kinds of declarations
             var method = root.DescendantNodes().OfType<MethodDeclarationSyntax>().First();
+
+            var root2 = root.ReplaceNode(method, g.AddAttributes(method, g.Attribute("MyAttr")));
+            var result2 = Formatter.Format(root2, document.Project.Solution.Workspace.Services, options, CancellationToken.None);
+
             Assert.Equal(@"
 public class C
 {
     [MyAttr]
     void M(int? p) { }
 }
-", Formatter.Format(root.ReplaceNode(method, g.AddAttributes(method, g.Attribute("MyAttr"))),
-    document.Project.Solution.Workspace).ToFullString());
+", result2.ToFullString());
         }
     }
 }
diff --git a/src/Workspaces/CSharpTest/Formatting/FormattingTriviaTests.cs b/src/Workspaces/CSharpTest/Formatting/FormattingTriviaTests.cs
index eb7f5943341f9..cefcd95929b4f 100644
--- a/src/Workspaces/CSharpTest/Formatting/FormattingTriviaTests.cs
+++ b/src/Workspaces/CSharpTest/Formatting/FormattingTriviaTests.cs
@@ -10,6 +10,7 @@
 using Roslyn.Test.Utilities;
 using Xunit;
 using System.Threading.Tasks;
+using System.Threading;
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests.Formatting
 {
@@ -1744,12 +1745,18 @@ static void Main(string[] args)
         [Fact, Trait(Traits.Feature, Traits.Features.Formatting)]
         public void NewLineOptions_LineFeedOnly()
         {
+            using var workspace = new AdhocWorkspace();
             var tree = SyntaxFactory.ParseCompilationUnit("class C\r\n{\r\n}");
 
             // replace all EOL trivia with elastic markers to force the formatter to add EOL back
             tree = tree.ReplaceTrivia(tree.DescendantTrivia().Where(tr => tr.IsKind(SyntaxKind.EndOfLineTrivia)), (o, r) => SyntaxFactory.ElasticMarker);
 
-            var formatted = Formatter.Format(tree, DefaultWorkspace, DefaultWorkspace.Options.WithChangedOption(FormattingOptions.NewLine, LanguageNames.CSharp, "\n"));
+            var options = SyntaxFormattingOptions.Create(
+                workspace.Options.WithChangedOption(FormattingOptions.NewLine, LanguageNames.CSharp, "\n"),
+                workspace.Services,
+                tree.Language);
+
+            var formatted = Formatter.Format(tree, workspace.Services, options, CancellationToken.None);
 
             var actual = formatted.ToFullString();
             var expected = "class C\n{\n}";
@@ -1790,7 +1797,14 @@ class F
                                                                                                               .WithLeadingTrivia(SyntaxFactory.TriviaList())
                                                                                                               .WithAdditionalAnnotations(SyntaxAnnotation.ElasticAnnotation));
 
-            var formatted = Formatter.Format(tree, DefaultWorkspace, DefaultWorkspace.Options.WithChangedOption(FormattingOptions.UseTabs, LanguageNames.CSharp, true));
+            using var workspace = new AdhocWorkspace();
+
+            var options = SyntaxFormattingOptions.Create(
+                workspace.Options.WithChangedOption(FormattingOptions.UseTabs, LanguageNames.CSharp, true),
+                workspace.Services,
+                tree.Language);
+
+            var formatted = Formatter.Format(tree, workspace.Services, options, CancellationToken.None);
 
             var actual = formatted.ToFullString();
             Assert.Equal(expected, actual);
diff --git a/src/Workspaces/Core/Portable/CaseCorrection/AbstractCaseCorrectionService.cs b/src/Workspaces/Core/Portable/CaseCorrection/AbstractCaseCorrectionService.cs
index 5a138d4d651c1..afca79fe933dc 100644
--- a/src/Workspaces/Core/Portable/CaseCorrection/AbstractCaseCorrectionService.cs
+++ b/src/Workspaces/Core/Portable/CaseCorrection/AbstractCaseCorrectionService.cs
@@ -8,7 +8,9 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Internal.Log;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
@@ -17,7 +19,7 @@ namespace Microsoft.CodeAnalysis.CaseCorrection
 {
     internal abstract partial class AbstractCaseCorrectionService : ICaseCorrectionService
     {
-        protected abstract void AddReplacements(SemanticModel? semanticModel, SyntaxNode root, ImmutableArray<TextSpan> spans, Workspace workspace, ConcurrentDictionary<SyntaxToken, SyntaxToken> replacements, CancellationToken cancellationToken);
+        protected abstract void AddReplacements(SemanticModel? semanticModel, SyntaxNode root, ImmutableArray<TextSpan> spans, ConcurrentDictionary<SyntaxToken, SyntaxToken> replacements, CancellationToken cancellationToken);
 
         public async Task<Document> CaseCorrectAsync(Document document, ImmutableArray<TextSpan> spans, CancellationToken cancellationToken)
         {
@@ -34,14 +36,14 @@ public async Task<Document> CaseCorrectAsync(Document document, ImmutableArray<T
 
             var semanticModel = await document.ReuseExistingSpeculativeModelAsync(spans.Collapse(), cancellationToken).ConfigureAwait(false);
 
-            var newRoot = CaseCorrect(semanticModel, root, spans, document.Project.Solution.Workspace, cancellationToken);
+            var newRoot = CaseCorrect(semanticModel, root, spans, cancellationToken);
             return (root == newRoot) ? document : document.WithSyntaxRoot(newRoot);
         }
 
-        public SyntaxNode CaseCorrect(SyntaxNode root, ImmutableArray<TextSpan> spans, Workspace workspace, CancellationToken cancellationToken)
-            => CaseCorrect(semanticModel: null, root, spans, workspace, cancellationToken);
+        public SyntaxNode CaseCorrect(SyntaxNode root, ImmutableArray<TextSpan> spans, CancellationToken cancellationToken)
+            => CaseCorrect(semanticModel: null, root, spans, cancellationToken);
 
-        private SyntaxNode CaseCorrect(SemanticModel? semanticModel, SyntaxNode root, ImmutableArray<TextSpan> spans, Workspace workspace, CancellationToken cancellationToken)
+        private SyntaxNode CaseCorrect(SemanticModel? semanticModel, SyntaxNode root, ImmutableArray<TextSpan> spans, CancellationToken cancellationToken)
         {
             using (Logger.LogBlock(FunctionId.CaseCorrection_CaseCorrect, cancellationToken))
             {
@@ -50,7 +52,7 @@ private SyntaxNode CaseCorrect(SemanticModel? semanticModel, SyntaxNode root, Im
 
                 using (Logger.LogBlock(FunctionId.CaseCorrection_AddReplacements, cancellationToken))
                 {
-                    AddReplacements(semanticModel, root, normalizedSpanCollection.ToImmutableArray(), workspace, replacements, cancellationToken);
+                    AddReplacements(semanticModel, root, normalizedSpanCollection.ToImmutableArray(), replacements, cancellationToken);
                 }
 
                 using (Logger.LogBlock(FunctionId.CaseCorrection_ReplaceTokens, cancellationToken))
diff --git a/src/Workspaces/Core/Portable/CaseCorrection/CaseCorrector.cs b/src/Workspaces/Core/Portable/CaseCorrection/CaseCorrector.cs
index 6f12d35299271..37eff4be9241b 100644
--- a/src/Workspaces/Core/Portable/CaseCorrection/CaseCorrector.cs
+++ b/src/Workspaces/Core/Portable/CaseCorrection/CaseCorrector.cs
@@ -7,6 +7,8 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.CodeAnalysis.CaseCorrection
@@ -64,7 +66,7 @@ public static Task<Document> CaseCorrectAsync(Document document, ImmutableArray<
         /// <summary>
         /// Case correct only things that don't require semantic information
         /// </summary>
-        internal static SyntaxNode CaseCorrect(SyntaxNode root, ImmutableArray<TextSpan> spans, Workspace workspace, CancellationToken cancellationToken = default)
-            => workspace.Services.GetLanguageServices(root.Language).GetRequiredService<ICaseCorrectionService>().CaseCorrect(root, spans, workspace, cancellationToken);
+        internal static SyntaxNode CaseCorrect(SyntaxNode root, ImmutableArray<TextSpan> spans, HostWorkspaceServices services, CancellationToken cancellationToken = default)
+            => services.GetLanguageServices(root.Language).GetRequiredService<ICaseCorrectionService>().CaseCorrect(root, spans, cancellationToken);
     }
 }
diff --git a/src/Workspaces/Core/Portable/CaseCorrection/ICaseCorrectionService.cs b/src/Workspaces/Core/Portable/CaseCorrection/ICaseCorrectionService.cs
index d535edbc8d49f..5fcb67f21aa08 100644
--- a/src/Workspaces/Core/Portable/CaseCorrection/ICaseCorrectionService.cs
+++ b/src/Workspaces/Core/Portable/CaseCorrection/ICaseCorrectionService.cs
@@ -6,6 +6,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.CodeAnalysis.CaseCorrection
@@ -20,6 +21,6 @@ internal interface ICaseCorrectionService : ILanguageService
         /// <summary>
         /// Case corrects only things that don't require semantic information
         /// </summary>
-        SyntaxNode CaseCorrect(SyntaxNode root, ImmutableArray<TextSpan> spans, Workspace workspace, CancellationToken cancellationToken);
+        SyntaxNode CaseCorrect(SyntaxNode root, ImmutableArray<TextSpan> spans, CancellationToken cancellationToken);
     }
 }
diff --git a/src/Workspaces/Core/Portable/CodeCleanup/AbstractCodeCleanerService.cs b/src/Workspaces/Core/Portable/CodeCleanup/AbstractCodeCleanerService.cs
index c5e41db5b9c28..b9a3a9f39cf3c 100644
--- a/src/Workspaces/Core/Portable/CodeCleanup/AbstractCodeCleanerService.cs
+++ b/src/Workspaces/Core/Portable/CodeCleanup/AbstractCodeCleanerService.cs
@@ -11,13 +11,14 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeCleanup.Providers;
 using Microsoft.CodeAnalysis.Internal.Log;
-using Microsoft.CodeAnalysis.LanguageServices;
+using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared;
 using Microsoft.CodeAnalysis.Shared.Collections;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
+using Microsoft.CodeAnalysis.Formatting;
 
 namespace Microsoft.CodeAnalysis.CodeCleanup
 {
@@ -26,7 +27,7 @@ internal abstract class AbstractCodeCleanerService : ICodeCleanerService
         public abstract ImmutableArray<ICodeCleanupProvider> GetDefaultProviders();
         protected abstract ImmutableArray<TextSpan> GetSpansToAvoid(SyntaxNode root);
 
-        public async Task<Document> CleanupAsync(Document document, ImmutableArray<TextSpan> spans, ImmutableArray<ICodeCleanupProvider> providers, CancellationToken cancellationToken)
+        public async Task<Document> CleanupAsync(Document document, ImmutableArray<TextSpan> spans, SyntaxFormattingOptions options, ImmutableArray<ICodeCleanupProvider> providers, CancellationToken cancellationToken)
         {
             using (Logger.LogBlock(FunctionId.CodeCleanup_CleanupAsync, cancellationToken))
             {
@@ -45,7 +46,7 @@ public async Task<Document> CleanupAsync(Document document, ImmutableArray<TextS
                 if (CleanupWholeNode(root.FullSpan, normalizedSpan))
                 {
                     // We are cleaning up the whole document, so there is no need to do expansive span tracking between cleaners.
-                    return await IterateAllCodeCleanupProvidersAsync(document, document, r => ImmutableArray.Create(r.FullSpan), codeCleaners, cancellationToken).ConfigureAwait(false);
+                    return await IterateAllCodeCleanupProvidersAsync(document, document, options, r => ImmutableArray.Create(r.FullSpan), codeCleaners, cancellationToken).ConfigureAwait(false);
                 }
 
                 // We need to track spans between cleaners. Annotate the tree with the provided spans.
@@ -55,7 +56,7 @@ public async Task<Document> CleanupAsync(Document document, ImmutableArray<TextS
                 if (newNode == null)
                 {
                     // ... then we are cleaning up the whole document, so there is no need to do expansive span tracking between cleaners.
-                    return await IterateAllCodeCleanupProvidersAsync(document, document, n => ImmutableArray.Create(n.FullSpan), codeCleaners, cancellationToken).ConfigureAwait(false);
+                    return await IterateAllCodeCleanupProvidersAsync(document, document, options, n => ImmutableArray.Create(n.FullSpan), codeCleaners, cancellationToken).ConfigureAwait(false);
                 }
 
                 // Replace the initial node and document with the annotated node.
@@ -64,13 +65,13 @@ public async Task<Document> CleanupAsync(Document document, ImmutableArray<TextS
 
                 // Run the actual cleanup.
                 return await IterateAllCodeCleanupProvidersAsync(
-                    document, annotatedDocument,
+                    document, annotatedDocument, options,
                     r => GetTextSpansFromAnnotation(r, annotations, cancellationToken),
                     codeCleaners, cancellationToken).ConfigureAwait(false);
             }
         }
 
-        public async Task<SyntaxNode> CleanupAsync(SyntaxNode root, ImmutableArray<TextSpan> spans, Workspace workspace, ImmutableArray<ICodeCleanupProvider> providers, CancellationToken cancellationToken)
+        public async Task<SyntaxNode> CleanupAsync(SyntaxNode root, ImmutableArray<TextSpan> spans, SyntaxFormattingOptions options, HostWorkspaceServices services, ImmutableArray<ICodeCleanupProvider> providers, CancellationToken cancellationToken)
         {
             using (Logger.LogBlock(FunctionId.CodeCleanup_Cleanup, cancellationToken))
             {
@@ -87,7 +88,7 @@ public async Task<SyntaxNode> CleanupAsync(SyntaxNode root, ImmutableArray<TextS
                 if (CleanupWholeNode(root.FullSpan, normalizedSpan))
                 {
                     // We are cleaning up the whole document, so there is no need to do expansive span tracking between cleaners.
-                    return await IterateAllCodeCleanupProvidersAsync(root, root, r => ImmutableArray.Create(r.FullSpan), workspace, codeCleaners, cancellationToken).ConfigureAwait(false);
+                    return await IterateAllCodeCleanupProvidersAsync(root, root, options, r => ImmutableArray.Create(r.FullSpan), services, codeCleaners, cancellationToken).ConfigureAwait(false);
                 }
 
                 // We need to track spans between cleaners. Annotate the tree with the provided spans.
@@ -97,7 +98,7 @@ public async Task<SyntaxNode> CleanupAsync(SyntaxNode root, ImmutableArray<TextS
                 if (newNode == null)
                 {
                     // ... then we are cleaning up the whole document, so there is no need to do expansive span tracking between cleaners.
-                    return await IterateAllCodeCleanupProvidersAsync(root, root, n => ImmutableArray.Create(n.FullSpan), workspace, codeCleaners, cancellationToken).ConfigureAwait(false);
+                    return await IterateAllCodeCleanupProvidersAsync(root, root, options, n => ImmutableArray.Create(n.FullSpan), services, codeCleaners, cancellationToken).ConfigureAwait(false);
                 }
 
                 // Replace the initial node and document with the annotated node.
@@ -105,9 +106,9 @@ public async Task<SyntaxNode> CleanupAsync(SyntaxNode root, ImmutableArray<TextS
 
                 // Run the actual cleanup.
                 return await IterateAllCodeCleanupProvidersAsync(
-                    root, annotatedRoot,
+                    root, annotatedRoot, options,
                     r => GetTextSpansFromAnnotation(r, annotations, cancellationToken),
-                    workspace, codeCleaners, cancellationToken).ConfigureAwait(false);
+                    services, codeCleaners, cancellationToken).ConfigureAwait(false);
             }
         }
 
@@ -454,6 +455,7 @@ private static bool CleanupWholeNode(TextSpan nodeSpan, ImmutableArray<TextSpan>
         private async Task<Document> IterateAllCodeCleanupProvidersAsync(
             Document originalDocument,
             Document annotatedDocument,
+            SyntaxFormattingOptions options,
             Func<SyntaxNode, ImmutableArray<TextSpan>> spanGetter,
             ImmutableArray<ICodeCleanupProvider> codeCleaners,
             CancellationToken cancellationToken)
@@ -492,7 +494,7 @@ private async Task<Document> IterateAllCodeCleanupProvidersAsync(
 
                     using (Logger.LogBlock(FunctionId.CodeCleanup_IterateOneCodeCleanup, GetCodeCleanerTypeName, codeCleaner, cancellationToken))
                     {
-                        currentDocument = await codeCleaner.CleanupAsync(currentDocument, spans, cancellationToken).ConfigureAwait(false);
+                        currentDocument = await codeCleaner.CleanupAsync(currentDocument, spans, options, cancellationToken).ConfigureAwait(false);
                     }
 
 #if DEBUG
@@ -534,8 +536,9 @@ private ImmutableArray<TextSpan> GetSpans(
         private async Task<SyntaxNode> IterateAllCodeCleanupProvidersAsync(
             SyntaxNode originalRoot,
             SyntaxNode annotatedRoot,
+            SyntaxFormattingOptions options,
             Func<SyntaxNode, ImmutableArray<TextSpan>> spanGetter,
-            Workspace workspace,
+            HostWorkspaceServices services,
             ImmutableArray<ICodeCleanupProvider> codeCleaners,
             CancellationToken cancellationToken)
         {
@@ -568,7 +571,7 @@ private async Task<SyntaxNode> IterateAllCodeCleanupProvidersAsync(
 
                     using (Logger.LogBlock(FunctionId.CodeCleanup_IterateOneCodeCleanup, GetCodeCleanerTypeName, codeCleaner, cancellationToken))
                     {
-                        currentRoot = await codeCleaner.CleanupAsync(currentRoot, spans, workspace, cancellationToken).ConfigureAwait(false);
+                        currentRoot = await codeCleaner.CleanupAsync(currentRoot, spans, options, services, cancellationToken).ConfigureAwait(false);
                     }
                 }
 
diff --git a/src/Workspaces/Core/Portable/CodeCleanup/CodeCleaner.cs b/src/Workspaces/Core/Portable/CodeCleanup/CodeCleaner.cs
index ba2c0ae954d5e..aee43fe399a36 100644
--- a/src/Workspaces/Core/Portable/CodeCleanup/CodeCleaner.cs
+++ b/src/Workspaces/Core/Portable/CodeCleanup/CodeCleaner.cs
@@ -9,7 +9,10 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeCleanup.Providers;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Text;
+using Microsoft.CodeAnalysis.Formatting;
 
 namespace Microsoft.CodeAnalysis.CodeCleanup
 {
@@ -72,27 +75,29 @@ public static Task<Document> CleanupAsync(Document document, TextSpan span, Immu
         /// Clean up the provided spans in the document.
         /// Optionally you can provide your own options and code cleaners. Otherwise, the default will be used.
         /// </summary>
-        public static Task<Document> CleanupAsync(Document document, ImmutableArray<TextSpan> spans, ImmutableArray<ICodeCleanupProvider> providers = default, CancellationToken cancellationToken = default)
+        public static async Task<Document> CleanupAsync(Document document, ImmutableArray<TextSpan> spans, ImmutableArray<ICodeCleanupProvider> providers = default, CancellationToken cancellationToken = default)
         {
             var cleanupService = document.GetRequiredLanguageService<ICodeCleanerService>();
-            return cleanupService.CleanupAsync(document, spans, providers, cancellationToken);
+            var options = await SyntaxFormattingOptions.FromDocumentAsync(document, cancellationToken).ConfigureAwait(false);
+            return await cleanupService.CleanupAsync(document, spans, options, providers, cancellationToken).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Clean up the provided span in the node.
         /// This will only cleanup stuff that doesn't require semantic information.
         /// </summary>
-        public static Task<SyntaxNode> CleanupAsync(SyntaxNode root, TextSpan span, Workspace workspace, ImmutableArray<ICodeCleanupProvider> providers = default, CancellationToken cancellationToken = default)
-            => CleanupAsync(root, ImmutableArray.Create(span), workspace, providers, cancellationToken);
+        public static Task<SyntaxNode> CleanupAsync(SyntaxNode root, TextSpan span, OptionSet options, HostWorkspaceServices services, ImmutableArray<ICodeCleanupProvider> providers = default, CancellationToken cancellationToken = default)
+            => CleanupAsync(root, ImmutableArray.Create(span), options, services, providers, cancellationToken);
 
         /// <summary>
         /// Clean up the provided spans in the node.
         /// This will only cleanup stuff that doesn't require semantic information.
         /// </summary>
-        public static Task<SyntaxNode> CleanupAsync(SyntaxNode root, ImmutableArray<TextSpan> spans, Workspace workspace, ImmutableArray<ICodeCleanupProvider> providers = default, CancellationToken cancellationToken = default)
+        public static Task<SyntaxNode> CleanupAsync(SyntaxNode root, ImmutableArray<TextSpan> spans, OptionSet options, HostWorkspaceServices services, ImmutableArray<ICodeCleanupProvider> providers = default, CancellationToken cancellationToken = default)
         {
-            var cleanupService = workspace.Services.GetLanguageServices(root.Language).GetRequiredService<ICodeCleanerService>();
-            return cleanupService.CleanupAsync(root, spans, workspace, providers, cancellationToken);
+            var cleanupService = services.GetLanguageServices(root.Language).GetRequiredService<ICodeCleanerService>();
+            var formattingOptions = SyntaxFormattingOptions.Create(options, services, root.Language);
+            return cleanupService.CleanupAsync(root, spans, formattingOptions, services, providers, cancellationToken);
         }
     }
 }
diff --git a/src/Workspaces/Core/Portable/CodeCleanup/ICodeCleanerService.cs b/src/Workspaces/Core/Portable/CodeCleanup/ICodeCleanerService.cs
index 68c4e6bf67f97..f9f47a1551ea9 100644
--- a/src/Workspaces/Core/Portable/CodeCleanup/ICodeCleanerService.cs
+++ b/src/Workspaces/Core/Portable/CodeCleanup/ICodeCleanerService.cs
@@ -6,6 +6,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeCleanup.Providers;
+using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Text;
 
@@ -26,13 +27,13 @@ internal interface ICodeCleanerService : ILanguageService
         /// <summary>
         /// This will run all provided code cleaners in an order that is given to the method.
         /// </summary>
-        Task<Document> CleanupAsync(Document document, ImmutableArray<TextSpan> spans, ImmutableArray<ICodeCleanupProvider> providers, CancellationToken cancellationToken);
+        Task<Document> CleanupAsync(Document document, ImmutableArray<TextSpan> spans, SyntaxFormattingOptions options, ImmutableArray<ICodeCleanupProvider> providers, CancellationToken cancellationToken);
 
         /// <summary>
         /// This will run all provided code cleaners in an order that is given to the method.
         /// 
         /// This will do cleanups that don't require any semantic information.
         /// </summary>
-        Task<SyntaxNode> CleanupAsync(SyntaxNode root, ImmutableArray<TextSpan> spans, Workspace workspace, ImmutableArray<ICodeCleanupProvider> providers, CancellationToken cancellationToken);
+        Task<SyntaxNode> CleanupAsync(SyntaxNode root, ImmutableArray<TextSpan> spans, SyntaxFormattingOptions options, HostWorkspaceServices services, ImmutableArray<ICodeCleanupProvider> providers, CancellationToken cancellationToken);
     }
 }
diff --git a/src/Workspaces/Core/Portable/CodeCleanup/Providers/FormatCodeCleanupProvider.cs b/src/Workspaces/Core/Portable/CodeCleanup/Providers/FormatCodeCleanupProvider.cs
index d18e6f90ebeb1..707c1d34a32fa 100644
--- a/src/Workspaces/Core/Portable/CodeCleanup/Providers/FormatCodeCleanupProvider.cs
+++ b/src/Workspaces/Core/Portable/CodeCleanup/Providers/FormatCodeCleanupProvider.cs
@@ -2,53 +2,50 @@
 // 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 System.Collections.Immutable;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Formatting;
+using Microsoft.CodeAnalysis.Formatting.Rules;
+using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.CodeAnalysis.CodeCleanup.Providers
 {
-    internal class FormatCodeCleanupProvider : ICodeCleanupProvider
+    internal sealed class FormatCodeCleanupProvider : ICodeCleanupProvider
     {
+        private readonly IEnumerable<AbstractFormattingRule>? _rules;
+
+        public FormatCodeCleanupProvider(IEnumerable<AbstractFormattingRule>? rules = null)
+        {
+            _rules = rules;
+        }
+
         public string Name => PredefinedCodeCleanupProviderNames.Format;
 
-        public async Task<Document> CleanupAsync(Document document, ImmutableArray<TextSpan> spans, CancellationToken cancellationToken)
+        public async Task<Document> CleanupAsync(Document document, ImmutableArray<TextSpan> spans, SyntaxFormattingOptions options, CancellationToken cancellationToken)
         {
-            // If the old text already exists, use the fast path for formatting.
-            if (document.TryGetText(out var oldText))
-            {
-                var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-                var textChanges = Formatter.GetFormattedTextChanges(root, spans, document.Project.Solution.Workspace, cancellationToken: cancellationToken);
-                if (textChanges.Count == 0)
-                {
-                    return document;
-                }
-
-                var newText = oldText.WithChanges(textChanges);
-                return document.WithText(newText);
-            }
-
-            return await Formatter.FormatAsync(document, spans, cancellationToken: cancellationToken).ConfigureAwait(false);
+            var formatter = document.GetRequiredLanguageService<ISyntaxFormattingService>();
+            var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var result = formatter.GetFormattingResult(root, spans, options, _rules, cancellationToken);
+
+            // apply changes to an old text if it already exists
+            return document.TryGetText(out var oldText) ?
+                document.WithText(oldText.WithChanges(result.GetTextChanges(cancellationToken))) :
+                document.WithSyntaxRoot(result.GetFormattedRoot(cancellationToken));
         }
 
-        public async Task<SyntaxNode> CleanupAsync(SyntaxNode root, ImmutableArray<TextSpan> spans, Workspace workspace, CancellationToken cancellationToken)
+        public Task<SyntaxNode> CleanupAsync(SyntaxNode root, ImmutableArray<TextSpan> spans, SyntaxFormattingOptions options, HostWorkspaceServices services, CancellationToken cancellationToken)
         {
-            // If the old text already exists, use the fast path for formatting.
-            if (root.SyntaxTree != null && root.SyntaxTree.TryGetText(out var oldText))
-            {
-                var changes = Formatter.GetFormattedTextChanges(root, spans, workspace, cancellationToken: cancellationToken);
-                if (changes.Count == 0)
-                {
-                    return root;
-                }
-
-                return await root.SyntaxTree.WithChangedText(oldText.WithChanges(changes)).GetRootAsync(cancellationToken).ConfigureAwait(false);
-            }
-
-            return Formatter.Format(root, spans, workspace, cancellationToken: cancellationToken);
+            var formatter = services.GetRequiredLanguageService<ISyntaxFormattingService>(root.Language);
+            var result = formatter.GetFormattingResult(root, spans, options, _rules, cancellationToken);
+
+            // apply changes to an old text if it already exists
+            return (root.SyntaxTree != null && root.SyntaxTree.TryGetText(out var oldText)) ?
+                root.SyntaxTree.WithChangedText(oldText.WithChanges(result.GetTextChanges(cancellationToken))).GetRootAsync(cancellationToken) :
+                Task.FromResult(result.GetFormattedRoot(cancellationToken));
         }
     }
 }
diff --git a/src/Workspaces/Core/Portable/CodeCleanup/Providers/ICodeCleanupProvider.cs b/src/Workspaces/Core/Portable/CodeCleanup/Providers/ICodeCleanupProvider.cs
index cfdb8b814ca76..52f2f2959a1be 100644
--- a/src/Workspaces/Core/Portable/CodeCleanup/Providers/ICodeCleanupProvider.cs
+++ b/src/Workspaces/Core/Portable/CodeCleanup/Providers/ICodeCleanupProvider.cs
@@ -5,6 +5,8 @@
 using System.Collections.Immutable;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Formatting;
+using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.CodeAnalysis.CodeCleanup.Providers
@@ -22,13 +24,13 @@ internal interface ICodeCleanupProvider
         /// <summary>
         /// This should apply its code clean up logic to the spans of the document.
         /// </summary>
-        Task<Document> CleanupAsync(Document document, ImmutableArray<TextSpan> spans, CancellationToken cancellationToken = default);
+        Task<Document> CleanupAsync(Document document, ImmutableArray<TextSpan> spans, SyntaxFormattingOptions options, CancellationToken cancellationToken);
 
         /// <summary>
         /// This will run all provided code cleaners in an order that is given to the method.
         /// 
         /// This will do cleanups that don't require any semantic information
         /// </summary>
-        Task<SyntaxNode> CleanupAsync(SyntaxNode root, ImmutableArray<TextSpan> spans, Workspace workspace, CancellationToken cancellationToken = default);
+        Task<SyntaxNode> CleanupAsync(SyntaxNode root, ImmutableArray<TextSpan> spans, SyntaxFormattingOptions options, HostWorkspaceServices services, CancellationToken cancellationToken);
     }
 }
diff --git a/src/Workspaces/Core/Portable/CodeCleanup/Providers/SimpleCodeCleanupProvider.cs b/src/Workspaces/Core/Portable/CodeCleanup/Providers/SimpleCodeCleanupProvider.cs
deleted file mode 100644
index e3575eb48e0ba..0000000000000
--- a/src/Workspaces/Core/Portable/CodeCleanup/Providers/SimpleCodeCleanupProvider.cs
+++ /dev/null
@@ -1,72 +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.Immutable;
-using System.Diagnostics;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.Shared.Extensions;
-using Microsoft.CodeAnalysis.Text;
-using Roslyn.Utilities;
-
-namespace Microsoft.CodeAnalysis.CodeCleanup.Providers
-{
-    /// <summary>
-    /// Helper class that implements <see cref="ICodeCleanupProvider"/> using delegates passed to its constructor.
-    /// </summary>
-    internal class SimpleCodeCleanupProvider : ICodeCleanupProvider
-    {
-        private readonly Func<Document, ImmutableArray<TextSpan>, CancellationToken, Task<Document>>? _documentDelegatee;
-        private readonly Func<SyntaxNode, ImmutableArray<TextSpan>, Workspace, CancellationToken, SyntaxNode>? _syntaxDelegatee;
-
-        public SimpleCodeCleanupProvider(string name,
-            Func<Document, ImmutableArray<TextSpan>, CancellationToken, Task<Document>>? documentDelegatee = null,
-            Func<SyntaxNode, ImmutableArray<TextSpan>, Workspace, CancellationToken, SyntaxNode>? syntaxDelegatee = null)
-        {
-            Debug.Assert(documentDelegatee != null || syntaxDelegatee != null);
-
-            this.Name = name;
-            _documentDelegatee = documentDelegatee;
-            _syntaxDelegatee = syntaxDelegatee;
-        }
-
-        public string Name { get; }
-
-        public Task<Document> CleanupAsync(Document document, ImmutableArray<TextSpan> spans, CancellationToken cancellationToken)
-        {
-            if (_documentDelegatee != null)
-            {
-                return _documentDelegatee(document, spans, cancellationToken);
-            }
-
-            return CleanupCoreAsync(document, spans, cancellationToken);
-        }
-
-        private async Task<Document> CleanupCoreAsync(Document document, ImmutableArray<TextSpan> spans, CancellationToken cancellationToken)
-        {
-            RoslynDebug.AssertNotNull(_syntaxDelegatee);
-
-            var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-            var newRoot = _syntaxDelegatee(root, spans, document.Project.Solution.Workspace, cancellationToken);
-
-            if (root != newRoot)
-            {
-                return document.WithSyntaxRoot(newRoot);
-            }
-
-            return document;
-        }
-
-        public Task<SyntaxNode> CleanupAsync(SyntaxNode root, ImmutableArray<TextSpan> spans, Workspace workspace, CancellationToken cancellationToken)
-        {
-            if (_syntaxDelegatee != null)
-            {
-                return Task.FromResult(_syntaxDelegatee(root, spans, workspace, cancellationToken));
-            }
-
-            return Task.FromResult(root);
-        }
-    }
-}
diff --git a/src/Workspaces/Core/Portable/CodeCleanup/Providers/SimplificationCodeCleanupProvider.cs b/src/Workspaces/Core/Portable/CodeCleanup/Providers/SimplificationCodeCleanupProvider.cs
index 702f7044dbef3..70ea4aefd3909 100644
--- a/src/Workspaces/Core/Portable/CodeCleanup/Providers/SimplificationCodeCleanupProvider.cs
+++ b/src/Workspaces/Core/Portable/CodeCleanup/Providers/SimplificationCodeCleanupProvider.cs
@@ -5,6 +5,8 @@
 using System.Collections.Immutable;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Simplification;
 using Microsoft.CodeAnalysis.Text;
 
@@ -14,10 +16,10 @@ internal class SimplificationCodeCleanupProvider : ICodeCleanupProvider
     {
         public string Name => PredefinedCodeCleanupProviderNames.Simplification;
 
-        public Task<Document> CleanupAsync(Document document, ImmutableArray<TextSpan> spans, CancellationToken cancellationToken)
+        public Task<Document> CleanupAsync(Document document, ImmutableArray<TextSpan> spans, SyntaxFormattingOptions options, CancellationToken cancellationToken)
             => Simplifier.ReduceAsync(document, spans, null, cancellationToken);
 
-        public Task<SyntaxNode> CleanupAsync(SyntaxNode root, ImmutableArray<TextSpan> spans, Workspace workspace, CancellationToken cancellationToken)
+        public Task<SyntaxNode> CleanupAsync(SyntaxNode root, ImmutableArray<TextSpan> spans, SyntaxFormattingOptions options, HostWorkspaceServices services, CancellationToken cancellationToken)
         {
             // Simplifier doesn't work without semantic information
             return Task.FromResult(root);
diff --git a/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs b/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs
index f2ef1efb52eeb..96fb7047d135b 100644
--- a/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs
+++ b/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs
@@ -53,6 +53,9 @@ public abstract class SyntaxGenerator : ILanguageService
         public static SyntaxGenerator GetGenerator(Workspace workspace, string language)
             => GetGenerator(workspace.Services, language);
 
+        /// <summary>
+        /// Gets the <see cref="SyntaxGenerator"/> for the specified language.
+        /// </summary>
         internal static SyntaxGenerator GetGenerator(HostWorkspaceServices services, string language)
             => services.GetLanguageServices(language).GetRequiredService<SyntaxGenerator>();
 
diff --git a/src/Workspaces/Core/Portable/Formatting/AbstractFormattingService.cs b/src/Workspaces/Core/Portable/Formatting/AbstractFormattingService.cs
index f1968be47a0e8..e697edafd98c5 100644
--- a/src/Workspaces/Core/Portable/Formatting/AbstractFormattingService.cs
+++ b/src/Workspaces/Core/Portable/Formatting/AbstractFormattingService.cs
@@ -16,6 +16,9 @@ namespace Microsoft.CodeAnalysis.Formatting
     internal abstract class AbstractFormattingService : IFormattingService
     {
         public Task<Document> FormatAsync(Document document, IEnumerable<TextSpan>? spans, OptionSet options, CancellationToken cancellationToken)
-            => Formatter.FormatAsync(document, spans, options, rules: null, cancellationToken: cancellationToken);
+        {
+            var formattingOptions = SyntaxFormattingOptions.Create(options, document.Project.Solution.Workspace.Services, document.Project.Language);
+            return Formatter.FormatAsync(document, spans, formattingOptions, rules: null, cancellationToken);
+        }
     }
 }
diff --git a/src/Workspaces/Core/Portable/Formatting/Formatter.cs b/src/Workspaces/Core/Portable/Formatting/Formatter.cs
index 55b488c8b56a5..95327a7f3fbe5 100644
--- a/src/Workspaces/Core/Portable/Formatting/Formatter.cs
+++ b/src/Workspaces/Core/Portable/Formatting/Formatter.cs
@@ -6,7 +6,9 @@
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Formatting.Rules;
+using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.OrganizeImports;
 using Microsoft.CodeAnalysis.Shared.Extensions;
@@ -47,32 +49,6 @@ internal static IEnumerable<AbstractFormattingRule> GetDefaultFormattingRules(Do
             }
         }
 
-        /// <summary>
-        /// Gets the formatting rules that would be applied if left unspecified.
-        /// </summary>
-        internal static IEnumerable<AbstractFormattingRule> GetDefaultFormattingRules(Workspace workspace, string language)
-        {
-            if (workspace == null)
-            {
-                throw new ArgumentNullException(nameof(workspace));
-            }
-
-            if (language == null)
-            {
-                throw new ArgumentNullException(nameof(language));
-            }
-
-            var service = workspace.Services.GetLanguageServices(language).GetService<ISyntaxFormattingService>();
-            if (service != null)
-            {
-                return service.GetDefaultFormattingRules();
-            }
-            else
-            {
-                return SpecializedCollections.EmptyEnumerable<AbstractFormattingRule>();
-            }
-        }
-
         /// <summary>
         /// Formats the whitespace in a document.
         /// </summary>
@@ -114,16 +90,11 @@ public static async Task<Document> FormatAsync(Document document, IEnumerable<Te
             return await formattingService.FormatAsync(document, spans, options, cancellationToken).ConfigureAwait(false);
         }
 
-        internal static async Task<Document> FormatAsync(Document document, IEnumerable<TextSpan>? spans, OptionSet? options, IEnumerable<AbstractFormattingRule>? rules, CancellationToken cancellationToken)
+        internal static async Task<Document> FormatAsync(Document document, IEnumerable<TextSpan>? spans, SyntaxFormattingOptions options, IEnumerable<AbstractFormattingRule>? rules, CancellationToken cancellationToken)
         {
-            if (document == null)
-            {
-                throw new ArgumentNullException(nameof(document));
-            }
-
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-            var documentOptions = options ?? await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
-            return document.WithSyntaxRoot(Format(root, spans, document.Project.Solution.Workspace, documentOptions, rules, cancellationToken));
+            var services = document.Project.Solution.Workspace.Services;
+            return document.WithSyntaxRoot(Format(root, spans, services, options, rules, cancellationToken));
         }
 
         /// <summary>
@@ -151,7 +122,10 @@ internal static async Task<Document> FormatAsync(Document document, SyntaxAnnota
 
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             var documentOptions = options ?? await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
-            return document.WithSyntaxRoot(Format(root, annotation, document.Project.Solution.Workspace, documentOptions, rules, cancellationToken));
+            var services = document.Project.Solution.Workspace.Services;
+            var formattingOptions = SyntaxFormattingOptions.Create(documentOptions, services, root.Language);
+
+            return document.WithSyntaxRoot(Format(root, annotation, services, formattingOptions, rules, cancellationToken));
         }
 
         /// <summary>
@@ -164,9 +138,12 @@ internal static async Task<Document> FormatAsync(Document document, SyntaxAnnota
         /// <param name="cancellationToken">An optional cancellation token.</param>
         /// <returns>The formatted tree's root node.</returns>
         public static SyntaxNode Format(SyntaxNode node, SyntaxAnnotation annotation, Workspace workspace, OptionSet? options = null, CancellationToken cancellationToken = default)
-            => Format(node, annotation, workspace, options, rules: null, cancellationToken: cancellationToken);
+            => Format(node, annotation, workspace, options, rules: null, cancellationToken);
 
-        internal static SyntaxNode Format(SyntaxNode node, SyntaxAnnotation annotation, Workspace workspace, OptionSet? options, IEnumerable<AbstractFormattingRule>? rules, CancellationToken cancellationToken)
+        internal static SyntaxNode Format(SyntaxNode node, SyntaxAnnotation annotation, HostWorkspaceServices services, SyntaxFormattingOptions options, CancellationToken cancellationToken)
+            => Format(node, annotation, services, options, rules: null, cancellationToken);
+
+        private static SyntaxNode Format(SyntaxNode node, SyntaxAnnotation annotation, Workspace workspace, OptionSet? options, IEnumerable<AbstractFormattingRule>? rules, CancellationToken cancellationToken)
         {
             if (workspace == null)
             {
@@ -183,13 +160,12 @@ internal static SyntaxNode Format(SyntaxNode node, SyntaxAnnotation annotation,
                 throw new ArgumentNullException(nameof(annotation));
             }
 
-            var spans = (annotation == SyntaxAnnotation.ElasticAnnotation)
-                ? GetElasticSpans(node)
-                : GetAnnotatedSpans(node, annotation);
-
-            return Format(node, spans, workspace, options, rules, cancellationToken);
+            return Format(node, GetAnnotatedSpans(node, annotation), workspace, options, rules, cancellationToken);
         }
 
+        internal static SyntaxNode Format(SyntaxNode node, SyntaxAnnotation annotation, HostWorkspaceServices services, SyntaxFormattingOptions options, IEnumerable<AbstractFormattingRule>? rules, CancellationToken cancellationToken)
+            => Format(node, GetAnnotatedSpans(node, annotation), services, options, rules, cancellationToken);
+
         /// <summary>
         /// Formats the whitespace of a syntax tree.
         /// </summary>
@@ -199,7 +175,10 @@ internal static SyntaxNode Format(SyntaxNode node, SyntaxAnnotation annotation,
         /// <param name="cancellationToken">An optional cancellation token.</param>
         /// <returns>The formatted tree's root node.</returns>
         public static SyntaxNode Format(SyntaxNode node, Workspace workspace, OptionSet? options = null, CancellationToken cancellationToken = default)
-            => Format(node, SpecializedCollections.SingletonEnumerable(node.FullSpan), workspace, options, rules: null, cancellationToken: cancellationToken);
+            => Format(node, SpecializedCollections.SingletonEnumerable(node.FullSpan), workspace, options, rules: null, cancellationToken);
+
+        internal static SyntaxNode Format(SyntaxNode node, HostWorkspaceServices services, SyntaxFormattingOptions options, CancellationToken cancellationToken)
+            => Format(node, SpecializedCollections.SingletonEnumerable(node.FullSpan), services, options, rules: null, cancellationToken);
 
         /// <summary>
         /// Formats the whitespace in areas of a syntax tree identified by a span.
@@ -213,6 +192,9 @@ public static SyntaxNode Format(SyntaxNode node, Workspace workspace, OptionSet?
         public static SyntaxNode Format(SyntaxNode node, TextSpan span, Workspace workspace, OptionSet? options = null, CancellationToken cancellationToken = default)
             => Format(node, SpecializedCollections.SingletonEnumerable(span), workspace, options, rules: null, cancellationToken: cancellationToken);
 
+        internal static SyntaxNode Format(SyntaxNode node, TextSpan span, HostWorkspaceServices services, SyntaxFormattingOptions options, CancellationToken cancellationToken)
+            => Format(node, SpecializedCollections.SingletonEnumerable(span), services, options, rules: null, cancellationToken: cancellationToken);
+
         /// <summary>
         /// Formats the whitespace in areas of a syntax tree identified by multiple non-overlapping spans.
         /// </summary>
@@ -225,13 +207,16 @@ public static SyntaxNode Format(SyntaxNode node, TextSpan span, Workspace worksp
         public static SyntaxNode Format(SyntaxNode node, IEnumerable<TextSpan>? spans, Workspace workspace, OptionSet? options = null, CancellationToken cancellationToken = default)
             => Format(node, spans, workspace, options, rules: null, cancellationToken: cancellationToken);
 
-        internal static SyntaxNode Format(SyntaxNode node, IEnumerable<TextSpan>? spans, Workspace workspace, OptionSet? options, IEnumerable<AbstractFormattingRule>? rules, CancellationToken cancellationToken)
+        private static SyntaxNode Format(SyntaxNode node, IEnumerable<TextSpan>? spans, Workspace workspace, OptionSet? options, IEnumerable<AbstractFormattingRule>? rules, CancellationToken cancellationToken)
         {
             var formattingResult = GetFormattingResult(node, spans, workspace, options, rules, cancellationToken);
             return formattingResult == null ? node : formattingResult.GetFormattedRoot(cancellationToken);
         }
 
-        internal static IFormattingResult? GetFormattingResult(SyntaxNode node, IEnumerable<TextSpan>? spans, Workspace workspace, OptionSet? options, IEnumerable<AbstractFormattingRule>? rules, CancellationToken cancellationToken)
+        internal static SyntaxNode Format(SyntaxNode node, IEnumerable<TextSpan>? spans, HostWorkspaceServices services, SyntaxFormattingOptions options, IEnumerable<AbstractFormattingRule>? rules, CancellationToken cancellationToken)
+            => GetFormattingResult(node, spans, services, options, rules, cancellationToken).GetFormattedRoot(cancellationToken);
+
+        private static IFormattingResult? GetFormattingResult(SyntaxNode node, IEnumerable<TextSpan>? spans, Workspace workspace, OptionSet? options, IEnumerable<AbstractFormattingRule>? rules, CancellationToken cancellationToken)
         {
             if (workspace == null)
             {
@@ -249,13 +234,16 @@ internal static SyntaxNode Format(SyntaxNode node, IEnumerable<TextSpan>? spans,
                 return null;
             }
 
-            var optionService = workspace.Services.GetRequiredService<IOptionService>();
-
             options ??= workspace.Options;
-            rules ??= GetDefaultFormattingRules(workspace, node.Language);
             spans ??= SpecializedCollections.SingletonEnumerable(node.FullSpan);
-            var shouldUseFormattingSpanCollapse = options.GetOption(FormattingBehaviorOptions.AllowDisjointSpanMerging);
-            return languageFormatter.Format(node, spans, shouldUseFormattingSpanCollapse, options.AsAnalyzerConfigOptions(optionService, node.Language), rules, cancellationToken);
+            var formattingOptions = SyntaxFormattingOptions.Create(options, workspace.Services, node.Language);
+            return languageFormatter.GetFormattingResult(node, spans, formattingOptions, rules, cancellationToken);
+        }
+
+        internal static IFormattingResult GetFormattingResult(SyntaxNode node, IEnumerable<TextSpan>? spans, HostWorkspaceServices services, SyntaxFormattingOptions options, IEnumerable<AbstractFormattingRule>? rules, CancellationToken cancellationToken)
+        {
+            var formatter = services.GetRequiredLanguageService<ISyntaxFormattingService>(node.Language);
+            return formatter.GetFormattingResult(node, spans, options, rules, cancellationToken);
         }
 
         /// <summary>
@@ -269,6 +257,9 @@ internal static SyntaxNode Format(SyntaxNode node, IEnumerable<TextSpan>? spans,
         public static IList<TextChange> GetFormattedTextChanges(SyntaxNode node, Workspace workspace, OptionSet? options = null, CancellationToken cancellationToken = default)
             => GetFormattedTextChanges(node, SpecializedCollections.SingletonEnumerable(node.FullSpan), workspace, options, rules: null, cancellationToken: cancellationToken);
 
+        internal static IList<TextChange> GetFormattedTextChanges(SyntaxNode node, HostWorkspaceServices services, SyntaxFormattingOptions options, CancellationToken cancellationToken)
+            => GetFormattedTextChanges(node, SpecializedCollections.SingletonEnumerable(node.FullSpan), services, options, rules: null, cancellationToken: cancellationToken);
+
         /// <summary>
         /// Determines the changes necessary to format the whitespace of a syntax tree.
         /// </summary>
@@ -279,7 +270,10 @@ public static IList<TextChange> GetFormattedTextChanges(SyntaxNode node, Workspa
         /// <param name="cancellationToken">An optional cancellation token.</param>
         /// <returns>The changes necessary to format the tree.</returns>
         public static IList<TextChange> GetFormattedTextChanges(SyntaxNode node, TextSpan span, Workspace workspace, OptionSet? options = null, CancellationToken cancellationToken = default)
-            => GetFormattedTextChanges(node, SpecializedCollections.SingletonEnumerable(span), workspace, options, rules: null, cancellationToken: cancellationToken);
+            => GetFormattedTextChanges(node, SpecializedCollections.SingletonEnumerable(span), workspace, options, rules: null, cancellationToken);
+
+        internal static IList<TextChange> GetFormattedTextChanges(SyntaxNode node, TextSpan span, HostWorkspaceServices services, SyntaxFormattingOptions options, CancellationToken cancellationToken = default)
+            => GetFormattedTextChanges(node, SpecializedCollections.SingletonEnumerable(span), services, options, rules: null, cancellationToken);
 
         /// <summary>
         /// Determines the changes necessary to format the whitespace of a syntax tree.
@@ -291,9 +285,12 @@ public static IList<TextChange> GetFormattedTextChanges(SyntaxNode node, TextSpa
         /// <param name="cancellationToken">An optional cancellation token.</param>
         /// <returns>The changes necessary to format the tree.</returns>
         public static IList<TextChange> GetFormattedTextChanges(SyntaxNode node, IEnumerable<TextSpan>? spans, Workspace workspace, OptionSet? options = null, CancellationToken cancellationToken = default)
-            => GetFormattedTextChanges(node, spans, workspace, options, rules: null, cancellationToken: cancellationToken);
+            => GetFormattedTextChanges(node, spans, workspace, options, rules: null, cancellationToken);
+
+        internal static IList<TextChange> GetFormattedTextChanges(SyntaxNode node, IEnumerable<TextSpan>? spans, HostWorkspaceServices services, SyntaxFormattingOptions options, CancellationToken cancellationToken = default)
+            => GetFormattedTextChanges(node, spans, services, options, rules: null, cancellationToken);
 
-        internal static IList<TextChange> GetFormattedTextChanges(SyntaxNode node, IEnumerable<TextSpan>? spans, Workspace workspace, OptionSet? options, IEnumerable<AbstractFormattingRule>? rules, CancellationToken cancellationToken)
+        private static IList<TextChange> GetFormattedTextChanges(SyntaxNode node, IEnumerable<TextSpan>? spans, Workspace workspace, OptionSet? options, IEnumerable<AbstractFormattingRule>? rules, CancellationToken cancellationToken)
         {
             var formattingResult = GetFormattingResult(node, spans, workspace, options, rules, cancellationToken);
             return formattingResult == null
@@ -301,6 +298,12 @@ internal static IList<TextChange> GetFormattedTextChanges(SyntaxNode node, IEnum
                 : formattingResult.GetTextChanges(cancellationToken);
         }
 
+        internal static IList<TextChange> GetFormattedTextChanges(SyntaxNode node, IEnumerable<TextSpan>? spans, HostWorkspaceServices services, SyntaxFormattingOptions options, IEnumerable<AbstractFormattingRule>? rules, CancellationToken cancellationToken = default)
+        {
+            var formatter = services.GetRequiredLanguageService<ISyntaxFormattingService>(node.Language);
+            return formatter.GetFormattingResult(node, spans, options, rules, cancellationToken).GetTextChanges(cancellationToken);
+        }
+
         /// <summary>
         /// Organizes the imports in the document.
         /// </summary>
diff --git a/src/Workspaces/Core/Portable/Formatting/FormattingBehaviorOptions.cs b/src/Workspaces/Core/Portable/Formatting/FormattingBehaviorOptions.cs
index 3c9cdbd7e6f52..6a9b67da7346f 100644
--- a/src/Workspaces/Core/Portable/Formatting/FormattingBehaviorOptions.cs
+++ b/src/Workspaces/Core/Portable/Formatting/FormattingBehaviorOptions.cs
@@ -28,7 +28,6 @@ public Provider()
             public ImmutableArray<IOption> Options { get; } = ImmutableArray.Create<IOption>(
                 SmartIndent,
                 PreferredWrappingColumn,
-                AllowDisjointSpanMerging,
                 AutoFormattingOnReturn,
                 AutoFormattingOnTyping,
                 AutoFormattingOnSemicolon,
@@ -54,12 +53,6 @@ public Provider()
         internal static Option2<int> PreferredWrappingColumn { get; } =
             new(FeatureName, FormattingOptionGroups.NewLine, nameof(PreferredWrappingColumn), defaultValue: 120);
 
-        /// <summary>
-        /// TODO: Currently the option has no storage and always has its default value. 
-        /// </summary>
-        internal static Option2<bool> AllowDisjointSpanMerging { get; } =
-            new(FeatureName, OptionGroup.Default, nameof(AllowDisjointSpanMerging), defaultValue: false);
-
         internal static readonly PerLanguageOption2<bool> AutoFormattingOnReturn =
             new(FeatureName, OptionGroup.Default, nameof(AutoFormattingOnReturn), defaultValue: true,
             storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.Auto Formatting On Return"));
diff --git a/src/Workspaces/Core/Portable/Indentation/AbstractIndentationService.Indenter.cs b/src/Workspaces/Core/Portable/Indentation/AbstractIndentationService.Indenter.cs
index 796e7905ca082..86120f72eabc6 100644
--- a/src/Workspaces/Core/Portable/Indentation/AbstractIndentationService.Indenter.cs
+++ b/src/Workspaces/Core/Portable/Indentation/AbstractIndentationService.Indenter.cs
@@ -170,7 +170,7 @@ public bool TryGetSmartTokenIndentation(out IndentationResult indentationResult)
                     var sourceText = Tree.GetText(CancellationToken);
 
                     var formatter = _service.CreateSmartTokenFormatter(this);
-                    var changes = formatter.FormatTokenAsync(Document.Project.Solution.Workspace, token, CancellationToken)
+                    var changes = formatter.FormatTokenAsync(Document.Project.Solution.Workspace.Services, token, CancellationToken)
                                            .WaitAndGetResult_CanCallOnBackground(CancellationToken);
 
                     var updatedSourceText = sourceText.WithChanges(changes);
diff --git a/src/Workspaces/Core/Portable/Indentation/ISmartTokenFormatter.cs b/src/Workspaces/Core/Portable/Indentation/ISmartTokenFormatter.cs
index 1f350134b09ab..2cab6570ce4c6 100644
--- a/src/Workspaces/Core/Portable/Indentation/ISmartTokenFormatter.cs
+++ b/src/Workspaces/Core/Portable/Indentation/ISmartTokenFormatter.cs
@@ -5,12 +5,13 @@
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.CodeAnalysis.Indentation
 {
     internal interface ISmartTokenFormatter
     {
-        Task<IList<TextChange>> FormatTokenAsync(Workspace workspace, SyntaxToken token, CancellationToken cancellationToken);
+        Task<IList<TextChange>> FormatTokenAsync(HostWorkspaceServices services, SyntaxToken token, CancellationToken cancellationToken);
     }
 }
diff --git a/src/Workspaces/CoreTest/CodeCleanup/CodeCleanupTests.cs b/src/Workspaces/CoreTest/CodeCleanup/CodeCleanupTests.cs
index 3a2f06a71a284..0465307892c44 100644
--- a/src/Workspaces/CoreTest/CodeCleanup/CodeCleanupTests.cs
+++ b/src/Workspaces/CoreTest/CodeCleanup/CodeCleanupTests.cs
@@ -4,6 +4,7 @@
 
 #nullable disable
 
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
@@ -11,6 +12,8 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeCleanup;
 using Microsoft.CodeAnalysis.CodeCleanup.Providers;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Text;
@@ -168,15 +171,18 @@ public void EntireRange_EndOfFile()
         public void EntireRangeWithTransformation_RemoveClass()
         {
             var expectedResult = (IEnumerable<TextSpan>)null;
-            var transformer = new SimpleCodeCleanupProvider("TransformerCleanup", async (doc, spans, cancellationToken) =>
+            var transformer = new MockCodeCleanupProvider()
             {
-                var root = await doc.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-                root = root.RemoveCSharpMember(0);
+                CleanupDocumentAsyncImpl = async (document, spans, options, cancellationToken) =>
+                {
+                    var root = await document.GetSyntaxRootAsync(cancellationToken);
+                    root = root.RemoveCSharpMember(0);
 
-                expectedResult = SpecializedCollections.SingletonEnumerable(root.FullSpan);
+                    expectedResult = SpecializedCollections.SingletonEnumerable(root.FullSpan);
 
-                return doc.WithSyntaxRoot(root);
-            });
+                    return document.WithSyntaxRoot(root);
+                }
+            };
 
             VerifyRange("{|b:class C {}|}", transformer, ref expectedResult);
         }
@@ -185,17 +191,20 @@ public void EntireRangeWithTransformation_RemoveClass()
         public void EntireRangeWithTransformation_AddMember()
         {
             var expectedResult = (IEnumerable<TextSpan>)null;
-            var transformer = new SimpleCodeCleanupProvider("TransformerCleanup", async (doc, spans, cancellationToken) =>
+            var transformer = new MockCodeCleanupProvider()
             {
-                var root = await doc.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-                var @class = root.GetMember(0);
-                var classWithMember = @class.AddCSharpMember(CreateCSharpMethod(), 0);
-                root = root.ReplaceNode(@class, classWithMember);
+                CleanupDocumentAsyncImpl = async (document, spans, options, cancellationToken) =>
+                {
+                    var root = await document.GetSyntaxRootAsync(cancellationToken);
+                    var @class = root.GetMember(0);
+                    var classWithMember = @class.AddCSharpMember(CreateCSharpMethod(), 0);
+                    root = root.ReplaceNode(@class, classWithMember);
 
-                expectedResult = SpecializedCollections.SingletonEnumerable(root.FullSpan);
+                    expectedResult = SpecializedCollections.SingletonEnumerable(root.FullSpan);
 
-                return doc.WithSyntaxRoot(root);
-            });
+                    return document.WithSyntaxRoot(root);
+                }
+            };
 
             VerifyRange("{|b:class C {}|}", transformer, ref expectedResult);
         }
@@ -204,17 +213,20 @@ public void EntireRangeWithTransformation_AddMember()
         public void RangeWithTransformation_AddMember()
         {
             var expectedResult = (IEnumerable<TextSpan>)null;
-            var transformer = new SimpleCodeCleanupProvider("TransformerCleanup", async (doc, spans, cancellationToken) =>
+            var transformer = new MockCodeCleanupProvider()
             {
-                var root = await doc.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-                var @class = root.GetMember(0).GetMember(0);
-                var classWithMember = @class.AddCSharpMember(CreateCSharpMethod(), 0);
-                root = root.ReplaceNode(@class, classWithMember);
+                CleanupDocumentAsyncImpl = async (document, spans, options, cancellationToken) =>
+                {
+                    var root = await document.GetSyntaxRootAsync(cancellationToken);
+                    var @class = root.GetMember(0).GetMember(0);
+                    var classWithMember = @class.AddCSharpMember(CreateCSharpMethod(), 0);
+                    root = root.ReplaceNode(@class, classWithMember);
 
-                expectedResult = SpecializedCollections.SingletonEnumerable(root.GetMember(0).GetMember(0).GetCodeCleanupSpan());
+                    expectedResult = SpecializedCollections.SingletonEnumerable(root.GetMember(0).GetMember(0).GetCodeCleanupSpan());
 
-                return doc.WithSyntaxRoot(root);
-            });
+                    return document.WithSyntaxRoot(root);
+                }
+            };
 
             VerifyRange("namespace N { {|b:class C {}|} }", transformer, ref expectedResult);
         }
@@ -223,17 +235,20 @@ public void RangeWithTransformation_AddMember()
         public void RangeWithTransformation_RemoveMember()
         {
             var expectedResult = (IEnumerable<TextSpan>)null;
-            var transformer = new SimpleCodeCleanupProvider("TransformerCleanup", async (doc, spans, cancellationToken) =>
+            var transformer = new MockCodeCleanupProvider()
             {
-                var root = await doc.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-                var @class = root.GetMember(0).GetMember(0);
-                var classWithMember = @class.RemoveCSharpMember(0);
-                root = root.ReplaceNode(@class, classWithMember);
+                CleanupDocumentAsyncImpl = async (document, spans, options, cancellationToken) =>
+                {
+                    var root = await document.GetSyntaxRootAsync(cancellationToken);
+                    var @class = root.GetMember(0).GetMember(0);
+                    var classWithMember = @class.RemoveCSharpMember(0);
+                    root = root.ReplaceNode(@class, classWithMember);
 
-                expectedResult = SpecializedCollections.SingletonEnumerable(root.GetMember(0).GetMember(0).GetCodeCleanupSpan());
+                    expectedResult = SpecializedCollections.SingletonEnumerable(root.GetMember(0).GetMember(0).GetCodeCleanupSpan());
 
-                return doc.WithSyntaxRoot(root);
-            });
+                    return document.WithSyntaxRoot(root);
+                }
+            };
 
             VerifyRange("namespace N { {|b:class C { void Method() { } }|} }", transformer, ref expectedResult);
         }
@@ -335,20 +350,23 @@ End Sub
         public void RangeWithTransformation_OutsideOfRange()
         {
             var expectedResult = (IEnumerable<TextSpan>)null;
-            var transformer = new SimpleCodeCleanupProvider("TransformerCleanup", async (doc, spans, cancellationToken) =>
+            var transformer = new MockCodeCleanupProvider()
             {
-                var root = await doc.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-                var member = root.GetMember(0).GetMember(0).GetMember(0);
-                var previousToken = member.GetFirstToken().GetPreviousToken().GetPreviousToken();
-                var nextToken = member.GetLastToken().GetNextToken().GetNextToken();
+                CleanupDocumentAsyncImpl = async (document, spans, options, cancellationToken) =>
+                {
+                    var root = await document.GetSyntaxRootAsync(cancellationToken);
+                    var member = root.GetMember(0).GetMember(0).GetMember(0);
+                    var previousToken = member.GetFirstToken().GetPreviousToken().GetPreviousToken();
+                    var nextToken = member.GetLastToken().GetNextToken().GetNextToken();
 
-                root = root.ReplaceToken(previousToken, CSharp.SyntaxFactory.Identifier(previousToken.LeadingTrivia, previousToken.ValueText, previousToken.TrailingTrivia));
-                root = root.ReplaceToken(nextToken, CSharp.SyntaxFactory.Token(nextToken.LeadingTrivia, CSharp.CSharpExtensions.Kind(nextToken), nextToken.TrailingTrivia));
+                    root = root.ReplaceToken(previousToken, CSharp.SyntaxFactory.Identifier(previousToken.LeadingTrivia, previousToken.ValueText, previousToken.TrailingTrivia));
+                    root = root.ReplaceToken(nextToken, CSharp.SyntaxFactory.Token(nextToken.LeadingTrivia, CSharp.CSharpExtensions.Kind(nextToken), nextToken.TrailingTrivia));
 
-                expectedResult = SpecializedCollections.EmptyEnumerable<TextSpan>();
+                    expectedResult = SpecializedCollections.EmptyEnumerable<TextSpan>();
 
-                return doc.WithSyntaxRoot(root);
-            });
+                    return document.WithSyntaxRoot(root);
+                }
+            };
 
             VerifyRange("namespace N { class C { {|b:void Method() { }|} } }", transformer, ref expectedResult);
         }
@@ -377,11 +395,14 @@ private static void VerifyRange(string codeWithMarker, ICodeCleanupProvider tran
         private static void VerifyRange(string code, ImmutableArray<ICodeCleanupProvider> codeCleanups, ImmutableArray<TextSpan> spans, ref IEnumerable<TextSpan> expectedResult, string language)
         {
             var result = (IEnumerable<TextSpan>)null;
-            var spanCodeCleanup = new SimpleCodeCleanupProvider("TestCodeCleanup", (d, s, c) =>
+            var spanCodeCleanup = new MockCodeCleanupProvider()
             {
-                result = s;
-                return Task.FromResult(d);
-            });
+                CleanupDocumentAsyncImpl = (document, spans, options, cancellationToken) =>
+                {
+                    result = spans;
+                    return Task.FromResult(document);
+                }
+            };
 
             var document = CreateDocument(code, language);
 
diff --git a/src/Workspaces/CoreTest/CodeCleanup/MockCodeCleanupProvider.cs b/src/Workspaces/CoreTest/CodeCleanup/MockCodeCleanupProvider.cs
new file mode 100644
index 0000000000000..15195e451f58d
--- /dev/null
+++ b/src/Workspaces/CoreTest/CodeCleanup/MockCodeCleanupProvider.cs
@@ -0,0 +1,34 @@
+// 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.Immutable;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeCleanup.Providers;
+using Microsoft.CodeAnalysis.Formatting;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.UnitTests.CodeCleanup
+{
+    internal sealed class MockCodeCleanupProvider : ICodeCleanupProvider
+    {
+        public Func<Document, ImmutableArray<TextSpan>, SyntaxFormattingOptions, CancellationToken, Task<Document>>? CleanupDocumentAsyncImpl { get; set; }
+        public Func<SyntaxNode, ImmutableArray<TextSpan>, SyntaxFormattingOptions, HostWorkspaceServices, SyntaxNode>? CleanupNodeImpl { get; set; }
+
+        public MockCodeCleanupProvider()
+        {
+        }
+
+        public string Name => nameof(MockCodeCleanupProvider);
+
+        public Task<Document> CleanupAsync(Document document, ImmutableArray<TextSpan> spans, SyntaxFormattingOptions options, CancellationToken cancellationToken)
+            => (CleanupDocumentAsyncImpl ?? throw new NotImplementedException()).Invoke(document, spans, options, cancellationToken);
+
+        public Task<SyntaxNode> CleanupAsync(SyntaxNode root, ImmutableArray<TextSpan> spans, SyntaxFormattingOptions options, HostWorkspaceServices services, CancellationToken cancellationToken)
+            => Task.FromResult((CleanupNodeImpl ?? throw new NotImplementedException()).Invoke(root, spans, options, services));
+    }
+}
diff --git a/src/Workspaces/CoreTest/Editing/SyntaxEditorTests.cs b/src/Workspaces/CoreTest/Editing/SyntaxEditorTests.cs
index 0f5ff6ab4be6c..a316c6c451988 100644
--- a/src/Workspaces/CoreTest/Editing/SyntaxEditorTests.cs
+++ b/src/Workspaces/CoreTest/Editing/SyntaxEditorTests.cs
@@ -6,7 +6,9 @@
 
 using System;
 using System.Linq;
+using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Test.Utilities;
@@ -25,7 +27,9 @@ private Workspace EmptyWorkspace
         private void VerifySyntax<TSyntax>(SyntaxNode node, string expectedText) where TSyntax : SyntaxNode
         {
             Assert.IsAssignableFrom<TSyntax>(node);
-            var formatted = Formatter.Format(node, EmptyWorkspace);
+
+            var options = SyntaxFormattingOptions.Default;
+            var formatted = Formatter.Format(node, EmptyWorkspace.Services, options, CancellationToken.None);
             var actualText = formatted.ToFullString();
             Assert.Equal(expectedText, actualText);
         }
diff --git a/src/Workspaces/CoreTest/FormattingTests.cs b/src/Workspaces/CoreTest/FormattingTests.cs
index 998368664ed42..ff56861851559 100644
--- a/src/Workspaces/CoreTest/FormattingTests.cs
+++ b/src/Workspaces/CoreTest/FormattingTests.cs
@@ -4,6 +4,8 @@
 
 #nullable disable
 
+using System.Threading;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Roslyn.Test.Utilities;
@@ -28,7 +30,10 @@ public void TestCSharpFormatting()
         [Fact, Trait(Traits.Feature, Traits.Features.Formatting)]
         public void TestCSharpDefaultRules()
         {
-            var rules = Formatter.GetDefaultFormattingRules(new AdhocWorkspace(), LanguageNames.CSharp);
+            using var workspace = new AdhocWorkspace();
+
+            var service = workspace.Services.GetLanguageServices(LanguageNames.CSharp).GetService<ISyntaxFormattingService>();
+            var rules = service.GetDefaultFormattingRules();
 
             Assert.NotNull(rules);
             Assert.NotEmpty(rules);
@@ -54,7 +59,9 @@ End Class
         [Fact, Trait(Traits.Feature, Traits.Features.Formatting)]
         public void TestVisualBasicDefaultFormattingRules()
         {
-            var rules = Formatter.GetDefaultFormattingRules(new AdhocWorkspace(), LanguageNames.VisualBasic);
+            using var workspace = new AdhocWorkspace();
+            var service = workspace.Services.GetLanguageServices(LanguageNames.VisualBasic).GetService<ISyntaxFormattingService>();
+            var rules = service.GetDefaultFormattingRules();
 
             Assert.NotNull(rules);
             Assert.NotEmpty(rules);
@@ -75,7 +82,9 @@ private static void AssertFormatVB(string expected, string input)
         private static void AssertFormat(string expected, SyntaxTree tree)
         {
             using var workspace = new AdhocWorkspace();
-            var formattedRoot = Formatter.Format(tree.GetRoot(), workspace);
+
+            var options = SyntaxFormattingOptions.Default;
+            var formattedRoot = Formatter.Format(tree.GetRoot(), workspace.Services, options, CancellationToken.None);
             var actualFormattedText = formattedRoot.ToFullString();
 
             Assert.Equal(expected, actualFormattedText);
diff --git a/src/Workspaces/CoreTestUtilities/Formatting/FormattingTestBase.cs b/src/Workspaces/CoreTestUtilities/Formatting/FormattingTestBase.cs
index adf07b02d6f06..8d7d718b351a7 100644
--- a/src/Workspaces/CoreTestUtilities/Formatting/FormattingTestBase.cs
+++ b/src/Workspaces/CoreTestUtilities/Formatting/FormattingTestBase.cs
@@ -7,6 +7,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
 using Microsoft.CodeAnalysis.Formatting;
+using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Test.Utilities;
@@ -54,29 +55,31 @@ private protected async Task AssertFormatAsync(
 
                 var syntaxTree = await document.GetRequiredSyntaxTreeAsync(CancellationToken.None);
 
-                var options = workspace.Options;
+                var optionSet = workspace.Options;
                 if (changedOptionSet != null)
                 {
                     foreach (var entry in changedOptionSet)
                     {
-                        options = options.WithChangedOption(entry.Key, entry.Value);
+                        optionSet = optionSet.WithChangedOption(entry.Key, entry.Value);
                     }
                 }
 
                 var root = await syntaxTree.GetRootAsync();
-                AssertFormat(workspace, expected, root, spans, options, await document.GetTextAsync());
+                var options = SyntaxFormattingOptions.Create(optionSet, workspace.Services, root.Language);
+
+                AssertFormat(workspace.Services, expected, root, spans, options, await document.GetTextAsync());
 
                 // format with node and transform
-                AssertFormatWithTransformation(workspace, expected, root, spans, options, treeCompare, parseOptions);
+                AssertFormatWithTransformation(workspace.Services, expected, root, spans, options, treeCompare, parseOptions);
             }
         }
 
         protected abstract SyntaxNode ParseCompilation(string text, ParseOptions? parseOptions);
 
-        protected void AssertFormatWithTransformation(
-            Workspace workspace, string expected, SyntaxNode root, IEnumerable<TextSpan> spans, OptionSet optionSet, bool treeCompare = true, ParseOptions? parseOptions = null)
+        internal void AssertFormatWithTransformation(
+            HostWorkspaceServices services, string expected, SyntaxNode root, IEnumerable<TextSpan> spans, SyntaxFormattingOptions options, bool treeCompare = true, ParseOptions? parseOptions = null)
         {
-            var newRootNode = Formatter.Format(root, spans, workspace, optionSet, CancellationToken.None);
+            var newRootNode = Formatter.Format(root, spans, services, options, rules: null, CancellationToken.None);
 
             Assert.Equal(expected, newRootNode.ToFullString());
 
@@ -90,9 +93,9 @@ protected void AssertFormatWithTransformation(
             }
         }
 
-        protected static void AssertFormat(Workspace workspace, string expected, SyntaxNode root, IEnumerable<TextSpan> spans, OptionSet optionSet, SourceText sourceText)
+        internal static void AssertFormat(HostWorkspaceServices services, string expected, SyntaxNode root, IEnumerable<TextSpan> spans, SyntaxFormattingOptions options, SourceText sourceText)
         {
-            var result = Formatter.GetFormattedTextChanges(root, spans, workspace, optionSet);
+            var result = Formatter.GetFormattedTextChanges(root, spans, services, options);
             AssertResult(expected, sourceText, result);
         }
 
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/AbstractSyntaxFormattingService.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/AbstractSyntaxFormattingService.cs
index 922481ecaf0ae..d1de744dc12a7 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/AbstractSyntaxFormattingService.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/AbstractSyntaxFormattingService.cs
@@ -19,7 +19,6 @@ namespace Microsoft.CodeAnalysis.Formatting
     internal abstract class AbstractSyntaxFormattingService : ISyntaxFormattingService
     {
         private static readonly Func<TextSpan, bool> s_notEmpty = s => !s.IsEmpty;
-        private static readonly Func<TextSpan, int> s_spanLength = s => s.Length;
 
         protected AbstractSyntaxFormattingService()
         {
@@ -31,55 +30,38 @@ protected AbstractSyntaxFormattingService()
 
         protected abstract AbstractFormattingResult Format(SyntaxNode node, AnalyzerConfigOptions options, IEnumerable<AbstractFormattingRule> rules, SyntaxToken token1, SyntaxToken token2, CancellationToken cancellationToken);
 
-        public IFormattingResult Format(SyntaxNode node, IEnumerable<TextSpan> spans, bool shouldUseFormattingSpanCollapse, AnalyzerConfigOptions options, IEnumerable<AbstractFormattingRule> rules, CancellationToken cancellationToken)
+        public IFormattingResult GetFormattingResult(SyntaxNode node, IEnumerable<TextSpan>? spans, SyntaxFormattingOptions options, IEnumerable<AbstractFormattingRule>? rules, CancellationToken cancellationToken)
         {
-            CheckArguments(node, spans, options, rules);
+            IReadOnlyList<TextSpan> spansToFormat;
 
-            // quick exit check
-            var spansToFormat = new NormalizedTextSpanCollection(spans.Where(s_notEmpty));
-            if (spansToFormat.Count == 0)
+            if (spans == null)
             {
-                return CreateAggregatedFormattingResult(node, SpecializedCollections.EmptyList<AbstractFormattingResult>());
+                spansToFormat = node.FullSpan.IsEmpty ?
+                    SpecializedCollections.EmptyReadOnlyList<TextSpan>() :
+                    SpecializedCollections.SingletonReadOnlyList(node.FullSpan);
             }
-
-            // check what kind of formatting strategy to use
-            if (AllowDisjointSpanMerging(spansToFormat, shouldUseFormattingSpanCollapse))
+            else
             {
-                return FormatMergedSpan(node, options, rules, spansToFormat, cancellationToken);
+                spansToFormat = new NormalizedTextSpanCollection(spans.Where(s_notEmpty));
             }
 
-            return FormatIndividually(node, options, rules, spansToFormat, cancellationToken);
-        }
-
-        private IFormattingResult FormatMergedSpan(
-            SyntaxNode node, AnalyzerConfigOptions options, IEnumerable<AbstractFormattingRule> rules, IList<TextSpan> spansToFormat, CancellationToken cancellationToken)
-        {
-            var spanToFormat = TextSpan.FromBounds(spansToFormat[0].Start, spansToFormat[spansToFormat.Count - 1].End);
-            var pair = node.ConvertToTokenPair(spanToFormat);
-
-            if (node.IsInvalidTokenRange(pair.Item1, pair.Item2))
+            if (spansToFormat.Count == 0)
             {
                 return CreateAggregatedFormattingResult(node, SpecializedCollections.EmptyList<AbstractFormattingResult>());
             }
 
-            // more expensive case
-            var result = Format(node, options, rules, pair.Item1, pair.Item2, cancellationToken);
-            return CreateAggregatedFormattingResult(node, new List<AbstractFormattingResult>(1) { result }, SimpleIntervalTree.Create(new TextSpanIntervalIntrospector(), spanToFormat));
-        }
+            rules ??= GetDefaultFormattingRules();
 
-        private IFormattingResult FormatIndividually(
-            SyntaxNode node, AnalyzerConfigOptions options, IEnumerable<AbstractFormattingRule> rules, IList<TextSpan> spansToFormat, CancellationToken cancellationToken)
-        {
             List<AbstractFormattingResult>? results = null;
-            foreach (var pair in node.ConvertToTokenPairs(spansToFormat))
+            foreach (var (startToken, endToken) in node.ConvertToTokenPairs(spansToFormat))
             {
-                if (node.IsInvalidTokenRange(pair.Item1, pair.Item2))
+                if (node.IsInvalidTokenRange(startToken, endToken))
                 {
                     continue;
                 }
 
                 results ??= new List<AbstractFormattingResult>();
-                results.Add(Format(node, options, rules, pair.Item1, pair.Item2, cancellationToken));
+                results.Add(Format(node, options.Options, rules, startToken, endToken, cancellationToken));
             }
 
             // quick simple case check
@@ -96,61 +78,5 @@ private IFormattingResult FormatIndividually(
             // more expensive case
             return CreateAggregatedFormattingResult(node, results);
         }
-
-        private static bool AllowDisjointSpanMerging(IList<TextSpan> list, bool shouldUseFormattingSpanCollapse)
-        {
-            // If the user is specific about the formatting specific spans then honor users settings
-            if (!shouldUseFormattingSpanCollapse)
-            {
-                return false;
-            }
-
-            // most common case. it is either just formatting a whole file, a selection or some generate XXX refactoring.
-            if (list.Count <= 3)
-            {
-                // don't collapse formatting spans
-                return false;
-            }
-
-            // too many formatting spans, just collapse them and format at once
-            if (list.Count > 30)
-            {
-                // figuring out base indentation at random place in a file takes about 2ms.
-                // doing 30 times will make it cost about 60ms. that is about same cost, for the same file, engine will
-                // take to create full formatting context. basically after that, creating full context is cheaper than
-                // doing bottom up base indentation calculation for each span.
-                return true;
-            }
-
-            // check how much area we are formatting
-            var formattingSpan = TextSpan.FromBounds(list[0].Start, list[list.Count - 1].End);
-            var actualFormattingSize = list.Sum(s_spanLength);
-
-            // we are formatting more than half of the collapsed span.
-            return (formattingSpan.Length / Math.Max(actualFormattingSize, 1)) < 2;
-        }
-
-        private static void CheckArguments(SyntaxNode node, IEnumerable<TextSpan> spans, AnalyzerConfigOptions options, IEnumerable<AbstractFormattingRule> rules)
-        {
-            if (node == null)
-            {
-                throw new ArgumentNullException(nameof(node));
-            }
-
-            if (spans == null)
-            {
-                throw new ArgumentNullException(nameof(spans));
-            }
-
-            if (options == null)
-            {
-                throw new ArgumentNullException(nameof(options));
-            }
-
-            if (rules == null)
-            {
-                throw new ArgumentNullException(nameof(rules));
-            }
-        }
     }
 }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/FormattingExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/FormattingExtensions.cs
index e7c049d8defec..3308e64ece2da 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/FormattingExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/FormattingExtensions.cs
@@ -284,11 +284,22 @@ public static TextChange SimpleDiff(this TextChange textChange, string text)
 
         internal static IEnumerable<TextSpan> GetAnnotatedSpans(SyntaxNode node, SyntaxAnnotation annotation)
         {
-            foreach (var nodeOrToken in node.GetAnnotatedNodesAndTokens(annotation))
+            if (annotation == SyntaxAnnotation.ElasticAnnotation)
             {
-                var firstToken = nodeOrToken.IsNode ? nodeOrToken.AsNode()!.GetFirstToken(includeZeroWidth: true) : nodeOrToken.AsToken();
-                var lastToken = nodeOrToken.IsNode ? nodeOrToken.AsNode()!.GetLastToken(includeZeroWidth: true) : nodeOrToken.AsToken();
-                yield return GetSpan(firstToken, lastToken);
+                var tokens = node.GetAnnotatedTrivia(SyntaxAnnotation.ElasticAnnotation).Select(tr => tr.Token).Distinct();
+                return AggregateSpans(tokens.Select(t => GetElasticSpan(t)));
+            }
+
+            return EnumerateAnnotatedSpans(node, annotation);
+
+            static IEnumerable<TextSpan> EnumerateAnnotatedSpans(SyntaxNode node, SyntaxAnnotation annotation)
+            {
+                foreach (var nodeOrToken in node.GetAnnotatedNodesAndTokens(annotation))
+                {
+                    var firstToken = nodeOrToken.IsNode ? nodeOrToken.AsNode()!.GetFirstToken(includeZeroWidth: true) : nodeOrToken.AsToken();
+                    var lastToken = nodeOrToken.IsNode ? nodeOrToken.AsNode()!.GetLastToken(includeZeroWidth: true) : nodeOrToken.AsToken();
+                    yield return GetSpan(firstToken, lastToken);
+                }
             }
         }
 
@@ -310,12 +321,6 @@ internal static TextSpan GetSpan(SyntaxToken firstToken, SyntaxToken lastToken)
             return TextSpan.FromBounds(firstToken.SpanStart, lastToken.Span.End);
         }
 
-        internal static IEnumerable<TextSpan> GetElasticSpans(SyntaxNode root)
-        {
-            var tokens = root.GetAnnotatedTrivia(SyntaxAnnotation.ElasticAnnotation).Select(tr => tr.Token).Distinct();
-            return AggregateSpans(tokens.Select(t => GetElasticSpan(t)));
-        }
-
         internal static TextSpan GetElasticSpan(SyntaxToken token)
             => GetSpan(token, token);
 
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/ISyntaxFormattingService.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/ISyntaxFormattingService.cs
index 48df77ac2c2cd..9ee260b539894 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/ISyntaxFormattingService.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/ISyntaxFormattingService.cs
@@ -4,11 +4,14 @@
 
 using System.Collections.Generic;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Formatting.Rules;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 
 #if !CODE_STYLE
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Host;
 #endif
 
@@ -20,6 +23,26 @@ internal interface ISyntaxFormattingService
 #endif
     {
         IEnumerable<AbstractFormattingRule> GetDefaultFormattingRules();
-        IFormattingResult Format(SyntaxNode node, IEnumerable<TextSpan> spans, bool shouldUseFormattingSpanCollapse, AnalyzerConfigOptions options, IEnumerable<AbstractFormattingRule> rules, CancellationToken cancellationToken);
+        IFormattingResult GetFormattingResult(SyntaxNode node, IEnumerable<TextSpan>? spans, SyntaxFormattingOptions options, IEnumerable<AbstractFormattingRule>? rules, CancellationToken cancellationToken);
+    }
+
+    internal readonly record struct SyntaxFormattingOptions(
+        AnalyzerConfigOptions Options)
+    {
+        public static readonly SyntaxFormattingOptions Default = Create(DictionaryAnalyzerConfigOptions.Empty);
+
+        public static SyntaxFormattingOptions Create(AnalyzerConfigOptions options)
+            => new(options);
+
+#if !CODE_STYLE
+        public static SyntaxFormattingOptions Create(OptionSet options, HostWorkspaceServices services, string language)
+            => new(options.AsAnalyzerConfigOptions(services.GetRequiredService<IOptionService>(), language));
+
+        public static async Task<SyntaxFormattingOptions> FromDocumentAsync(Document document, CancellationToken cancellationToken)
+        {
+            var documentOptions = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
+            return Create(documentOptions, document.Project.Solution.Workspace.Services, document.Project.Language);
+        }
+#endif
     }
 }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/CommonFormattingHelpers.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/CommonFormattingHelpers.cs
index afe5e11504038..54ae88b5b443a 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/CommonFormattingHelpers.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/CommonFormattingHelpers.cs
@@ -39,7 +39,7 @@ internal static class CommonFormattingHelpers
             return 0;
         };
 
-        public static IEnumerable<ValueTuple<SyntaxToken, SyntaxToken>> ConvertToTokenPairs(this SyntaxNode root, IList<TextSpan> spans)
+        public static IEnumerable<(SyntaxToken, SyntaxToken)> ConvertToTokenPairs(this SyntaxNode root, IReadOnlyList<TextSpan> spans)
         {
             Contract.ThrowIfNull(root);
             Contract.ThrowIfFalse(spans.Count > 0);
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpRemoveUnnecessaryImportsService.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpRemoveUnnecessaryImportsService.cs
index 3a9ac27d3fa8e..eba472f45ddea 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpRemoveUnnecessaryImportsService.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpRemoveUnnecessaryImportsService.cs
@@ -9,7 +9,9 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.Formatting;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Internal.Log;
@@ -18,6 +20,12 @@
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
+#if CODE_STYLE
+using Formatter = Microsoft.CodeAnalysis.Formatting.FormatterHelper;
+#else
+using Formatter = Microsoft.CodeAnalysis.Formatting.Formatter;
+#endif
+
 namespace Microsoft.CodeAnalysis.CSharp.RemoveUnnecessaryImports
 {
     [ExportLanguageService(typeof(IRemoveUnnecessaryImportsService), LanguageNames.CSharp), Shared]
@@ -30,6 +38,11 @@ public CSharpRemoveUnnecessaryImportsService()
         {
         }
 
+#if CODE_STYLE
+        private static ISyntaxFormattingService GetSyntaxFormattingService()
+            => CSharpSyntaxFormattingService.Instance;
+#endif
+
         protected override IUnnecessaryImportsProvider UnnecessaryImportsProvider
             => CSharpUnnecessaryImportsProvider.Instance;
 
@@ -54,16 +67,20 @@ public override async Task<Document> RemoveUnnecessaryImportsAsync(
                 var newRoot = (CompilationUnitSyntax)new Rewriter(document, unnecessaryImports, cancellationToken).Visit(oldRoot);
 
                 cancellationToken.ThrowIfCancellationRequested();
-                return document.WithSyntaxRoot(await FormatResultAsync(document, newRoot, cancellationToken).ConfigureAwait(false));
-            }
-        }
+#if CODE_STYLE
+                var provider = GetSyntaxFormattingService();
+                var optionSet = document.Project.AnalyzerOptions.AnalyzerConfigOptionsProvider.GetOptions(oldRoot.SyntaxTree);
+                var options = SyntaxFormattingOptions.Create(optionSet);
+#else
+                var provider = document.Project.Solution.Workspace.Services;
+                var options = await SyntaxFormattingOptions.FromDocumentAsync(document, cancellationToken).ConfigureAwait(false);
+#endif
+                var spans = new List<TextSpan>();
+                AddFormattingSpans(newRoot, spans, cancellationToken);
+                var formattedRoot = Formatter.Format(newRoot, spans, provider, options, rules: null, cancellationToken);
 
-        private async Task<SyntaxNode> FormatResultAsync(Document document, CompilationUnitSyntax newRoot, CancellationToken cancellationToken)
-        {
-            var spans = new List<TextSpan>();
-            AddFormattingSpans(newRoot, spans, cancellationToken);
-            var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
-            return Formatter.Format(newRoot, spans, document.Project.Solution.Workspace, options, cancellationToken: cancellationToken);
+                return document.WithSyntaxRoot(formattedRoot);
+            }
         }
 
         private void AddFormattingSpans(
diff --git a/src/Workspaces/VisualBasic/Portable/CaseCorrection/VisualBasicCaseCorrectionService.vb b/src/Workspaces/VisualBasic/Portable/CaseCorrection/VisualBasicCaseCorrectionService.vb
index 3e250e53d7e36..a13d6291b8380 100644
--- a/src/Workspaces/VisualBasic/Portable/CaseCorrection/VisualBasicCaseCorrectionService.vb
+++ b/src/Workspaces/VisualBasic/Portable/CaseCorrection/VisualBasicCaseCorrectionService.vb
@@ -27,7 +27,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CaseCorrection
         Protected Overrides Sub AddReplacements(semanticModel As SemanticModel,
                                                 root As SyntaxNode,
                                                 spans As ImmutableArray(Of TextSpan),
-                                                workspace As Workspace,
                                                 replacements As ConcurrentDictionary(Of SyntaxToken, SyntaxToken),
                                                 cancellationToken As CancellationToken)
             For Each span In spans
diff --git a/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/AbstractTokensCodeCleanupProvider.vb b/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/AbstractTokensCodeCleanupProvider.vb
index 43dc00ea7d320..9eef93cdd24c1 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/AbstractTokensCodeCleanupProvider.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/AbstractTokensCodeCleanupProvider.vb
@@ -5,6 +5,8 @@
 Imports System.Collections.Immutable
 Imports System.Threading
 Imports Microsoft.CodeAnalysis
+Imports Microsoft.CodeAnalysis.Formatting
+Imports Microsoft.CodeAnalysis.Host
 Imports Microsoft.CodeAnalysis.Shared.Collections
 Imports Microsoft.CodeAnalysis.Text
 
@@ -15,18 +17,18 @@ Namespace Microsoft.CodeAnalysis.CodeCleanup.Providers
         Public MustOverride ReadOnly Property Name As String Implements ICodeCleanupProvider.Name
 
         Protected MustOverride Function GetRewriterAsync(
-            document As Document, root As SyntaxNode, spans As ImmutableArray(Of TextSpan), workspace As Workspace, cancellationToken As CancellationToken) As Task(Of Rewriter)
+            document As Document, root As SyntaxNode, spans As ImmutableArray(Of TextSpan), cancellationToken As CancellationToken) As Task(Of Rewriter)
 
-        Public Async Function CleanupAsync(document As Document, spans As ImmutableArray(Of TextSpan), Optional cancellationToken As CancellationToken = Nothing) As Task(Of Document) Implements ICodeCleanupProvider.CleanupAsync
+        Public Async Function CleanupAsync(document As Document, spans As ImmutableArray(Of TextSpan), options As SyntaxFormattingOptions, cancellationToken As CancellationToken) As Task(Of Document) Implements ICodeCleanupProvider.CleanupAsync
             Dim root = Await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(False)
-            Dim rewriter As Rewriter = Await GetRewriterAsync(document, root, spans, document.Project.Solution.Workspace, cancellationToken).ConfigureAwait(False)
+            Dim rewriter As Rewriter = Await GetRewriterAsync(document, root, spans, cancellationToken).ConfigureAwait(False)
             Dim newRoot = rewriter.Visit(root)
 
             Return If(root Is newRoot, document, document.WithSyntaxRoot(newRoot))
         End Function
 
-        Public Async Function CleanupAsync(root As SyntaxNode, spans As ImmutableArray(Of TextSpan), workspace As Workspace, Optional cancellationToken As CancellationToken = Nothing) As Task(Of SyntaxNode) Implements ICodeCleanupProvider.CleanupAsync
-            Dim rewriter As Rewriter = Await GetRewriterAsync(Nothing, root, spans, workspace, cancellationToken).ConfigureAwait(False)
+        Public Async Function CleanupAsync(root As SyntaxNode, spans As ImmutableArray(Of TextSpan), options As SyntaxFormattingOptions, services As HostWorkspaceServices, cancellationToken As CancellationToken) As Task(Of SyntaxNode) Implements ICodeCleanupProvider.CleanupAsync
+            Dim rewriter As Rewriter = Await GetRewriterAsync(Nothing, root, spans, cancellationToken).ConfigureAwait(False)
             Return rewriter.Visit(root)
         End Function
 
diff --git a/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/AddMissingTokensCodeCleanupProvider.vb b/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/AddMissingTokensCodeCleanupProvider.vb
index d1890270c9e77..5323ec7417111 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/AddMissingTokensCodeCleanupProvider.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/AddMissingTokensCodeCleanupProvider.vb
@@ -26,7 +26,7 @@ Namespace Microsoft.CodeAnalysis.CodeCleanup.Providers
             End Get
         End Property
 
-        Protected Overrides Async Function GetRewriterAsync(document As Document, root As SyntaxNode, spans As ImmutableArray(Of TextSpan), workspace As Workspace, cancellationToken As CancellationToken) As Task(Of Rewriter)
+        Protected Overrides Async Function GetRewriterAsync(document As Document, root As SyntaxNode, spans As ImmutableArray(Of TextSpan), cancellationToken As CancellationToken) As Task(Of Rewriter)
             Return Await AddMissingTokensRewriter.CreateAsync(document, spans, cancellationToken).ConfigureAwait(False)
         End Function
 
diff --git a/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/CaseCorrectionCodeCleanupProvider.vb b/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/CaseCorrectionCodeCleanupProvider.vb
index 7d3b700d5d1ea..e4cd067bbaf8f 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/CaseCorrectionCodeCleanupProvider.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/CaseCorrectionCodeCleanupProvider.vb
@@ -7,6 +7,8 @@ Imports System.Composition
 Imports System.Diagnostics.CodeAnalysis
 Imports System.Threading
 Imports Microsoft.CodeAnalysis.CaseCorrection
+Imports Microsoft.CodeAnalysis.Formatting
+Imports Microsoft.CodeAnalysis.Host
 Imports Microsoft.CodeAnalysis.Text
 
 Namespace Microsoft.CodeAnalysis.CodeCleanup.Providers
@@ -26,12 +28,12 @@ Namespace Microsoft.CodeAnalysis.CodeCleanup.Providers
             End Get
         End Property
 
-        Public Function CleanupAsync(document As Document, spans As ImmutableArray(Of TextSpan), Optional cancellationToken As CancellationToken = Nothing) As Task(Of Document) Implements ICodeCleanupProvider.CleanupAsync
+        Public Function CleanupAsync(document As Document, spans As ImmutableArray(Of TextSpan), options As SyntaxFormattingOptions, cancellationToken As CancellationToken) As Task(Of Document) Implements ICodeCleanupProvider.CleanupAsync
             Return CaseCorrector.CaseCorrectAsync(document, spans, cancellationToken)
         End Function
 
-        Public Function CleanupAsync(root As SyntaxNode, spans As ImmutableArray(Of TextSpan), workspace As Workspace, Optional cancellationToken As CancellationToken = Nothing) As Task(Of SyntaxNode) Implements ICodeCleanupProvider.CleanupAsync
-            Return Task.FromResult(CaseCorrector.CaseCorrect(root, spans, workspace, cancellationToken))
+        Public Function CleanupAsync(root As SyntaxNode, spans As ImmutableArray(Of TextSpan), options As SyntaxFormattingOptions, services As HostWorkspaceServices, cancellationToken As CancellationToken) As Task(Of SyntaxNode) Implements ICodeCleanupProvider.CleanupAsync
+            Return Task.FromResult(CaseCorrector.CaseCorrect(root, spans, services, cancellationToken))
         End Function
     End Class
 End Namespace
diff --git a/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/FixIncorrectTokensCodeCleanupProvider.vb b/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/FixIncorrectTokensCodeCleanupProvider.vb
index 5cf2a1980917f..80e32d78edc21 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/FixIncorrectTokensCodeCleanupProvider.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/FixIncorrectTokensCodeCleanupProvider.vb
@@ -35,7 +35,7 @@ Namespace Microsoft.CodeAnalysis.CodeCleanup.Providers
             End Get
         End Property
 
-        Protected Overrides Function GetRewriterAsync(document As Document, root As SyntaxNode, spans As ImmutableArray(Of TextSpan), workspace As Workspace, cancellationToken As CancellationToken) As Task(Of Rewriter)
+        Protected Overrides Function GetRewriterAsync(document As Document, root As SyntaxNode, spans As ImmutableArray(Of TextSpan), cancellationToken As CancellationToken) As Task(Of Rewriter)
             Return FixIncorrectTokensRewriter.CreateAsync(document, spans, cancellationToken)
         End Function
 
diff --git a/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/NormalizeModifiersOrOperatorsCodeCleanupProvider.vb b/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/NormalizeModifiersOrOperatorsCodeCleanupProvider.vb
index 8ee05faf7c3c8..7ad4b805deded 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/NormalizeModifiersOrOperatorsCodeCleanupProvider.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/NormalizeModifiersOrOperatorsCodeCleanupProvider.vb
@@ -7,6 +7,8 @@ Imports System.Composition
 Imports System.Diagnostics.CodeAnalysis
 Imports System.Threading
 Imports Microsoft.CodeAnalysis
+Imports Microsoft.CodeAnalysis.Formatting
+Imports Microsoft.CodeAnalysis.Host
 Imports Microsoft.CodeAnalysis.Shared.Collections
 Imports Microsoft.CodeAnalysis.Text
 Imports Microsoft.CodeAnalysis.VisualBasic.CodeStyle
@@ -29,14 +31,14 @@ Namespace Microsoft.CodeAnalysis.CodeCleanup.Providers
             End Get
         End Property
 
-        Public Async Function CleanupAsync(document As Document, spans As ImmutableArray(Of TextSpan), Optional cancellationToken As CancellationToken = Nothing) As Task(Of Document) Implements ICodeCleanupProvider.CleanupAsync
+        Public Async Function CleanupAsync(document As Document, spans As ImmutableArray(Of TextSpan), options As SyntaxFormattingOptions, cancellationToken As CancellationToken) As Task(Of Document) Implements ICodeCleanupProvider.CleanupAsync
             Dim root = Await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(False)
-            Dim newRoot = Await CleanupAsync(root, spans, document.Project.Solution.Workspace, cancellationToken).ConfigureAwait(False)
+            Dim newRoot = Await CleanupAsync(root, spans, options, document.Project.Solution.Workspace.Services, cancellationToken).ConfigureAwait(False)
 
             Return If(root Is newRoot, document, document.WithSyntaxRoot(newRoot))
         End Function
 
-        Public Function CleanupAsync(root As SyntaxNode, spans As ImmutableArray(Of TextSpan), workspace As Workspace, Optional cancellationToken As CancellationToken = Nothing) As Task(Of SyntaxNode) Implements ICodeCleanupProvider.CleanupAsync
+        Public Function CleanupAsync(root As SyntaxNode, spans As ImmutableArray(Of TextSpan), options As SyntaxFormattingOptions, services As HostWorkspaceServices, cancellationToken As CancellationToken) As Task(Of SyntaxNode) Implements ICodeCleanupProvider.CleanupAsync
             Dim rewriter = New Rewriter(spans, cancellationToken)
             Dim newRoot = rewriter.Visit(root)
 
diff --git a/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/ReduceTokensCodeCleanupProvider.vb b/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/ReduceTokensCodeCleanupProvider.vb
index b92ec96f64a81..b6f4bef51bc7b 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/ReduceTokensCodeCleanupProvider.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/ReduceTokensCodeCleanupProvider.vb
@@ -30,7 +30,7 @@ Namespace Microsoft.CodeAnalysis.CodeCleanup.Providers
             End Get
         End Property
 
-        Protected Overrides Function GetRewriterAsync(document As Document, root As SyntaxNode, spans As ImmutableArray(Of TextSpan), workspace As Workspace, cancellationToken As CancellationToken) As Task(Of Rewriter)
+        Protected Overrides Function GetRewriterAsync(document As Document, root As SyntaxNode, spans As ImmutableArray(Of TextSpan), cancellationToken As CancellationToken) As Task(Of Rewriter)
             Return Task.FromResult(Of Rewriter)(New ReduceTokensRewriter(spans, cancellationToken))
         End Function
 
diff --git a/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/RemoveUnnecessaryLineContinuationCodeCleanupProvider.vb b/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/RemoveUnnecessaryLineContinuationCodeCleanupProvider.vb
index 7394c1197d429..9bcd1c84bfdfc 100644
--- a/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/RemoveUnnecessaryLineContinuationCodeCleanupProvider.vb
+++ b/src/Workspaces/VisualBasic/Portable/CodeCleanup/Providers/RemoveUnnecessaryLineContinuationCodeCleanupProvider.vb
@@ -7,6 +7,8 @@ Imports System.Composition
 Imports System.Diagnostics.CodeAnalysis
 Imports System.Threading
 Imports Microsoft.CodeAnalysis
+Imports Microsoft.CodeAnalysis.Formatting
+Imports Microsoft.CodeAnalysis.Host
 Imports Microsoft.CodeAnalysis.Text
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 
@@ -27,7 +29,7 @@ Namespace Microsoft.CodeAnalysis.CodeCleanup.Providers
             End Get
         End Property
 
-        Public Async Function CleanupAsync(document As Document, spans As ImmutableArray(Of TextSpan), Optional cancellationToken As CancellationToken = Nothing) As Task(Of Document) Implements ICodeCleanupProvider.CleanupAsync
+        Public Async Function CleanupAsync(document As Document, spans As ImmutableArray(Of TextSpan), options As SyntaxFormattingOptions, cancellationToken As CancellationToken) As Task(Of Document) Implements ICodeCleanupProvider.CleanupAsync
             ' Is this VB 9? If so, we shouldn't remove line continuations because implicit line continuation was introduced in VB 10.
             Dim parseOptions = TryCast(document.Project.ParseOptions, VisualBasicParseOptions)
             If parseOptions?.LanguageVersion <= LanguageVersion.VisualBasic9 Then
@@ -35,12 +37,12 @@ Namespace Microsoft.CodeAnalysis.CodeCleanup.Providers
             End If
 
             Dim root = Await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(False)
-            Dim newRoot = Await CleanupAsync(root, spans, document.Project.Solution.Workspace, cancellationToken).ConfigureAwait(False)
+            Dim newRoot = Await CleanupAsync(root, spans, options, document.Project.Solution.Workspace.Services, cancellationToken).ConfigureAwait(False)
 
             Return If(newRoot Is root, document, document.WithSyntaxRoot(newRoot))
         End Function
 
-        Public Function CleanupAsync(root As SyntaxNode, spans As ImmutableArray(Of TextSpan), workspace As Workspace, Optional cancellationToken As CancellationToken = Nothing) As Task(Of SyntaxNode) Implements ICodeCleanupProvider.CleanupAsync
+        Public Function CleanupAsync(root As SyntaxNode, spans As ImmutableArray(Of TextSpan), options As SyntaxFormattingOptions, services As HostWorkspaceServices, cancellationToken As CancellationToken) As Task(Of SyntaxNode) Implements ICodeCleanupProvider.CleanupAsync
             Return Task.FromResult(Replacer.Process(root, spans, cancellationToken))
         End Function
 
diff --git a/src/Workspaces/VisualBasic/Portable/Indentation/VisualBasicIndentationService.Indenter.vb b/src/Workspaces/VisualBasic/Portable/Indentation/VisualBasicIndentationService.Indenter.vb
index bd37ccfb9a1a2..d4006252b31a4 100644
--- a/src/Workspaces/VisualBasic/Portable/Indentation/VisualBasicIndentationService.Indenter.vb
+++ b/src/Workspaces/VisualBasic/Portable/Indentation/VisualBasicIndentationService.Indenter.vb
@@ -17,11 +17,11 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Indentation
         End Function
 
         Protected Overrides Function CreateSmartTokenFormatter(indenter As Indenter) As ISmartTokenFormatter
-            Dim workspace = indenter.Document.Project.Solution.Workspace
-            Dim formattingRuleFactory = workspace.Services.GetService(Of IHostDependentFormattingRuleFactoryService)()
+            Dim services = indenter.Document.Project.Solution.Workspace.Services
+            Dim formattingRuleFactory = services.GetService(Of IHostDependentFormattingRuleFactoryService)()
             Dim rules = {New SpecialFormattingRule(indenter.OptionSet.GetOption(FormattingOptions.SmartIndent, indenter.Document.Root.Language)), formattingRuleFactory.CreateRule(indenter.Document.Document, indenter.LineToBeIndented.Start)}.Concat(Formatter.GetDefaultFormattingRules(indenter.Document.Document))
-
-            Return New VisualBasicSmartTokenFormatter(indenter.OptionSet, rules, indenter.Root)
+            Dim options = SyntaxFormattingOptions.Create(indenter.OptionSet, services, indenter.Document.Project.Language)
+            Return New VisualBasicSmartTokenFormatter(options, rules, indenter.Root)
         End Function
 
         Protected Overrides Function GetDesiredIndentationWorker(
diff --git a/src/Workspaces/VisualBasic/Portable/Indentation/VisualBasicSmartTokenFormatter.vb b/src/Workspaces/VisualBasic/Portable/Indentation/VisualBasicSmartTokenFormatter.vb
index aa953c464f3ff..c6df0a006973d 100644
--- a/src/Workspaces/VisualBasic/Portable/Indentation/VisualBasicSmartTokenFormatter.vb
+++ b/src/Workspaces/VisualBasic/Portable/Indentation/VisualBasicSmartTokenFormatter.vb
@@ -7,6 +7,7 @@ Imports Microsoft.CodeAnalysis.Formatting
 Imports Microsoft.CodeAnalysis.Formatting.Rules
 Imports Microsoft.CodeAnalysis.Indentation
 Imports Microsoft.CodeAnalysis.Options
+Imports Microsoft.CodeAnalysis.Host
 Imports Microsoft.CodeAnalysis.Text
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 
@@ -14,32 +15,31 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Indentation
     Friend Class VisualBasicSmartTokenFormatter
         Implements ISmartTokenFormatter
 
-        Private ReadOnly _optionSet As OptionSet
+        Private ReadOnly _options As SyntaxFormattingOptions
         Private ReadOnly _formattingRules As IEnumerable(Of AbstractFormattingRule)
 
         Private ReadOnly _root As CompilationUnitSyntax
 
-        Public Sub New(optionSet As OptionSet,
+        Public Sub New(options As SyntaxFormattingOptions,
                        formattingRules As IEnumerable(Of AbstractFormattingRule),
                        root As CompilationUnitSyntax)
-            Contract.ThrowIfNull(optionSet)
             Contract.ThrowIfNull(formattingRules)
             Contract.ThrowIfNull(root)
 
-            Me._optionSet = optionSet
+            Me._options = options
             Me._formattingRules = formattingRules
 
             Me._root = root
         End Sub
 
-        Public Function FormatTokenAsync(workspace As Workspace, token As SyntaxToken, cancellationToken As CancellationToken) As Tasks.Task(Of IList(Of TextChange)) Implements ISmartTokenFormatter.FormatTokenAsync
+        Public Function FormatTokenAsync(services As HostWorkspaceServices, token As SyntaxToken, cancellationToken As CancellationToken) As Tasks.Task(Of IList(Of TextChange)) Implements ISmartTokenFormatter.FormatTokenAsync
             Contract.ThrowIfTrue(token.Kind = SyntaxKind.None OrElse token.Kind = SyntaxKind.EndOfFileToken)
 
             ' get previous token
             Dim previousToken = token.GetPreviousToken()
 
             Dim spans = SpecializedCollections.SingletonEnumerable(TextSpan.FromBounds(previousToken.SpanStart, token.Span.End))
-            Return Task.FromResult(Formatter.GetFormattedTextChanges(_root, spans, workspace, _optionSet, _formattingRules, cancellationToken))
+            Return Task.FromResult(Formatter.GetFormattedTextChanges(_root, spans, services, _options, _formattingRules, cancellationToken))
         End Function
     End Class
 End Namespace
diff --git a/src/Workspaces/VisualBasicTest/Formatting/FormattingTests.vb b/src/Workspaces/VisualBasicTest/Formatting/FormattingTests.vb
index 6004b5d2fa16a..72de1f2d67263 100644
--- a/src/Workspaces/VisualBasicTest/Formatting/FormattingTests.vb
+++ b/src/Workspaces/VisualBasicTest/Formatting/FormattingTests.vb
@@ -2,6 +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.
 
+Imports System.Threading
+Imports Microsoft.CodeAnalysis.Diagnostics
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions
 Imports Microsoft.CodeAnalysis.Formatting
 Imports Microsoft.CodeAnalysis.Test.Utilities
@@ -3027,16 +3029,17 @@ End Module"
                 Dim project = workspace.CurrentSolution.AddProject("Project", "Project.dll", LanguageNames.VisualBasic)
                 Dim document = project.AddDocument("Document", SourceText.From(inputOutput))
                 Dim root = Await document.GetSyntaxRootAsync()
+                Dim options = SyntaxFormattingOptions.Default
 
                 ' format first time
-                Dim result = Formatter.GetFormattedTextChanges(root, workspace)
+                Dim result = Formatter.GetFormattedTextChanges(root, workspace.Services, options, CancellationToken.None)
                 AssertResult(inputOutput, Await document.GetTextAsync(), result)
 
                 Dim document2 = document.WithText((Await document.GetTextAsync()).WithChanges(result))
                 Dim root2 = Await document2.GetSyntaxRootAsync()
 
                 ' format second time
-                Dim result2 = Formatter.GetFormattedTextChanges(root, workspace)
+                Dim result2 = Formatter.GetFormattedTextChanges(root, workspace.Services, options, CancellationToken.None)
                 AssertResult(inputOutput, Await document2.GetTextAsync(), result2)
             End Using
         End Function
@@ -3854,7 +3857,7 @@ End Class</text>.Value.Replace(vbLf, vbCrLf)
             root = root.ReplaceNode(method, method.NormalizeWhitespace(elasticTrivia:=True).WithAdditionalAnnotations(goo))
 
             Using workspace = New AdhocWorkspace()
-                Dim result = Formatter.Format(root, goo, workspace).ToString()
+                Dim result = Formatter.Format(root, goo, workspace.Services, SyntaxFormattingOptions.Default, CancellationToken.None).ToString()
                 Assert.Equal(expected, result)
             End Using
         End Sub
@@ -4672,17 +4675,24 @@ End Class
 
         <Fact, Trait(Traits.Feature, Traits.Features.Formatting)>
         Public Sub NewLineOption_LineFeedOnly()
-            Dim tree = SyntaxFactory.ParseCompilationUnit("Class C" & vbCrLf & "End Class")
+            Using workspace = New AdhocWorkspace()
+                Dim tree = SyntaxFactory.ParseCompilationUnit("Class C" & vbCrLf & "End Class")
+
+                ' replace all EOL trivia with elastic markers to force the formatter to add EOL back
+                tree = tree.ReplaceTrivia(tree.DescendantTrivia().Where(Function(tr) tr.IsKind(SyntaxKind.EndOfLineTrivia)), Function(o, r) SyntaxFactory.ElasticMarker)
 
-            ' replace all EOL trivia with elastic markers to force the formatter to add EOL back
-            tree = tree.ReplaceTrivia(tree.DescendantTrivia().Where(Function(tr) tr.IsKind(SyntaxKind.EndOfLineTrivia)), Function(o, r) SyntaxFactory.ElasticMarker)
+                Dim options = SyntaxFormattingOptions.Create(
+                    workspace.Options.WithChangedOption(FormattingOptions.NewLine, LanguageNames.VisualBasic, vbLf),
+                    workspace.Services,
+                    tree.Language)
 
-            Dim formatted = Formatter.Format(tree, DefaultWorkspace, DefaultWorkspace.Options.WithChangedOption(FormattingOptions.NewLine, LanguageNames.VisualBasic, vbLf))
-            Dim actual = formatted.ToFullString()
+                Dim formatted = Formatter.Format(tree, workspace.Services, options, CancellationToken.None)
+                Dim actual = formatted.ToFullString()
 
-            Dim expected = "Class C" & vbLf & "End Class"
+                Dim expected = "Class C" & vbLf & "End Class"
 
-            Assert.Equal(expected, actual)
+                Assert.Equal(expected, actual)
+            End Using
         End Sub
 
         <Fact, Trait(Traits.Feature, Traits.Features.Formatting)>
diff --git a/src/Workspaces/VisualBasicTest/Formatting/VisualBasicFormattingTestBase.vb b/src/Workspaces/VisualBasicTest/Formatting/VisualBasicFormattingTestBase.vb
index 5f8769c83e773..d854e8d556bf2 100644
--- a/src/Workspaces/VisualBasicTest/Formatting/VisualBasicFormattingTestBase.vb
+++ b/src/Workspaces/VisualBasicTest/Formatting/VisualBasicFormattingTestBase.vb
@@ -4,6 +4,7 @@
 
 Imports System.Collections.Immutable
 Imports System.Threading
+Imports Microsoft.CodeAnalysis.Diagnostics
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions
 Imports Microsoft.CodeAnalysis.Formatting
 Imports Microsoft.CodeAnalysis.Text
@@ -55,26 +56,27 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests.Formatting
                 Dim project = workspace.CurrentSolution.AddProject("Project", "Project.dll", LanguageNames.VisualBasic)
                 Dim document = project.AddDocument("Document", SourceText.From(code))
                 Dim syntaxTree = Await document.GetSyntaxTreeAsync()
+                Dim options = SyntaxFormattingOptions.Default
 
                 ' Test various entry points into the formatter
 
                 Dim spans = New List(Of TextSpan)()
                 spans.Add(syntaxTree.GetRoot().FullSpan)
 
-                Dim changes = Formatter.GetFormattedTextChanges(Await syntaxTree.GetRootAsync(), workspace, cancellationToken:=CancellationToken.None)
+                Dim changes = Formatter.GetFormattedTextChanges(Await syntaxTree.GetRootAsync(), workspace.Services, options, CancellationToken.None)
                 AssertResult(expected, Await document.GetTextAsync(), changes)
 
-                changes = Formatter.GetFormattedTextChanges(Await syntaxTree.GetRootAsync(), (Await syntaxTree.GetRootAsync()).FullSpan, workspace, cancellationToken:=CancellationToken.None)
+                changes = Formatter.GetFormattedTextChanges(Await syntaxTree.GetRootAsync(), (Await syntaxTree.GetRootAsync()).FullSpan, workspace.Services, options, CancellationToken.None)
                 AssertResult(expected, Await document.GetTextAsync(), changes)
 
                 spans = New List(Of TextSpan)()
                 spans.Add(syntaxTree.GetRoot().FullSpan)
 
-                changes = Formatter.GetFormattedTextChanges(Await syntaxTree.GetRootAsync(), spans, workspace, cancellationToken:=CancellationToken.None)
+                changes = Formatter.GetFormattedTextChanges(Await syntaxTree.GetRootAsync(), spans, workspace.Services, options, CancellationToken.None)
                 AssertResult(expected, Await document.GetTextAsync(), changes)
 
                 ' format with node and transform
-                AssertFormatWithTransformation(workspace, expected, syntaxTree.GetRoot(), spans, Nothing, False)
+                AssertFormatWithTransformation(workspace.Services, expected, syntaxTree.GetRoot(), spans, SyntaxFormattingOptions.Default, False)
             End Using
         End Function
 

From 6a6798ce2678d76fe96252381573c17a286205e1 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Fri, 14 Jan 2022 20:03:32 -0800
Subject: [PATCH 370/444] Fixed

---
 .../RemoveUnnecessaryLambdaExpressionTests.cs | 36 +++++++++++----
 ...ecessaryLambdaExpressionCodeFixProvider.cs |  5 +-
 ...ssaryLambdaExpressionDiagnosticAnalyzer.cs | 46 +++++++++++++++----
 3 files changed, 66 insertions(+), 21 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
index 91f7a9a8252ec..b44deae439740 100644
--- a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
+++ b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
@@ -18,18 +18,36 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.RemoveUnnecessaryLambda
 
     public class RemoveUnnecessaryLambdaExpressionTests
     {
-        private static async Task TestInRegularAndScriptAsync(string testCode, string fixedCode)
+        private static async Task TestInRegularAndScriptAsync(string testCode, string fixedCode, LanguageVersion version = LanguageVersion.Preview)
         {
             await new VerifyCS.Test
             {
                 TestCode = testCode,
                 FixedCode = fixedCode,
-                LanguageVersion = LanguageVersion.Preview,
+                LanguageVersion = version,
             }.RunAsync();
         }
 
-        private static Task TestMissingInRegularAndScriptAsync(string testCode)
-            => TestInRegularAndScriptAsync(testCode, testCode);
+        private static Task TestMissingInRegularAndScriptAsync(string testCode, LanguageVersion version = LanguageVersion.Preview)
+            => TestInRegularAndScriptAsync(testCode, testCode, version);
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestMissingInCSharp10()
+        {
+            await TestMissingInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void Goo()
+    {
+        Bar(s => Quux(s));
+    }
+
+    void Bar(Func<int, string> f) { }
+    string Quux(int i) => default;
+}", LanguageVersion.CSharp10);
+        }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
         public async Task Test1()
@@ -131,7 +149,7 @@ class C
 {
     void Goo()
     {
-        Bar(s [||]=> Quux(s));
+        Bar(s => Quux({|CS1503:s|}));
     }
 
     void Bar(Func<string, string> f) { }
@@ -149,7 +167,7 @@ class C
 {
     void Goo()
     {
-        Bar(s [||]=> Quux(s));
+        Bar(s => Quux(s));
     }
 
     void Bar(Func<object, object> f) { }
@@ -167,7 +185,7 @@ class C
 {
     void Goo()
     {
-        Bar(s [||]=> Quux(s));
+        Bar(s => Quux(s));
     }
 
     void Bar(Func<object, string> f) { }
@@ -238,7 +256,7 @@ void Bar(Func<int, bool, string> f) { }
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
-        public async Task RestReturnStatement2()
+        public async Task TestReturnStatement2()
         {
             await TestInRegularAndScriptAsync(
 @"using System;
@@ -292,7 +310,7 @@ static void Bar(Action<string> x)
 
     static void Main()
     {
-        Bar([|x => |]Goo(x));
+        {|CS0121:Bar|}(x => Goo(x));
     }
 }");
         }
diff --git a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs
index 149c3e6de03a5..98e44a0eada2b 100644
--- a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs
@@ -12,6 +12,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editing;
@@ -57,9 +58,9 @@ protected override Task FixAllAsync(
                     (current, generator) =>
                     {
                         if (current is AnonymousFunctionExpressionSyntax anonymousFunction &&
-                            TryGetInvocation(anonymousFunction, out var invocation, out _))
+                            TryGetAnonymousFunctionInvocation(anonymousFunction, out var invocation, out _))
                         {
-                            return invocation.Expression.WithTriviaFrom(current);
+                            return invocation.Expression.WithTriviaFrom(current).Parenthesize();
                         }
 
                         return current;
diff --git a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
index 74664184d7a06..6f1e9e1cd7662 100644
--- a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
@@ -4,12 +4,14 @@
 
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CSharp.Utilities;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
@@ -41,16 +43,17 @@ protected override void InitializeWorker(AnalysisContext context)
         {
             context.RegisterCompilationStartAction(context =>
             {
-                //if (((CSharpCompilation)context.Compilation).LanguageVersion >= LanguageVersion.Preview)
-                //{
-                context.RegisterSyntaxNodeAction(
-                    AnalyzeSyntax,
-                    SyntaxKind.SimpleLambdaExpression, SyntaxKind.ParenthesizedLambdaExpression, SyntaxKind.AnonymousMethodExpression);
-                // }
+                if (((CSharpCompilation)context.Compilation).LanguageVersion >= LanguageVersion.Preview)
+                {
+                    var expressionType = context.Compilation.ExpressionOfTType();
+                    context.RegisterSyntaxNodeAction(
+                        c => AnalyzeSyntax(c, expressionType),
+                        SyntaxKind.SimpleLambdaExpression, SyntaxKind.ParenthesizedLambdaExpression, SyntaxKind.AnonymousMethodExpression);
+                }
             });
         }
 
-        private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
+        private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol? expressionType)
         {
             var cancellationToken = context.CancellationToken;
             var semanticModel = context.SemanticModel;
@@ -65,7 +68,7 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
             if (anonymousFunction.Modifiers.Any(SyntaxKind.StaticKeyword))
                 return;
 
-            if (!TryGetInvocation(anonymousFunction, out var invocation, out var wasAwaited))
+            if (!TryGetAnonymousFunctionInvocation(anonymousFunction, out var invocation, out var wasAwaited))
                 return;
 
             // If we had an async function, but we didn't await the expression inside then we can't convert this. The
@@ -98,6 +101,9 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
 
             // Looks like a reasonable candidate to simplify.  Now switch to semantics to check for sure.
 
+            if (CSharpSemanticFactsService.Instance.IsInExpressionTree(semanticModel, anonymousFunction, expressionType, cancellationToken))
+                return;
+
             // If we have `object obj = x => Goo(x);` we don't want to simplify.  The compiler warns if you write
             // `object obj = Goo;` because of the conversion to a non-delegate type.
             var lambdaTypeInfo = semanticModel.GetTypeInfo(anonymousFunction, cancellationToken);
@@ -135,6 +141,10 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
                     return;
             }
 
+            // if we have `() => new C().X()` then converting to `new C().X` very much changes the meaning.
+            if (MayContainSideEffects(invokedExpression))
+                return;
+
             // Semantically, this looks good to go.  Now, do an actual speculative replacement to ensure that the
             // non-invoked method reference refers to the same method symbol, and that it converts to the same type that
             // the lambda was.
@@ -165,6 +175,22 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
                 additionalUnnecessaryLocations: ImmutableArray.Create(syntaxTree.GetLocation(endReportSpan))));
         }
 
+        private static bool MayContainSideEffects(ExpressionSyntax expression)
+        {
+            // Checks to see if inlining the temporary variable may change the code's semantics. 
+            // This is not meant to be an exhaustive check; it's more like a heuristic for obvious cases we know may cause side effects.
+
+            var descendantNodesAndSelf = expression.DescendantNodesAndSelf();
+
+            if (descendantNodesAndSelf.Any(n => n.IsKind(SyntaxKind.ObjectCreationExpression, SyntaxKind.InvocationExpression)))
+            {
+                return true;
+            }
+
+            // Assume if we reach here that the fix won't cause side effects.
+            return false;
+        }
+
         private static SeparatedSyntaxList<ParameterSyntax> GetParameters(AnonymousFunctionExpressionSyntax expression)
             => expression switch
             {
@@ -174,7 +200,7 @@ private static SeparatedSyntaxList<ParameterSyntax> GetParameters(AnonymousFunct
                 _ => throw ExceptionUtilities.UnexpectedValue(expression.Kind()),
             };
 
-        private bool TryGetAnonymousFunctionInvocation(
+        public static bool TryGetAnonymousFunctionInvocation(
             AnonymousFunctionExpressionSyntax anonymousFunction,
             [NotNullWhen(true)] out InvocationExpressionSyntax? invocation,
             out bool wasAwaited)
@@ -197,7 +223,7 @@ private bool TryGetAnonymousFunctionInvocation(
             return false;
         }
 
-        public static bool TryGetInvocation(
+        private static bool TryGetInvocation(
             ExpressionSyntax expression,
             [NotNullWhen(true)] out InvocationExpressionSyntax? invocation,
             out bool wasAwaited)

From e8f75818cff062d2616c74a0b4190266dab22661 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Fri, 14 Jan 2022 20:07:57 -0800
Subject: [PATCH 371/444] Add tests

---
 .../RemoveUnnecessaryLambdaExpressionTests.cs | 132 +++++++++++++++++-
 1 file changed, 129 insertions(+), 3 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
index b44deae439740..144e2f8403493 100644
--- a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
+++ b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
@@ -79,6 +79,132 @@ void Bar(Func<int, string> f) { }
 }");
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestNotOnStaticLambda()
+        {
+            await TestMissingInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void Goo()
+    {
+        Bar(static s => Quux(s));
+    }
+
+    void Bar(Func<int, string> f) { }
+    static string Quux(int i) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestNotOnConversionToObject()
+        {
+            await TestMissingInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void Goo()
+    {
+        object o = (int s) => Quux(s));
+    }
+
+    void Bar(Func<int, string> f) { }
+    static string Quux(int i) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestWithParenthesizedLambda()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void Goo()
+    {
+        Bar([|(int s) => |]Quux(s));
+    }
+
+    void Bar(Func<int, string> f) { }
+    string Quux(int i) => default;
+}",
+@"using System;
+
+class C
+{
+    void Goo()
+    {
+        Bar(Quux);
+    }
+
+    void Bar(Func<int, string> f) { }
+    string Quux(int i) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestWithAnonymousMethod()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void Goo()
+    {
+        Bar([|delegate (int s) { return |]Quux(s); });
+    }
+
+    void Bar(Func<int, string> f) { }
+    string Quux(int i) => default;
+}",
+@"using System;
+
+class C
+{
+    void Goo()
+    {
+        Bar(Quux);
+    }
+
+    void Bar(Func<int, string> f) { }
+    string Quux(int i) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestWithAnonymousMethodNoParameterList()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void Goo()
+    {
+        Bar([|delegate { return |]Quux(); });
+    }
+
+    void Bar(Func<string> f) { }
+    string Quux() => default;
+}",
+@"using System;
+
+class C
+{
+    void Goo()
+    {
+        Bar(Quux);
+    }
+
+    void Bar(Func<string> f) { }
+    string Quux() => default;
+}");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
         public async Task TestFixCoContravariance1()
         {
@@ -385,7 +511,7 @@ class C<T>
     public static void InvokeGoo()
     {
         Action<dynamic, string> goo = (x, y) => [||]C<T>.Goo(x, y); // Simplify lambda expression
-        goo(1, "");
+        goo(1, """");
     }
 
     static void Goo(object x, object y)
@@ -420,7 +546,7 @@ class Casd<T>
     public static void InvokeGoo()
     {
         Action<dynamic> goo = x => [||]Casd<T>.Goo(x); // Simplify lambda expression
-        goo(1, "");
+        goo(1, """");
     }
 
     private static void Goo(dynamic x)
@@ -497,7 +623,7 @@ void Main()
 
         [WorkItem(545994, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545994")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
-        public async Task TestNonReturnBlockSyntax()
+        public async Task TestExpressionStatement()
         {
             await TestInRegularAndScriptAsync(
 @"using System;

From a5cb30bb50d23789c617bd1ed53cb470a24700a5 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Fri, 14 Jan 2022 20:09:24 -0800
Subject: [PATCH 372/444] Add tests

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

diff --git a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
index 144e2f8403493..e7d0aa9b4a477 100644
--- a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
+++ b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
@@ -107,7 +107,7 @@ class C
 {
     void Goo()
     {
-        object o = (int s) => Quux(s));
+        object o = (int s) => Quux(s);
     }
 
     void Bar(Func<int, string> f) { }

From 3135be292848ba44a8d50af2676da3979c1ed775 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Fri, 14 Jan 2022 20:30:08 -0800
Subject: [PATCH 373/444] Add tests

---
 .../RemoveUnnecessaryLambdaExpressionTests.cs | 208 ++++++++++++-
 ...plifierCodeRefactoringProvider.Rewriter.cs |  86 -----
 ...LambdaSimplifierCodeRefactoringProvider.cs | 293 ------------------
 ...ssaryLambdaExpressionDiagnosticAnalyzer.cs |  20 +-
 4 files changed, 215 insertions(+), 392 deletions(-)
 delete mode 100644 src/Features/CSharp/Portable/CodeRefactorings/LambdaSimplifier/LambdaSimplifierCodeRefactoringProvider.Rewriter.cs
 delete mode 100644 src/Features/CSharp/Portable/CodeRefactorings/LambdaSimplifier/LambdaSimplifierCodeRefactoringProvider.cs

diff --git a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
index e7d0aa9b4a477..fc956554099db 100644
--- a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
+++ b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
@@ -97,6 +97,163 @@ void Bar(Func<int, string> f) { }
 }");
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestNotWithOptionalParameter()
+        {
+            await TestMissingInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void Goo()
+    {
+        Bar(s => Quux(s));
+    }
+
+    void Bar(Func<int, string> f) { }
+    static string Quux(int i, int j = 0) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestNotWithParams1()
+        {
+            await TestMissingInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void Goo()
+    {
+        Bar(s => Quux(s));
+    }
+
+    void Bar(Func<int, string> f) { }
+    static string Quux(int i, params int[] j) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestNotWithParams2()
+        {
+            await TestMissingInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void Goo()
+    {
+        Bar(s => Quux(s));
+    }
+
+    void Bar(Func<object, string> f) { }
+    static string Quux(params object[] j) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestWithParams1()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void Goo()
+    {
+        Bar([|s => |]Quux(s));
+    }
+
+    void Bar(Func<object[], string> f) { }
+    string Quux(params object[] o) => default;
+}",
+@"using System;
+
+class C
+{
+    void Goo()
+    {
+        Bar(Quux);
+    }
+
+    void Bar(Func<object[], string> f) { }
+    string Quux(params object[] o) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestNotWithRefChange1()
+        {
+            await TestMissingInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void Goo()
+    {
+        Bar(s => Quux(ref s));
+    }
+
+    void Bar(Func<int, string> f) { }
+    static string Quux(ref int i) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestNotWithRefChange2()
+        {
+            await TestMissingInRegularAndScriptAsync(
+@"using System;
+
+delegate string X(ref int i);
+
+class C
+{
+    void Goo()
+    {
+        Bar((ref int s) => Quux(s));
+    }
+
+    void Bar(X x) { }
+    static string Quux(int i) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestWithSameRef()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+
+delegate string X(ref int i);
+
+class C
+{
+    void Goo()
+    {
+        Bar([|(ref int s) => |]Quux(ref s));
+    }
+
+    void Bar(X x) { }
+    static string Quux(ref int i) => default;
+}",
+
+@"using System;
+
+delegate string X(ref int i);
+
+class C
+{
+    void Goo()
+    {
+        Bar(Quux);
+    }
+
+    void Bar(X x) { }
+    static string Quux(ref int i) => default;
+}");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
         public async Task TestNotOnConversionToObject()
         {
@@ -275,7 +432,7 @@ class C
 {
     void Goo()
     {
-        Bar(s => Quux({|CS1503:s|}));
+        Bar(s => {|CS1662:{|CS0266:Quux(s)|}|});
     }
 
     void Bar(Func<string, string> f) { }
@@ -293,7 +450,7 @@ class C
 {
     void Goo()
     {
-        Bar(s => Quux(s));
+        Bar(s => Quux({|CS1503:s|}));
     }
 
     void Bar(Func<object, object> f) { }
@@ -311,7 +468,7 @@ class C
 {
     void Goo()
     {
-        Bar(s => Quux(s));
+        Bar(s => Quux({|CS1503:s|}));
     }
 
     void Bar(Func<object, string> f) { }
@@ -510,7 +667,7 @@ class C<T>
 {
     public static void InvokeGoo()
     {
-        Action<dynamic, string> goo = (x, y) => [||]C<T>.Goo(x, y); // Simplify lambda expression
+        Action<dynamic, string> goo = (x, y) => C<T>.Goo(x, y); // Simplify lambda expression
         goo(1, """");
     }
 
@@ -528,9 +685,9 @@ static void Goo(object x, T y)
 
         [WorkItem(627092, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/627092")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
-        public async Task TestMissingOnLambdaWithDynamic_2()
+        public async Task TestWithLambdaWithDynamic()
         {
-            await TestMissingInRegularAndScriptAsync(
+            await TestInRegularAndScriptAsync(
 @"using System;
 
 class Program
@@ -541,12 +698,45 @@ static void Main()
     }
 }
 
-class Casd<T>
+class C<T>
 {
     public static void InvokeGoo()
     {
-        Action<dynamic> goo = x => [||]Casd<T>.Goo(x); // Simplify lambda expression
-        goo(1, """");
+        Action<dynamic> goo = [|x => |]C<T>.Goo(x); // Simplify lambda expression
+        goo(1);
+    }
+
+    private static void Goo(dynamic x)
+    {
+        throw new NotImplementedException();
+    }
+
+    static void Goo(object x, object y)
+    {
+        Console.WriteLine(""Goo(object x, object y)"");
+    }
+
+    static void Goo(object x, T y)
+    {
+        Console.WriteLine(""Goo(object x, T y)"");
+    }
+}",
+@"using System;
+
+class Program
+{
+    static void Main()
+    {
+        C<string>.InvokeGoo();
+    }
+}
+
+class C<T>
+{
+    public static void InvokeGoo()
+    {
+        Action<dynamic> goo = C<T>.Goo; // Simplify lambda expression
+        goo(1);
     }
 
     private static void Goo(dynamic x)
diff --git a/src/Features/CSharp/Portable/CodeRefactorings/LambdaSimplifier/LambdaSimplifierCodeRefactoringProvider.Rewriter.cs b/src/Features/CSharp/Portable/CodeRefactorings/LambdaSimplifier/LambdaSimplifierCodeRefactoringProvider.Rewriter.cs
deleted file mode 100644
index 5777b3900fa1f..0000000000000
--- a/src/Features/CSharp/Portable/CodeRefactorings/LambdaSimplifier/LambdaSimplifierCodeRefactoringProvider.Rewriter.cs
+++ /dev/null
@@ -1,86 +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.
-
-#nullable disable
-
-using System;
-using System.Linq;
-using System.Threading;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CodeActions;
-using Microsoft.CodeAnalysis.CSharp.Extensions;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Formatting;
-using Microsoft.CodeAnalysis.Shared.Utilities;
-
-namespace Microsoft.CodeAnalysis.CSharp.CodeRefactorings.LambdaSimplifier
-{
-    internal partial class LambdaSimplifierCodeRefactoringProvider
-    {
-        private class Rewriter : CSharpSyntaxRewriter
-        {
-            private readonly SemanticDocument _document;
-            private readonly Func<SyntaxNode, bool> _predicate;
-            private readonly CancellationToken _cancellationToken;
-
-            public Rewriter(
-                SemanticDocument document,
-                Func<SyntaxNode, bool> predicate,
-                CancellationToken cancellationToken)
-            {
-                _document = document;
-                _predicate = predicate;
-                _cancellationToken = cancellationToken;
-            }
-
-            private ExpressionSyntax SimplifyInvocation(InvocationExpressionSyntax invocation)
-            {
-                var expression = invocation.Expression;
-                if (expression is MemberAccessExpressionSyntax memberAccess)
-                {
-                    var symbolMap = SemanticMap.From(_document.SemanticModel, memberAccess.Expression, _cancellationToken);
-                    var anySideEffects = symbolMap.AllReferencedSymbols.Any(s =>
-                        s.Kind is SymbolKind.Method or SymbolKind.Property);
-
-                    if (anySideEffects)
-                    {
-                        var annotation = WarningAnnotation.Create(CSharpFeaturesResources.Warning_Expression_may_change_code_meaning);
-                        expression = expression.ReplaceNode(memberAccess.Expression, memberAccess.Expression.WithAdditionalAnnotations(annotation));
-                    }
-                }
-
-                return expression.Parenthesize()
-                    .WithAdditionalAnnotations(Formatter.Annotation);
-            }
-
-            public override SyntaxNode VisitSimpleLambdaExpression(SimpleLambdaExpressionSyntax node)
-            {
-                if (_predicate(node) && CanSimplify(_document, node, _cancellationToken))
-                {
-                    var invocation = TryGetInvocationExpression(node.Body);
-                    if (invocation != null)
-                    {
-                        return SimplifyInvocation(invocation);
-                    }
-                }
-
-                return base.VisitSimpleLambdaExpression(node);
-            }
-
-            public override SyntaxNode VisitParenthesizedLambdaExpression(ParenthesizedLambdaExpressionSyntax node)
-            {
-                if (_predicate(node) && CanSimplify(_document, node, _cancellationToken))
-                {
-                    var invocation = TryGetInvocationExpression(node.Body);
-                    if (invocation != null)
-                    {
-                        return SimplifyInvocation(invocation);
-                    }
-                }
-
-                return base.VisitParenthesizedLambdaExpression(node);
-            }
-        }
-    }
-}
diff --git a/src/Features/CSharp/Portable/CodeRefactorings/LambdaSimplifier/LambdaSimplifierCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/CodeRefactorings/LambdaSimplifier/LambdaSimplifierCodeRefactoringProvider.cs
deleted file mode 100644
index 2d672d9b145d7..0000000000000
--- a/src/Features/CSharp/Portable/CodeRefactorings/LambdaSimplifier/LambdaSimplifierCodeRefactoringProvider.cs
+++ /dev/null
@@ -1,293 +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.
-
-#nullable disable
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.CodeActions;
-using Microsoft.CodeAnalysis.CodeRefactorings;
-using Microsoft.CodeAnalysis.CSharp.Extensions;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Shared.Extensions;
-using Roslyn.Utilities;
-
-namespace Microsoft.CodeAnalysis.CSharp.CodeRefactorings.LambdaSimplifier
-{
-    // Disabled due to: https://github.com/dotnet/roslyn/issues/5835 & https://github.com/dotnet/roslyn/pull/6642
-    // [ExportCodeRefactoringProvider(LanguageNames.CSharp, Name = PredefinedCodeRefactoringProviderNames.SimplifyLambda)]
-    internal partial class LambdaSimplifierCodeRefactoringProvider : CodeRefactoringProvider
-    {
-        public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
-        {
-            var (document, textSpan, cancellationToken) = context;
-            if (cancellationToken.IsCancellationRequested)
-            {
-                return;
-            }
-
-            if (document.Project.Solution.Workspace.Kind == WorkspaceKind.MiscellaneousFiles)
-            {
-                return;
-            }
-
-            var semanticDocument = await SemanticDocument.CreateAsync(document, cancellationToken).ConfigureAwait(false);
-
-            var lambda = await context.TryGetRelevantNodeAsync<LambdaExpressionSyntax>().ConfigureAwait(false);
-            if (lambda == null)
-            {
-                return;
-            }
-
-            if (!CanSimplify(semanticDocument, lambda as SimpleLambdaExpressionSyntax, cancellationToken) &&
-                !CanSimplify(semanticDocument, lambda as ParenthesizedLambdaExpressionSyntax, cancellationToken))
-            {
-                return;
-            }
-
-            context.RegisterRefactoring(
-                new MyCodeAction(
-                    CSharpFeaturesResources.Simplify_lambda_expression,
-                    c => SimplifyLambdaAsync(document, lambda, c)),
-                lambda.Span);
-
-            context.RegisterRefactoring(
-                new MyCodeAction(
-                    CSharpFeaturesResources.Simplify_all_occurrences,
-                    c => SimplifyAllLambdasAsync(document, c)),
-                lambda.Span);
-        }
-
-        private static async Task<Document> SimplifyLambdaAsync(
-            Document document,
-            SyntaxNode lambda,
-            CancellationToken cancellationToken)
-        {
-            var semanticDocument = await SemanticDocument.CreateAsync(document, cancellationToken).ConfigureAwait(false);
-            var rewriter = new Rewriter(semanticDocument, n => n == lambda, cancellationToken);
-            var result = rewriter.Visit(semanticDocument.Root);
-            return document.WithSyntaxRoot(result);
-        }
-
-        private static async Task<Document> SimplifyAllLambdasAsync(
-            Document document,
-            CancellationToken cancellationToken)
-        {
-            var semanticDocument = await SemanticDocument.CreateAsync(document, cancellationToken).ConfigureAwait(false);
-            var rewriter = new Rewriter(semanticDocument, n => true, cancellationToken);
-            var result = rewriter.Visit(semanticDocument.Root);
-            return document.WithSyntaxRoot(result);
-        }
-
-        private static bool CanSimplify(
-            SemanticDocument document,
-            SimpleLambdaExpressionSyntax node,
-            CancellationToken cancellationToken)
-        {
-            if (node == null)
-            {
-                return false;
-            }
-
-            var paramName = node.Parameter.Identifier;
-            var invocation = TryGetInvocationExpression(node.Body);
-            return CanSimplify(document, node, new List<SyntaxToken>() { paramName }, invocation, cancellationToken);
-        }
-
-        private static bool CanSimplify(
-            SemanticDocument document,
-            ParenthesizedLambdaExpressionSyntax node,
-            CancellationToken cancellationToken)
-        {
-            if (node == null)
-            {
-                return false;
-            }
-
-            var paramNames = node.ParameterList.Parameters.Select(p => p.Identifier).ToList();
-            var invocation = TryGetInvocationExpression(node.Body);
-            return CanSimplify(document, node, paramNames, invocation, cancellationToken);
-        }
-
-        private static bool CanSimplify(
-           SemanticDocument document,
-            ExpressionSyntax lambda,
-            List<SyntaxToken> paramNames,
-            InvocationExpressionSyntax invocation,
-            CancellationToken cancellationToken)
-        {
-            if (invocation == null)
-            {
-                return false;
-            }
-
-            if (invocation.ArgumentList.Arguments.Count != paramNames.Count)
-            {
-                return false;
-            }
-
-            for (var i = 0; i < paramNames.Count; i++)
-            {
-                var argument = invocation.ArgumentList.Arguments[i];
-                if (argument.NameColon != null ||
-                    argument.RefOrOutKeyword.Kind() != SyntaxKind.None ||
-                    !argument.Expression.IsKind(SyntaxKind.IdentifierName, out IdentifierNameSyntax identifierName))
-                {
-                    return false;
-                }
-
-                if (identifierName.Identifier.ValueText != paramNames[i].ValueText)
-                {
-                    return false;
-                }
-            }
-
-            var semanticModel = document.SemanticModel;
-            var lambdaSemanticInfo = semanticModel.GetSymbolInfo(lambda, cancellationToken);
-            var invocationSemanticInfo = semanticModel.GetSymbolInfo(invocation, cancellationToken);
-            if (lambdaSemanticInfo.Symbol == null ||
-                invocationSemanticInfo.Symbol == null)
-            {
-                // Don't offer this if there are any errors or ambiguities.
-                return false;
-            }
-
-            if (lambdaSemanticInfo.Symbol is not IMethodSymbol lambdaMethod || invocationSemanticInfo.Symbol is not IMethodSymbol invocationMethod)
-            {
-                return false;
-            }
-
-            // TODO(cyrusn): Handle extension methods as well.
-            if (invocationMethod.IsExtensionMethod)
-            {
-                return false;
-            }
-
-            // Check if any of the parameter is of Type Dynamic
-            foreach (var parameter in lambdaMethod.Parameters)
-            {
-                if (parameter.Type != null && parameter.Type.Kind == SymbolKind.DynamicType)
-                {
-                    return false;
-                }
-            }
-
-            // Check if the parameter and return types match between the lambda and the
-            // invocation.  Note: return types can be covariant and argument types can be
-            // contravariant.
-            if (lambdaMethod.ReturnsVoid != invocationMethod.ReturnsVoid ||
-                lambdaMethod.Parameters.Length != invocationMethod.Parameters.Length)
-            {
-                return false;
-            }
-
-            if (!lambdaMethod.ReturnsVoid)
-            {
-                // Return type has to be covariant.
-                var conversion = document.SemanticModel.Compilation.ClassifyConversion(
-                    invocationMethod.ReturnType, lambdaMethod.ReturnType);
-                if (!conversion.IsIdentityOrImplicitReference())
-                {
-                    return false;
-                }
-            }
-
-            // Parameter types have to be contravariant.
-            for (var i = 0; i < lambdaMethod.Parameters.Length; i++)
-            {
-                var conversion = document.SemanticModel.Compilation.ClassifyConversion(
-                    lambdaMethod.Parameters[i].Type, invocationMethod.Parameters[i].Type);
-
-                if (!conversion.IsIdentityOrImplicitReference())
-                {
-                    return false;
-                }
-            }
-
-            if (WouldCauseAmbiguity(lambda, invocation, semanticModel, cancellationToken))
-            {
-                return false;
-            }
-
-            // Looks like something we can simplify.
-            return true;
-        }
-
-        // Ensure that if we replace the invocation with its expression that its expression will
-        // bind unambiguously.  This can happen with awesome cases like:
-#if false
-    static void Goo<T>(T x) where T : class { }
-    static void Bar(Action<int> x) { }
-    static void Bar(Action<string> x) { }
-    static void Main()
-    {
-        Bar(x => Goo(x)); // error CS0121: The call is ambiguous between the following methods or properties: 'A.Bar(System.Action<int>)' and 'A.Bar(System.Action<string>)'
-    }
-#endif
-        private static bool WouldCauseAmbiguity(
-            ExpressionSyntax lambda,
-            InvocationExpressionSyntax invocation,
-            SemanticModel oldSemanticModel,
-            CancellationToken cancellationToken)
-        {
-            var annotation = new SyntaxAnnotation();
-
-            // In order to check if there will be a problem, we actually make the change, fork the
-            // compilation, and then verify that the new expression bound unambiguously.  
-            var oldExpression = invocation.Expression.WithAdditionalAnnotations(annotation);
-            var oldCompilation = oldSemanticModel.Compilation;
-            var oldTree = oldSemanticModel.SyntaxTree;
-            var oldRoot = oldTree.GetRoot(cancellationToken);
-
-            var newRoot = oldRoot.ReplaceNode(lambda, oldExpression);
-
-            var newTree = oldTree.WithRootAndOptions(newRoot, oldTree.Options);
-
-            var newCompilation = oldCompilation.ReplaceSyntaxTree(oldTree, newTree);
-            var newExpression = newTree.GetRoot(cancellationToken).GetAnnotatedNodesAndTokens(annotation).First().AsNode();
-            var newSemanticModel = newCompilation.GetSemanticModel(newTree);
-
-            var info = newSemanticModel.GetSymbolInfo(newExpression, cancellationToken);
-
-            return info.CandidateReason != CandidateReason.None;
-        }
-
-        private static InvocationExpressionSyntax TryGetInvocationExpression(
-            SyntaxNode lambdaBody)
-        {
-            if (lambdaBody is ExpressionSyntax exprBody)
-            {
-                return exprBody.WalkDownParentheses() as InvocationExpressionSyntax;
-            }
-            else if (lambdaBody is BlockSyntax block)
-            {
-                if (block.Statements.Count == 1)
-                {
-                    var statement = block.Statements.First();
-                    if (statement is ReturnStatementSyntax returnStatement)
-                    {
-                        return returnStatement.Expression.WalkDownParentheses() as InvocationExpressionSyntax;
-                    }
-                    else if (statement is ExpressionStatementSyntax exprStatement)
-                    {
-                        return exprStatement.Expression.WalkDownParentheses() as InvocationExpressionSyntax;
-                    }
-                }
-            }
-
-            return null;
-        }
-
-        private class MyCodeAction : CodeAction.DocumentChangeAction
-        {
-            public MyCodeAction(string title, Func<CancellationToken, Task<Document>> createChangedDocument)
-                : base(title, createChangedDocument, title)
-            {
-            }
-        }
-    }
-}
diff --git a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
index 6f1e9e1cd7662..d39b0bad69f32 100644
--- a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
@@ -126,8 +126,7 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol?
             var compilation = semanticModel.Compilation;
 
             // Must be able to convert the invoked method return type to the lambda's return type.
-            var returnTypeConversion = compilation.ClassifyConversion(invokedMethod.ReturnType, lambdaMethod.ReturnType);
-            if (!returnTypeConversion.IsIdentityOrImplicitReference())
+            if (!IsIdentityOrImplicitConversion(compilation, invokedMethod.ReturnType, lambdaMethod.ReturnType))
                 return;
 
             for (int i = 0, n = lambdaMethod.Parameters.Length; i < n; i++)
@@ -135,9 +134,11 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol?
                 var lambdaParameter = lambdaMethod.Parameters[i];
                 var invokedParameter = invokedMethod.Parameters[i];
 
+                if (lambdaParameter.RefKind != invokedParameter.RefKind)
+                    return;
+
                 // All the lambda parameters must be convertible to the invoked method parameters.
-                var parameterConversion = compilation.ClassifyConversion(lambdaParameter.Type, invokedParameter.Type);
-                if (!parameterConversion.IsIdentityOrImplicitReference())
+                if (!IsIdentityOrImplicitConversion(compilation, lambdaParameter.Type, invokedParameter.Type))
                     return;
             }
 
@@ -175,6 +176,17 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol?
                 additionalUnnecessaryLocations: ImmutableArray.Create(syntaxTree.GetLocation(endReportSpan))));
         }
 
+        private static bool IsIdentityOrImplicitConversion(Compilation compilation, ITypeSymbol type1, ITypeSymbol type2)
+        {
+            // Dynamic can have an identity conversion between types.  But it can have a very different effect on the
+            // generated code.  Do not allow the change if these are nto in agreement.
+            if (type1 is IDynamicTypeSymbol != type2 is IDynamicTypeSymbol)
+                return false;
+
+            var conversion = compilation.ClassifyConversion(type1, type2);
+            return conversion.IsIdentityOrImplicitReference();
+        }
+
         private static bool MayContainSideEffects(ExpressionSyntax expression)
         {
             // Checks to see if inlining the temporary variable may change the code's semantics. 

From ed72724e9e9d29baa464db3e2a627521cae15e88 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Fri, 14 Jan 2022 20:44:34 -0800
Subject: [PATCH 374/444] Add tests

---
 .../RemoveUnnecessaryLambdaExpressionTests.cs | 441 ++++++++++++++++++
 1 file changed, 441 insertions(+)

diff --git a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
index fc956554099db..36a5f046fb553 100644
--- a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
+++ b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
@@ -835,6 +835,447 @@ static void Main()
     {
         Action a = Console.WriteLine;
     }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestTaskOfT1()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar([|s => |]Quux(s));
+    }
+
+    void Bar(Func<int, Task<string>> f) { }
+    Task<string> Quux(int i) => default;
+}",
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar(Quux);
+    }
+
+    void Bar(Func<int, Task<string>> f) { }
+    Task<string> Quux(int i) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestAsyncTaskOfT1()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar([|async s => await |]Quux(s));
+    }
+
+    void Bar(Func<int, Task<string>> f) { }
+    Task<string> Quux(int i) => default;
+}",
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar(Quux);
+    }
+
+    void Bar(Func<int, Task<string>> f) { }
+    Task<string> Quux(int i) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestAsyncTaskOfT2()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar([|async s => await |]Quux(s).ConfigureAwait(false));
+    }
+
+    void Bar(Func<int, Task<string>> f) { }
+    Task<string> Quux(int i) => default;
+}",
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar(Quux);
+    }
+
+    void Bar(Func<int, Task<string>> f) { }
+    Task<string> Quux(int i) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestAsyncNoAwait1()
+        {
+            await TestMissingInRegularAndScriptAsync(
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar(async s => Quux(s));
+    }
+
+    void Bar(Func<int, Task<string>> f) { }
+    string Quux(int i) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestTaskOfT1_Return()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar([|s => { return |]Quux(s); });
+    }
+
+    void Bar(Func<int, Task<string>> f) { }
+    Task<string> Quux(int i) => default;
+}",
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar(Quux);
+    }
+
+    void Bar(Func<int, Task<string>> f) { }
+    Task<string> Quux(int i) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestAsyncTaskOfT1_Return()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar([|async s => { return await |]Quux(s); });
+    }
+
+    void Bar(Func<int, Task<string>> f) { }
+    Task<string> Quux(int i) => default;
+}",
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar(Quux);
+    }
+
+    void Bar(Func<int, Task<string>> f) { }
+    Task<string> Quux(int i) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestAsyncTaskOfT2_Return()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar([|async s => { return await |]Quux(s).ConfigureAwait(false); });
+    }
+
+    void Bar(Func<int, Task<string>> f) { }
+    Task<string> Quux(int i) => default;
+}",
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar(Quux);
+    }
+
+    void Bar(Func<int, Task<string>> f) { }
+    Task<string> Quux(int i) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestAsyncNoAwait1_Return()
+        {
+            await TestMissingInRegularAndScriptAsync(
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar(async s => { return Quux(s); });
+    }
+
+    void Bar(Func<int, Task<string>> f) { }
+    string Quux(int i) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestTask1()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar([|s => |]Quux(s));
+    }
+
+    void Bar(Func<int, Task> f) { }
+    Task Quux(int i) => default;
+}",
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar(Quux);
+    }
+
+    void Bar(Func<int, Task> f) { }
+    Task Quux(int i) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestAsyncTask1()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar([|async s => await |]Quux(s));
+    }
+
+    void Bar(Func<int, Task> f) { }
+    Task Quux(int i) => default;
+}",
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar(Quux);
+    }
+
+    void Bar(Func<int, Task> f) { }
+    Task Quux(int i) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestAsyncTask2()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar([|async s => await |]Quux(s).ConfigureAwait(false));
+    }
+
+    void Bar(Func<int, Task> f) { }
+    Task Quux(int i) => default;
+}",
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar(Quux);
+    }
+
+    void Bar(Func<int, Task> f) { }
+    Task Quux(int i) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestTask1_ExpressionStatement()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar([|s {|CS1643:=>|} { |]Quux(s); });
+    }
+
+    void Bar(Func<int, Task> f) { }
+    Task Quux(int i) => default;
+}",
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar(Quux);
+    }
+
+    void Bar(Func<int, Task> f) { }
+    Task Quux(int i) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestAsyncTask1_ExpressionStatement()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar([|async s => { await |]Quux(s); });
+    }
+
+    void Bar(Func<int, Task> f) { }
+    Task Quux(int i) => default;
+}",
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar(Quux);
+    }
+
+    void Bar(Func<int, Task> f) { }
+    Task Quux(int i) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestAsyncTask2_ExpressionStatement()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar([|async s => { await |]Quux(s).ConfigureAwait(false); });
+    }
+
+    void Bar(Func<int, Task> f) { }
+    Task Quux(int i) => default;
+}",
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar(Quux);
+    }
+
+    void Bar(Func<int, Task> f) { }
+    Task Quux(int i) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestAsyncNoAwait1_ExpressionStatement()
+        {
+            await TestMissingInRegularAndScriptAsync(
+@"using System;
+using System.Threading.Tasks;
+
+class C
+{
+    void Goo()
+    {
+        Bar(async s => { Quux(s); });
+    }
+
+    void Bar(Func<int, Task> f) { }
+    void Quux(int i) { }
 }");
         }
     }

From 28f73b2ac38426baacb922ae93ec72df2d3a295e Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Fri, 14 Jan 2022 20:49:02 -0800
Subject: [PATCH 375/444] Fade correct spans

---
 ...harpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
index d39b0bad69f32..f740337cc0366 100644
--- a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
@@ -173,7 +173,9 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol?
                 syntaxTree.GetLocation(startReportSpan),
                 ReportDiagnostic.Default,
                 additionalLocations: ImmutableArray.Create(anonymousFunction.GetLocation()),
-                additionalUnnecessaryLocations: ImmutableArray.Create(syntaxTree.GetLocation(endReportSpan))));
+                additionalUnnecessaryLocations: ImmutableArray.Create(
+                    syntaxTree.GetLocation(startReportSpan),
+                    syntaxTree.GetLocation(endReportSpan))));
         }
 
         private static bool IsIdentityOrImplicitConversion(Compilation compilation, ITypeSymbol type1, ITypeSymbol type2)

From f2d9a5c810a718df6ecdcebe0d5c20230c2c3938 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Fri, 14 Jan 2022 21:10:10 -0800
Subject: [PATCH 376/444] Add option to control this feature.

---
 .../RemoveUnnecessaryLambdaExpressionTests.cs | 26 +++++++++++++++++++
 ...ssaryLambdaExpressionDiagnosticAnalyzer.cs | 12 +++++++--
 .../CodeStyle/CSharpCodeStyleOptions.cs       |  6 +++++
 3 files changed, 42 insertions(+), 2 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
index 36a5f046fb553..5f67ed80cb048 100644
--- a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
+++ b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
@@ -3,7 +3,9 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.RemoveUnnecessaryLambdaExpression;
 using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
 using Microsoft.CodeAnalysis.Test.Utilities;
@@ -79,6 +81,30 @@ void Bar(Func<int, string> f) { }
 }");
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestWithOptionOff()
+        {
+            var code = @"using System;
+
+class C
+{
+    void Goo()
+    {
+        Bar(s => Quux(s));
+    }
+
+    void Bar(Func<int, string> f) { }
+    string Quux(int i) => default;
+}";
+            await new VerifyCS.Test
+            {
+                TestCode = code,
+                FixedCode = code,
+                LanguageVersion = LanguageVersion.Preview,
+                Options = { { CSharpCodeStyleOptions.PreferMethodGroupConversion, CodeStyleOptions2.FalseWithSilentEnforcement } }
+            }.RunAsync();
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
         public async Task TestNotOnStaticLambda()
         {
diff --git a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
index f740337cc0366..63780b7e5e756 100644
--- a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
@@ -7,6 +7,7 @@
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CSharp.Utilities;
@@ -28,7 +29,7 @@ internal class CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer : Abstr
         public CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer()
             : base(IDEDiagnosticIds.RemoveUnnecessaryLambdaExpressionDiagnosticId,
                    EnforceOnBuildValues.RemoveUnnecessaryLambdaExpression,
-                   option: null,
+                   CSharpCodeStyleOptions.PreferMethodGroupConversion,
                    LanguageNames.CSharp,
                    new LocalizableResourceString(nameof(CSharpFeaturesResources.Remove_unnecessary_lambda_expression), CSharpFeaturesResources.ResourceManager, typeof(CSharpFeaturesResources)),
                    new LocalizableResourceString(nameof(CSharpFeaturesResources.Lambda_expression_can_be_removed), CSharpFeaturesResources.ResourceManager, typeof(CSharpFeaturesResources)),
@@ -59,6 +60,13 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol?
             var semanticModel = context.SemanticModel;
             var syntaxTree = semanticModel.SyntaxTree;
 
+            var preference = context.GetOption(CSharpCodeStyleOptions.PreferMethodGroupConversion);
+            if (preference.Notification.Severity == ReportDiagnostic.Suppress)
+            {
+                // User doesn't care about this rule.
+                return;
+            }
+
             var anonymousFunction = (AnonymousFunctionExpressionSyntax)context.Node;
 
             // Syntax checks first.
@@ -171,7 +179,7 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol?
             context.ReportDiagnostic(DiagnosticHelper.CreateWithLocationTags(
                 Descriptor,
                 syntaxTree.GetLocation(startReportSpan),
-                ReportDiagnostic.Default,
+                preference.Notification.Severity,
                 additionalLocations: ImmutableArray.Create(anonymousFunction.GetLocation()),
                 additionalUnnecessaryLocations: ImmutableArray.Create(
                     syntaxTree.GetLocation(startReportSpan),
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/CodeStyle/CSharpCodeStyleOptions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/CodeStyle/CSharpCodeStyleOptions.cs
index a9430fceb2571..a1c01a67f7109 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/CodeStyle/CSharpCodeStyleOptions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/CodeStyle/CSharpCodeStyleOptions.cs
@@ -136,6 +136,12 @@ private static Option2<CodeStyleOption2<string>> CreateOption(
             "csharp_style_prefer_range_operator",
             "TextEditor.CSharp.Specific.PreferRangeOperator");
 
+        public static readonly Option2<CodeStyleOption2<bool>> PreferMethodGroupConversion = CreateOption(
+            CSharpCodeStyleOptionGroups.ExpressionLevelPreferences, nameof(PreferMethodGroupConversion),
+            defaultValue: s_trueWithSilentEnforcement,
+            "csharp_style_prefer_method_group_conversion",
+            "TextEditor.CSharp.Specific.PreferMethodGroupConversion");
+
         public static readonly CodeStyleOption2<ExpressionBodyPreference> NeverWithSilentEnforcement =
             new(ExpressionBodyPreference.Never, NotificationOption2.Silent);
 

From 2cc6d9f57751e37a1ac98c3028d84d8c3a52b64f Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Fri, 14 Jan 2022 21:16:35 -0800
Subject: [PATCH 377/444] Add test

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

diff --git a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
index 5f67ed80cb048..c47ee23a2de37 100644
--- a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
+++ b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
@@ -101,7 +101,7 @@ void Bar(Func<int, string> f) { }
                 TestCode = code,
                 FixedCode = code,
                 LanguageVersion = LanguageVersion.Preview,
-                Options = { { CSharpCodeStyleOptions.PreferMethodGroupConversion, CodeStyleOptions2.FalseWithSilentEnforcement } }
+                Options = { { CSharpCodeStyleOptions.PreferMethodGroupConversion, new CodeStyleOption2<bool>(false, NotificationOption2.None) } }
             }.RunAsync();
         }
 

From e9d5ce75c0e5ccc5eb6032a6fb2fb87e85420cc3 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrus.najmabadi@gmail.com>
Date: Fri, 14 Jan 2022 20:03:50 -1000
Subject: [PATCH 378/444] Update
 src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs

Co-authored-by: Youssef Victor <youssefvictor00@gmail.com>
---
 ...CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
index 63780b7e5e756..4f0adfb161e1c 100644
--- a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
@@ -24,7 +24,7 @@ namespace Microsoft.CodeAnalysis.CSharp.RemoveUnnecessaryLambdaExpression
     /// time.
     /// </summary>
     [DiagnosticAnalyzer(LanguageNames.CSharp)]
-    internal class CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer : AbstractBuiltInCodeStyleDiagnosticAnalyzer
+    internal sealed class CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer : AbstractBuiltInCodeStyleDiagnosticAnalyzer
     {
         public CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer()
             : base(IDEDiagnosticIds.RemoveUnnecessaryLambdaExpressionDiagnosticId,

From 469086a103e34a9871ecadb88e9860c1affb5d9b Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrus.najmabadi@gmail.com>
Date: Fri, 14 Jan 2022 20:05:13 -1000
Subject: [PATCH 379/444] Update src/Compilers/Test/Core/Traits/Traits.cs

Co-authored-by: Youssef Victor <youssefvictor00@gmail.com>
---
 src/Compilers/Test/Core/Traits/Traits.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Compilers/Test/Core/Traits/Traits.cs b/src/Compilers/Test/Core/Traits/Traits.cs
index 4fbfc0c4844cc..444e63dd244b1 100644
--- a/src/Compilers/Test/Core/Traits/Traits.cs
+++ b/src/Compilers/Test/Core/Traits/Traits.cs
@@ -118,7 +118,7 @@ public static class Features
             public const string CodeActionsInvertIf = "CodeActions.InvertIf";
             public const string CodeActionsInvertLogical = "CodeActions.InvertLogical";
             public const string CodeActionsInvokeDelegateWithConditionalAccess = "CodeActions.InvokeDelegateWithConditionalAccess";
-            public const string CodeActionsRemoveUnnecessaryLambdaExpression = "CodeActions.LambdaSimplifier";
+            public const string CodeActionsRemoveUnnecessaryLambdaExpression = "CodeActions.RemoveUnnecessaryLambdaExpression";
             public const string CodeActionsMakeFieldReadonly = "CodeActions.MakeFieldReadonly";
             public const string CodeActionsMakeLocalFunctionStatic = "CodeActions.MakeLocalFunctionStatic";
             public const string CodeActionsMakeMethodAsynchronous = "CodeActions.MakeMethodAsynchronous";

From 56305c65b8ab24a2c1144e83b19b12d5498766c6 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Fri, 14 Jan 2022 22:05:52 -0800
Subject: [PATCH 380/444] NRT

---
 ...harpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs | 2 --
 .../CSharp/Impl/Options/Formatting/StyleViewModel.cs       | 7 ++++---
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs
index 98e44a0eada2b..a9bbd6bcf43e0 100644
--- a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System;
 using System.Collections.Immutable;
 using System.Composition;
diff --git a/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs b/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs
index 4a4d360b1675b..91c2a76a4dec5 100644
--- a/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs
@@ -2110,6 +2110,10 @@ internal StyleViewModel(OptionStore optionStore, IServiceProvider serviceProvide
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.PreferRangeOperator, ServicesVSResources.Prefer_range_operator, s_preferRangeOperator, s_preferRangeOperator, this, optionStore, expressionPreferencesGroupTitle));
 
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.PreferTupleSwap, ServicesVSResources.Prefer_tuple_swap, s_preferTupleSwap, s_preferTupleSwap, this, optionStore, expressionPreferencesGroupTitle));
+            CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.PreferMethodGroupConversion, ServicesVSResources.Prefer_tuple_swap, s_preferTupleSwap, s_preferTupleSwap, this, optionStore, expressionPreferencesGroupTitle));
+
+            AddExpressionBodyOptions(optionStore, expressionPreferencesGroupTitle);
+            AddUnusedValueOptions(optionStore, expressionPreferencesGroupTitle);
 
             // Pattern matching
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.PreferPatternMatching, CSharpVSResources.Prefer_pattern_matching, s_preferPatternMatching, s_preferPatternMatching, this, optionStore, patternMatchingPreferencesGroupTitle));
@@ -2117,9 +2121,6 @@ internal StyleViewModel(OptionStore optionStore, IServiceProvider serviceProvide
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.PreferPatternMatchingOverAsWithNullCheck, CSharpVSResources.Prefer_pattern_matching_over_as_with_null_check, s_preferPatternMatchingOverAsWithNullCheck, s_preferPatternMatchingOverAsWithNullCheck, this, optionStore, patternMatchingPreferencesGroupTitle));
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.PreferNotPattern, CSharpVSResources.Prefer_pattern_matching_over_mixed_type_check, s_preferPatternMatchingOverMixedTypeCheck, s_preferPatternMatchingOverMixedTypeCheck, this, optionStore, patternMatchingPreferencesGroupTitle));
 
-            AddExpressionBodyOptions(optionStore, expressionPreferencesGroupTitle);
-            AddUnusedValueOptions(optionStore, expressionPreferencesGroupTitle);
-
             // Variable preferences
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.PreferInlinedVariableDeclaration, ServicesVSResources.Prefer_inlined_variable_declaration, s_preferInlinedVariableDeclaration, s_preferInlinedVariableDeclaration, this, optionStore, variablePreferencesGroupTitle));
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.PreferDeconstructedVariableDeclaration, ServicesVSResources.Prefer_deconstructed_variable_declaration, s_preferDeconstructedVariableDeclaration, s_preferDeconstructedVariableDeclaration, this, optionStore, variablePreferencesGroupTitle));

From 849e5760c42e8feee0fad10285d7372ed9933076 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Sat, 15 Jan 2022 00:14:09 -0800
Subject: [PATCH 381/444] Add option

---
 .../Impl/Options/Formatting/StyleViewModel.cs | 28 ++++++++-
 .../Core/Def/ServicesVSResources.resx         | 57 ++++++++++---------
 .../Core/Def/xlf/ServicesVSResources.cs.xlf   |  5 ++
 .../Core/Def/xlf/ServicesVSResources.de.xlf   |  5 ++
 .../Core/Def/xlf/ServicesVSResources.es.xlf   |  5 ++
 .../Core/Def/xlf/ServicesVSResources.fr.xlf   |  5 ++
 .../Core/Def/xlf/ServicesVSResources.it.xlf   |  5 ++
 .../Core/Def/xlf/ServicesVSResources.ja.xlf   |  5 ++
 .../Core/Def/xlf/ServicesVSResources.ko.xlf   |  5 ++
 .../Core/Def/xlf/ServicesVSResources.pl.xlf   |  5 ++
 .../Def/xlf/ServicesVSResources.pt-BR.xlf     |  5 ++
 .../Core/Def/xlf/ServicesVSResources.ru.xlf   |  5 ++
 .../Core/Def/xlf/ServicesVSResources.tr.xlf   |  5 ++
 .../Def/xlf/ServicesVSResources.zh-Hans.xlf   |  5 ++
 .../Def/xlf/ServicesVSResources.zh-Hant.xlf   |  5 ++
 .../CodeStyle/CSharpCodeStyleOptions.cs       | 12 ++--
 16 files changed, 128 insertions(+), 34 deletions(-)

diff --git a/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs b/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs
index 91c2a76a4dec5..57acab1007e6c 100644
--- a/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/Formatting/StyleViewModel.cs
@@ -958,6 +958,32 @@ public override int GetHashCode()
     }}
 //]
 }}
+";
+
+        private static readonly string s_preferMethodGroupConversion = $@"
+using System;
+
+class Customer1
+{{
+    public void M()
+    {{
+//[
+        // {ServicesVSResources.Prefer_colon}
+        Action<object> writeObject = Console.Write;
+//]
+    }}
+}}
+class Customer2
+{{
+    public void M()
+    {{
+//[
+        // {ServicesVSResources.Over_colon}
+        Action<object> writeObject = obj => Console.Write(obj);
+//]
+    }}
+//]
+}}
 ";
 
         private static readonly string s_preferLocalFunctionOverAnonymousFunction = $@"
@@ -2088,6 +2114,7 @@ internal StyleViewModel(OptionStore optionStore, IServiceProvider serviceProvide
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CodeStyleOptions2.PreferAutoProperties, ServicesVSResources.analyzer_Prefer_auto_properties, s_preferAutoProperties, s_preferAutoProperties, this, optionStore, codeBlockPreferencesGroupTitle));
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.PreferSimpleUsingStatement, ServicesVSResources.Prefer_simple_using_statement, s_preferSimpleUsingStatement, s_preferSimpleUsingStatement, this, optionStore, codeBlockPreferencesGroupTitle));
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CodeStyleOptions2.PreferSystemHashCode, ServicesVSResources.Prefer_System_HashCode_in_GetHashCode, s_preferSystemHashCode, s_preferSystemHashCode, this, optionStore, codeBlockPreferencesGroupTitle));
+            CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.PreferMethodGroupConversion, ServicesVSResources.Prefer_method_group_conversion, s_preferMethodGroupConversion, s_preferMethodGroupConversion, this, optionStore, codeBlockPreferencesGroupTitle));
 
             AddParenthesesOptions(OptionStore);
 
@@ -2110,7 +2137,6 @@ internal StyleViewModel(OptionStore optionStore, IServiceProvider serviceProvide
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.PreferRangeOperator, ServicesVSResources.Prefer_range_operator, s_preferRangeOperator, s_preferRangeOperator, this, optionStore, expressionPreferencesGroupTitle));
 
             CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.PreferTupleSwap, ServicesVSResources.Prefer_tuple_swap, s_preferTupleSwap, s_preferTupleSwap, this, optionStore, expressionPreferencesGroupTitle));
-            CodeStyleItems.Add(new BooleanCodeStyleOptionViewModel(CSharpCodeStyleOptions.PreferMethodGroupConversion, ServicesVSResources.Prefer_tuple_swap, s_preferTupleSwap, s_preferTupleSwap, this, optionStore, expressionPreferencesGroupTitle));
 
             AddExpressionBodyOptions(optionStore, expressionPreferencesGroupTitle);
             AddUnusedValueOptions(optionStore, expressionPreferencesGroupTitle);
diff --git a/src/VisualStudio/Core/Def/ServicesVSResources.resx b/src/VisualStudio/Core/Def/ServicesVSResources.resx
index 6a1d1178d5642..5e006552b86b9 100644
--- a/src/VisualStudio/Core/Def/ServicesVSResources.resx
+++ b/src/VisualStudio/Core/Def/ServicesVSResources.resx
@@ -1,17 +1,17 @@
 <?xml version="1.0" encoding="utf-8"?>
 <root>
-  <!--
-    Microsoft ResX Schema
-
+  <!-- 
+    Microsoft ResX Schema 
+    
     Version 2.0
-
-    The primary goals of this format is to allow a simple XML format
-    that is mostly human readable. The generation and parsing of the
-    various data types are done through the TypeConverter classes
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
     associated with the data types.
-
+    
     Example:
-
+    
     ... ado.net/XML headers & schema ...
     <resheader name="resmimetype">text/microsoft-resx</resheader>
     <resheader name="version">2.0</resheader>
@@ -26,36 +26,36 @@
         <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
         <comment>This is a comment</comment>
     </data>
-
-    There are any number of "resheader" rows that contain simple
+                
+    There are any number of "resheader" rows that contain simple 
     name/value pairs.
-
-    Each data row contains a name, and value. The row also contains a
-    type or mimetype. Type corresponds to a .NET class that support
-    text/value conversion through the TypeConverter architecture.
-    Classes that don't support this are serialized and stored with the
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
     mimetype set.
-
-    The mimetype is used for serialized objects, and tells the
-    ResXResourceReader how to depersist the object. This is currently not
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
     extensible. For a given mimetype the value must be set accordingly:
-
-    Note - application/x-microsoft.net.object.binary.base64 is the format
-    that the ResXResourceWriter will generate, however the reader can
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
     read any of the formats listed below.
-
+    
     mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with
+    value   : The object must be serialized with 
             : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
             : and then encoded with base64 encoding.
-
+    
     mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with
+    value   : The object must be serialized with 
             : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
             : and then encoded with base64 encoding.
 
     mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array
+    value   : The object must be serialized into a byte array 
             : using a System.ComponentModel.TypeConverter
             : and then encoded with base64 encoding.
     -->
@@ -1900,4 +1900,7 @@ Additional information: {1}</value>
     <value>Automatically open Stack Trace Explorer on focus</value>
     <comment>"Stack Trace Explorer" is a tool window that is owned by the Roslyn package</comment>
   </data>
+  <data name="Prefer_method_group_conversion" xml:space="preserve">
+    <value>Prefer method group conversion</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
index fcd981d487234..91aa6b84acfbc 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
@@ -992,6 +992,11 @@
         <target state="translated">Preferovat operátor indexu</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_method_group_conversion">
+        <source>Prefer method group conversion</source>
+        <target state="new">Prefer method group conversion</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_namespace_and_folder_match_structure">
         <source>Prefer namespace and folder match structure</source>
         <target state="translated">Preferovat strukturu oboru názvů a shody složek</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
index 529459b546735..9214803885316 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
@@ -992,6 +992,11 @@
         <target state="translated">Indexoperator bevorzugen</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_method_group_conversion">
+        <source>Prefer method group conversion</source>
+        <target state="new">Prefer method group conversion</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_namespace_and_folder_match_structure">
         <source>Prefer namespace and folder match structure</source>
         <target state="translated">Namespace- und Ordnerübereinstimmungsstruktur bevorzugen</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
index 1b36dfb32fe2d..95bdc345a9c42 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
@@ -992,6 +992,11 @@
         <target state="translated">Preferir operador de índice</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_method_group_conversion">
+        <source>Prefer method group conversion</source>
+        <target state="new">Prefer method group conversion</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_namespace_and_folder_match_structure">
         <source>Prefer namespace and folder match structure</source>
         <target state="translated">Preferir estructura de coincidencia de espacio de nombres y carpetas</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
index bc379136aefad..c2f98dd332ac2 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
@@ -992,6 +992,11 @@
         <target state="translated">Préférer l'opérateur d'index</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_method_group_conversion">
+        <source>Prefer method group conversion</source>
+        <target state="new">Prefer method group conversion</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_namespace_and_folder_match_structure">
         <source>Prefer namespace and folder match structure</source>
         <target state="translated">Préférer l’espace de noms et la structure de correspondance de dossier</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
index dd280670703ec..7e0d381778a7a 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
@@ -992,6 +992,11 @@
         <target state="translated">Preferisci operatore di indice</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_method_group_conversion">
+        <source>Prefer method group conversion</source>
+        <target state="new">Prefer method group conversion</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_namespace_and_folder_match_structure">
         <source>Prefer namespace and folder match structure</source>
         <target state="translated">Preferire la struttura di corrispondenza spazio dei nomi e cartella</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
index 2b00fdf122d0c..b3100a936ca46 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
@@ -992,6 +992,11 @@
         <target state="translated">インデックス演算子を優先</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_method_group_conversion">
+        <source>Prefer method group conversion</source>
+        <target state="new">Prefer method group conversion</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_namespace_and_folder_match_structure">
         <source>Prefer namespace and folder match structure</source>
         <target state="translated">名前空間とフォルダー一致構造を優先する</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
index 2b2812a9b0524..1db9539ee2c27 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
@@ -992,6 +992,11 @@
         <target state="translated">인덱스 연산자 선호</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_method_group_conversion">
+        <source>Prefer method group conversion</source>
+        <target state="new">Prefer method group conversion</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_namespace_and_folder_match_structure">
         <source>Prefer namespace and folder match structure</source>
         <target state="translated">네임스페이스 및 폴더 일치 구조 선호</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
index 0b0dd74607534..a143d4c773a03 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
@@ -992,6 +992,11 @@
         <target state="translated">Preferuj operator indeksowania</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_method_group_conversion">
+        <source>Prefer method group conversion</source>
+        <target state="new">Prefer method group conversion</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_namespace_and_folder_match_structure">
         <source>Prefer namespace and folder match structure</source>
         <target state="translated">Preferuj strukturę dopasowania przestrzeni nazw i folderów</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
index f52ec924844f0..4197537e2a0d9 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
@@ -992,6 +992,11 @@
         <target state="translated">Preferir operador de índice</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_method_group_conversion">
+        <source>Prefer method group conversion</source>
+        <target state="new">Prefer method group conversion</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_namespace_and_folder_match_structure">
         <source>Prefer namespace and folder match structure</source>
         <target state="translated">Prefira espaço de nomes e estrutura de correspondência de pasta</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
index 91a2006438203..19f9a6da16b0a 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
@@ -992,6 +992,11 @@
         <target state="translated">Предпочитать оператор index</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_method_group_conversion">
+        <source>Prefer method group conversion</source>
+        <target state="new">Prefer method group conversion</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_namespace_and_folder_match_structure">
         <source>Prefer namespace and folder match structure</source>
         <target state="translated">Предпочитать пространство имен и структуру совпадений папок</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
index 6830da5ab9ac3..b85e07a628f81 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
@@ -992,6 +992,11 @@
         <target state="translated">Dizin işlecini tercih et</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_method_group_conversion">
+        <source>Prefer method group conversion</source>
+        <target state="new">Prefer method group conversion</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_namespace_and_folder_match_structure">
         <source>Prefer namespace and folder match structure</source>
         <target state="translated">Ad alanı ve klasör eşleşme yapısını tercih et</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
index 34c3d97eda05d..c2ac3476cd0d5 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
@@ -992,6 +992,11 @@
         <target state="translated">首选索引运算符</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_method_group_conversion">
+        <source>Prefer method group conversion</source>
+        <target state="new">Prefer method group conversion</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_namespace_and_folder_match_structure">
         <source>Prefer namespace and folder match structure</source>
         <target state="translated">首选命名空间和文件夹匹配结构</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
index 5f3d5d4b33555..4ec614b139bc2 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
@@ -992,6 +992,11 @@
         <target state="translated">優先使用索引運算子</target>
         <note />
       </trans-unit>
+      <trans-unit id="Prefer_method_group_conversion">
+        <source>Prefer method group conversion</source>
+        <target state="new">Prefer method group conversion</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Prefer_namespace_and_folder_match_structure">
         <source>Prefer namespace and folder match structure</source>
         <target state="translated">優先使用命名空間和資料夾相符結構</target>
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/CodeStyle/CSharpCodeStyleOptions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/CodeStyle/CSharpCodeStyleOptions.cs
index a1c01a67f7109..0eda8223d9e16 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/CodeStyle/CSharpCodeStyleOptions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/CodeStyle/CSharpCodeStyleOptions.cs
@@ -136,12 +136,6 @@ private static Option2<CodeStyleOption2<string>> CreateOption(
             "csharp_style_prefer_range_operator",
             "TextEditor.CSharp.Specific.PreferRangeOperator");
 
-        public static readonly Option2<CodeStyleOption2<bool>> PreferMethodGroupConversion = CreateOption(
-            CSharpCodeStyleOptionGroups.ExpressionLevelPreferences, nameof(PreferMethodGroupConversion),
-            defaultValue: s_trueWithSilentEnforcement,
-            "csharp_style_prefer_method_group_conversion",
-            "TextEditor.CSharp.Specific.PreferMethodGroupConversion");
-
         public static readonly CodeStyleOption2<ExpressionBodyPreference> NeverWithSilentEnforcement =
             new(ExpressionBodyPreference.Never, NotificationOption2.Silent);
 
@@ -345,6 +339,12 @@ private static Option2<CodeStyleOption2<NamespaceDeclarationPreference>> CreateN
             new(NamespaceDeclarationPreference.BlockScoped, NotificationOption2.Silent),
             "csharp_style_namespace_declarations");
 
+        public static readonly Option2<CodeStyleOption2<bool>> PreferMethodGroupConversion = CreateOption(
+            CSharpCodeStyleOptionGroups.CodeBlockPreferences, nameof(PreferMethodGroupConversion),
+            defaultValue: s_trueWithSilentEnforcement,
+            "csharp_style_prefer_method_group_conversion",
+            "TextEditor.CSharp.Specific.PreferMethodGroupConversion");
+
 #if false
 
         public static readonly Option2<CodeStyleOption2<bool>> VarElsewhere = CreateOption(

From 08752166a533f1014eda0f58a05db1abc27a329f Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Sat, 15 Jan 2022 00:15:57 -0800
Subject: [PATCH 382/444] Add automation object

---
 .../Impl/Options/AutomationObject/AutomationObject.Style.cs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.Style.cs b/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.Style.cs
index f4b23b785a1b0..527c4b7de2e52 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.Style.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.Style.cs
@@ -69,6 +69,12 @@ public string Style_PreferCoalesceExpression
             set { SetXmlOption(CodeStyleOptions2.PreferCoalesceExpression, value); }
         }
 
+        public string Style_PreferMethodGroupConversion
+        {
+            get { return GetXmlOption(CSharpCodeStyleOptions.PreferMethodGroupConversion); }
+            set { SetXmlOption(CSharpCodeStyleOptions.PreferMethodGroupConversion, value); }
+        }
+
         public string Style_PreferNullPropagation
         {
             get { return GetXmlOption(CodeStyleOptions2.PreferNullPropagation); }

From fbf79ae50844b84dc5f5518933e8783039ef5de1 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Sat, 15 Jan 2022 00:57:11 -0800
Subject: [PATCH 383/444] Fix issue with generics

---
 .../RemoveUnnecessaryLambdaExpressionTests.cs | 79 ++++++++++++++++++-
 ...ssaryLambdaExpressionDiagnosticAnalyzer.cs | 11 ++-
 2 files changed, 86 insertions(+), 4 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
index c47ee23a2de37..8195a20c8b739 100644
--- a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
+++ b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
@@ -626,7 +626,7 @@ static void Main()
 
         [WorkItem(542562, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542562")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
-        public async Task TestWithConstraint()
+        public async Task TestWithConstraint1()
         {
             var code = @"
 using System;
@@ -646,7 +646,7 @@ static void Bar(Action<string> x)
 
     static void Main()
     {
-        Bar([|x => |]Goo(x));
+        Bar([|x => |]Goo<string>(x));
     }
 }";
 
@@ -668,12 +668,40 @@ static void Bar(Action<string> x)
 
     static void Main()
     {
-        Bar(Goo);
+        Bar(Goo<string>);
     }
 }";
             await TestInRegularAndScriptAsync(code, expected);
         }
 
+        [WorkItem(542562, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542562")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestWithConstraint2()
+        {
+            var code = @"
+using System;
+class A
+{
+    static void Goo<T>(T x) where T : class
+    {
+    }
+
+    static void Bar(Action<int> x)
+    {
+    }
+
+    static void Bar(Action<string> x)
+    {
+    }
+
+    static void Main()
+    {
+        Bar(x => Goo(x));
+    }
+}";
+            await TestMissingInRegularAndScriptAsync(code);
+        }
+
         [WorkItem(627092, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/627092")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
         public async Task TestMissingOnLambdaWithDynamic_1()
@@ -1302,6 +1330,51 @@ void Goo()
 
     void Bar(Func<int, Task> f) { }
     void Quux(int i) { }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestExplicitGenericCall()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void Goo()
+    {
+        Action a = [|() => |]Quux<int>();
+    }
+
+    void Quux<T>() { }
+}",
+@"using System;
+
+class C
+{
+    void Goo()
+    {
+        Action a = Quux<int>;
+    }
+
+    void Quux<T>() { }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestImplicitGenericCall()
+        {
+            await TestMissingInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void Goo()
+    {
+        Action<int> a = b => Quux(b);
+    }
+
+    void Quux<T>(T t) { }
 }");
         }
     }
diff --git a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
index 4f0adfb161e1c..88a17d76d6d19 100644
--- a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
@@ -86,7 +86,7 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol?
 
             // We have to have an invocation in the lambda like `() => X()` or `() => expr.X()`.
             var invokedExpression = invocation.Expression;
-            if (invokedExpression is not IdentifierNameSyntax and not MemberAccessExpressionSyntax)
+            if (invokedExpression is not SimpleNameSyntax and not MemberAccessExpressionSyntax)
                 return;
 
             // lambda and invocation have to agree on number of parameters.
@@ -126,6 +126,15 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol?
             if (invokedSymbolInfo.Symbol is not IMethodSymbol invokedMethod)
                 return;
 
+            // If we're calling a generic method, we have to have supplied type arguments.  They cannot be inferred once
+            // we remove the arguments during simplification.
+            var invokedTypeArguments = invokedExpression.GetRightmostName() is GenericNameSyntax genericName
+                ? genericName.TypeArgumentList.Arguments
+                : default;
+
+            if (invokedMethod.TypeArguments.Length != invokedTypeArguments.Count)
+                return;
+
             // Methods have to be complimentary.  That means the same number of parameters, with proper
             // co-contravariance for the parameters and return type.
             if (lambdaMethod.Parameters.Length != invokedMethod.Parameters.Length)

From 1f39dfdca83e4ed55af812c298c204bf72f8bc50 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Sat, 15 Jan 2022 01:03:55 -0800
Subject: [PATCH 384/444] Make side effect logic more conservative

---
 ...ssaryLambdaExpressionDiagnosticAnalyzer.cs | 25 ++++++++-----------
 1 file changed, 11 insertions(+), 14 deletions(-)

diff --git a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
index 88a17d76d6d19..82dd83d74411c 100644
--- a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
@@ -160,7 +160,7 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol?
             }
 
             // if we have `() => new C().X()` then converting to `new C().X` very much changes the meaning.
-            if (MayContainSideEffects(invokedExpression))
+            if (MayHaveSideEffects(invokedExpression))
                 return;
 
             // Semantically, this looks good to go.  Now, do an actual speculative replacement to ensure that the
@@ -206,20 +206,17 @@ private static bool IsIdentityOrImplicitConversion(Compilation compilation, ITyp
             return conversion.IsIdentityOrImplicitReference();
         }
 
-        private static bool MayContainSideEffects(ExpressionSyntax expression)
+        private static bool MayHaveSideEffects(ExpressionSyntax expression)
         {
-            // Checks to see if inlining the temporary variable may change the code's semantics. 
-            // This is not meant to be an exhaustive check; it's more like a heuristic for obvious cases we know may cause side effects.
-
-            var descendantNodesAndSelf = expression.DescendantNodesAndSelf();
-
-            if (descendantNodesAndSelf.Any(n => n.IsKind(SyntaxKind.ObjectCreationExpression, SyntaxKind.InvocationExpression)))
-            {
-                return true;
-            }
-
-            // Assume if we reach here that the fix won't cause side effects.
-            return false;
+            // Checks to see if the expression being invoked looks side-effect free.  If so, changing from executing
+            // each time in the lambda to only executing it once could have impact on the program.
+
+            return !expression.DescendantNodesAndSelf().All(
+                n => n is TypeSyntax or
+                          TypeArgumentListSyntax or
+                          MemberAccessExpressionSyntax or
+                          InstanceExpressionSyntax or
+                          LiteralExpressionSyntax);
         }
 
         private static SeparatedSyntaxList<ParameterSyntax> GetParameters(AnonymousFunctionExpressionSyntax expression)

From 2c15ba3eb9fb5171bfb93401cc1b4bc412030078 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Sat, 15 Jan 2022 01:05:06 -0800
Subject: [PATCH 385/444] Fix name

---
 src/Analyzers/Core/CodeFixes/PredefinedCodeFixProviderNames.cs  | 1 +
 .../CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs   | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/Analyzers/Core/CodeFixes/PredefinedCodeFixProviderNames.cs b/src/Analyzers/Core/CodeFixes/PredefinedCodeFixProviderNames.cs
index e84bd13bf549f..94eec78057a11 100644
--- a/src/Analyzers/Core/CodeFixes/PredefinedCodeFixProviderNames.cs
+++ b/src/Analyzers/Core/CodeFixes/PredefinedCodeFixProviderNames.cs
@@ -91,6 +91,7 @@ internal static class PredefinedCodeFixProviderNames
         public const string RemoveUnnecessaryCast = nameof(RemoveUnnecessaryCast);
         public const string RemoveUnnecessaryDiscardDesignation = nameof(RemoveUnnecessaryDiscardDesignation);
         public const string RemoveUnnecessaryImports = nameof(RemoveUnnecessaryImports);
+        public const string RemoveUnnecessaryLambdaExpression = nameof(RemoveUnnecessaryLambdaExpression);
         public const string RemoveUnnecessaryParentheses = nameof(RemoveUnnecessaryParentheses);
         public const string RemoveUnnecessaryPragmaSuppressions = nameof(RemoveUnnecessaryPragmaSuppressions);
         public const string RemoveUnreachableCode = nameof(RemoveUnreachableCode);
diff --git a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs
index a9bbd6bcf43e0..81ca5e3ead6b2 100644
--- a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs
@@ -22,7 +22,7 @@ namespace Microsoft.CodeAnalysis.CSharp.RemoveUnnecessaryLambdaExpression
 {
     using static CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer;
 
-    [ExportCodeFixProvider(LanguageNames.CSharp, Name = PredefinedCodeFixProviderNames.UsePatternMatchingIsAndCastCheckWithoutName), Shared]
+    [ExportCodeFixProvider(LanguageNames.CSharp, Name = PredefinedCodeFixProviderNames.RemoveUnnecessaryLambdaExpression), Shared]
     internal partial class CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider : SyntaxEditorBasedCodeFixProvider
     {
         [ImportingConstructor]

From dcbfda82de7ff976e7a29e716e9ad0feca28390a Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Sat, 15 Jan 2022 01:06:23 -0800
Subject: [PATCH 386/444] Move syntactic check up

---
 ...RemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
index 82dd83d74411c..a7c24160c2f46 100644
--- a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
@@ -94,6 +94,10 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol?
             if (parameters.Count != invocation.ArgumentList.Arguments.Count)
                 return;
 
+            // if we have `() => new C().X()` then converting to `new C().X` very much changes the meaning.
+            if (MayHaveSideEffects(invokedExpression))
+                return;
+
             // parameters must be passed 1:1 from lambda to invocation.
             for (int i = 0, n = parameters.Count - 1; i < n; i++)
             {
@@ -159,10 +163,6 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol?
                     return;
             }
 
-            // if we have `() => new C().X()` then converting to `new C().X` very much changes the meaning.
-            if (MayHaveSideEffects(invokedExpression))
-                return;
-
             // Semantically, this looks good to go.  Now, do an actual speculative replacement to ensure that the
             // non-invoked method reference refers to the same method symbol, and that it converts to the same type that
             // the lambda was.

From 07591bb7ed8359f0c868646a5d8ac83a78c83555 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Sat, 15 Jan 2022 01:06:37 -0800
Subject: [PATCH 387/444] Move syntactic check up

---
 ...RemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
index a7c24160c2f46..7e749ef13fbd5 100644
--- a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
@@ -94,10 +94,6 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol?
             if (parameters.Count != invocation.ArgumentList.Arguments.Count)
                 return;
 
-            // if we have `() => new C().X()` then converting to `new C().X` very much changes the meaning.
-            if (MayHaveSideEffects(invokedExpression))
-                return;
-
             // parameters must be passed 1:1 from lambda to invocation.
             for (int i = 0, n = parameters.Count - 1; i < n; i++)
             {
@@ -111,6 +107,10 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol?
                     return;
             }
 
+            // if we have `() => new C().X()` then converting to `new C().X` very much changes the meaning.
+            if (MayHaveSideEffects(invokedExpression))
+                return;
+
             // Looks like a reasonable candidate to simplify.  Now switch to semantics to check for sure.
 
             if (CSharpSemanticFactsService.Instance.IsInExpressionTree(semanticModel, anonymousFunction, expressionType, cancellationToken))

From f03db31727b5f282c282c4af4d41fc43120db8a7 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Sat, 15 Jan 2022 11:51:20 -0800
Subject: [PATCH 388/444] Add test

---
 .../RemoveUnnecessaryLambdaExpressionTests.cs | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
index 8195a20c8b739..b8fcd4cab6b45 100644
--- a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
+++ b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
@@ -1377,5 +1377,47 @@ void Goo()
     void Quux<T>(T t) { }
 }");
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestNullabilityChanges()
+        {
+            await TestMissingInRegularAndScriptAsync(
+@"
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+class C
+{
+    void Goo(List<string> assemblies, HashSet<string> usedProjectFileNames)
+    {
+        var projectAssemblyFileNames = Select(assemblies, a => GetFileName(a));
+        var v = Any(projectAssemblyFileNames, usedProjectFileNames.Contains);
+    }
+
+    static List<TResult> Select<TItem, TResult>(List<TItem> items, Func<TItem, TResult> map) => new();
+
+    [return: NotNullIfNotNull(""path"")]
+    static string? GetFileName(string? path) => path;
+
+    static bool Any<T>(List<T> immutableArray, Func<T, bool> predicate) => true;
+}
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    [AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
+    public sealed class NotNullIfNotNullAttribute : Attribute
+    {
+        public string ParameterName => """";
+
+        public NotNullIfNotNullAttribute(string parameterName)
+        {
+        }
+    }
+}
+");
+        }
     }
 }

From 70a2a1f6412ebc16c4c157f736d9c665fdbec767 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Sat, 15 Jan 2022 12:16:06 -0800
Subject: [PATCH 389/444] Make sure overloads don't change

---
 .../RemoveUnnecessaryLambdaExpressionTests.cs | 17 ++-------
 ...ssaryLambdaExpressionDiagnosticAnalyzer.cs | 35 +++++++++++++++++++
 2 files changed, 37 insertions(+), 15 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
index b8fcd4cab6b45..df67e4e589491 100644
--- a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
+++ b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
@@ -1221,20 +1221,7 @@ void Bar(Func<int, Task> f) { }
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
         public async Task TestTask1_ExpressionStatement()
         {
-            await TestInRegularAndScriptAsync(
-@"using System;
-using System.Threading.Tasks;
-
-class C
-{
-    void Goo()
-    {
-        Bar([|s {|CS1643:=>|} { |]Quux(s); });
-    }
-
-    void Bar(Func<int, Task> f) { }
-    Task Quux(int i) => default;
-}",
+            await TestMissingInRegularAndScriptAsync(
 @"using System;
 using System.Threading.Tasks;
 
@@ -1242,7 +1229,7 @@ class C
 {
     void Goo()
     {
-        Bar(Quux);
+        Bar(s {|CS1643:=>|} { Quux(s); });
     }
 
     void Bar(Func<int, Task> f) { }
diff --git a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
index 7e749ef13fbd5..7c534c4e61d5b 100644
--- a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
@@ -5,6 +5,7 @@
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
@@ -182,6 +183,13 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol?
             if (!lambdaTypeInfo.ConvertedType.Equals(rewrittenConvertedType))
                 return;
 
+            if (OverloadsChanged(
+                    semanticModel, anonymousFunction.GetRequiredParent(),
+                    rewrittenSemanticModel, rewrittenExpression.GetRequiredParent(), cancellationToken))
+            {
+                return;
+            }
+
             var startReportSpan = TextSpan.FromBounds(anonymousFunction.SpanStart, invokedExpression.SpanStart);
             var endReportSpan = TextSpan.FromBounds(invokedExpression.Span.End, anonymousFunction.Span.End);
 
@@ -195,6 +203,33 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol?
                     syntaxTree.GetLocation(endReportSpan))));
         }
 
+        private static bool OverloadsChanged(
+            SemanticModel semanticModel1,
+            SyntaxNode? node1,
+            SemanticModel semanticModel2,
+            SyntaxNode? node2,
+            CancellationToken cancellationToken)
+        {
+            while (node1 != null && node2 != null)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                var method1 = semanticModel1.GetSymbolInfo(node1, cancellationToken).Symbol as IMethodSymbol;
+                var method2 = semanticModel2.GetSymbolInfo(node2, cancellationToken).Symbol as IMethodSymbol;
+
+                if (method1 is null != method2 is null)
+                    return true;
+
+                if (method1 is not null && !method1.Equals(method2, SymbolEqualityComparer.IncludeNullability))
+                    return true;
+
+                node1 = node1.Parent;
+                node2 = node2.Parent;
+            }
+
+            return false;
+        }
+
         private static bool IsIdentityOrImplicitConversion(Compilation compilation, ITypeSymbol type1, ITypeSymbol type2)
         {
             // Dynamic can have an identity conversion between types.  But it can have a very different effect on the

From 754b6d7955a001357a16cd30a69492c4fdaf0299 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Sat, 15 Jan 2022 12:17:54 -0800
Subject: [PATCH 390/444] Extend comment

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

diff --git a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
index 7c534c4e61d5b..f97f4ce2afb97 100644
--- a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
@@ -118,7 +118,8 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol?
                 return;
 
             // If we have `object obj = x => Goo(x);` we don't want to simplify.  The compiler warns if you write
-            // `object obj = Goo;` because of the conversion to a non-delegate type.
+            // `object obj = Goo;` because of the conversion to a non-delegate type. While we could insert a cast here
+            // to make this work, that goes against the spirit of this analyzer/fixer just removing code.
             var lambdaTypeInfo = semanticModel.GetTypeInfo(anonymousFunction, cancellationToken);
             if (lambdaTypeInfo.ConvertedType == null || lambdaTypeInfo.ConvertedType.SpecialType is SpecialType.System_Object)
                 return;

From a3505be3bbde940e19624e2d4373b8f68feb51bc Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Sat, 15 Jan 2022 12:23:07 -0800
Subject: [PATCH 391/444] Fix test

---
 .../Core/Test/Options/CSharpEditorConfigGeneratorTests.vb       | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/VisualStudio/Core/Test/Options/CSharpEditorConfigGeneratorTests.vb b/src/VisualStudio/Core/Test/Options/CSharpEditorConfigGeneratorTests.vb
index 0fd050a669a7b..9cd8b5dd4b538 100644
--- a/src/VisualStudio/Core/Test/Options/CSharpEditorConfigGeneratorTests.vb
+++ b/src/VisualStudio/Core/Test/Options/CSharpEditorConfigGeneratorTests.vb
@@ -128,6 +128,7 @@ csharp_preferred_modifier_order = public,private,protected,internal,static,exter
 csharp_prefer_braces = true
 csharp_prefer_simple_using_statement = true
 csharp_style_namespace_declarations = block_scoped
+csharp_style_prefer_method_group_conversion = true
 
 # Expression-level preferences
 csharp_prefer_simple_default_expression = true
@@ -362,6 +363,7 @@ csharp_preferred_modifier_order = public,private,protected,internal,static,exter
 csharp_prefer_braces = true
 csharp_prefer_simple_using_statement = true
 csharp_style_namespace_declarations = block_scoped
+csharp_style_prefer_method_group_conversion = true
 
 # Expression-level preferences
 csharp_prefer_simple_default_expression = true

From faf4bc52d3033192993751f3fd71c760abb78964 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Sat, 15 Jan 2022 12:25:47 -0800
Subject: [PATCH 392/444] Fix test

---
 .../Test/Diagnostics/IDEDiagnosticIDConfigurationTests.cs   | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/EditorFeatures/Test/Diagnostics/IDEDiagnosticIDConfigurationTests.cs b/src/EditorFeatures/Test/Diagnostics/IDEDiagnosticIDConfigurationTests.cs
index 5d8b95a977999..f565458cb4cc7 100644
--- a/src/EditorFeatures/Test/Diagnostics/IDEDiagnosticIDConfigurationTests.cs
+++ b/src/EditorFeatures/Test/Diagnostics/IDEDiagnosticIDConfigurationTests.cs
@@ -432,6 +432,9 @@ public void CSharp_VerifyIDEDiagnosticSeveritiesAreConfigurable()
 # IDE0190
 dotnet_diagnostic.IDE0190.severity = %value%
 
+# IDE0200
+dotnet_diagnostic.IDE0200.severity = %value%
+
 # IDE2000
 dotnet_diagnostic.IDE2000.severity = %value%
 
@@ -1016,6 +1019,9 @@ No editorconfig based code style option
 # IDE0190, PreferParameterNullChecking
 csharp_style_prefer_parameter_null_checking = true
 
+# IDE0200, PreferMethodGroupConversion
+csharp_style_prefer_method_group_conversion = true
+
 # IDE1005, PreferConditionalDelegateCall
 csharp_style_conditional_delegate_call = true
 

From c9e01a150631cfd5ee91fc6c7f34f910f6855ccc Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Sat, 15 Jan 2022 12:29:50 -0800
Subject: [PATCH 393/444] Fix editorconfig

---
 .../DataProvider/CodeStyle/CSharpCodeStyleSettingsProvider.cs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/VisualStudio/CSharp/Impl/EditorConfigSettings/DataProvider/CodeStyle/CSharpCodeStyleSettingsProvider.cs b/src/VisualStudio/CSharp/Impl/EditorConfigSettings/DataProvider/CodeStyle/CSharpCodeStyleSettingsProvider.cs
index 5a391c3d78d37..7b370876367e7 100644
--- a/src/VisualStudio/CSharp/Impl/EditorConfigSettings/DataProvider/CodeStyle/CSharpCodeStyleSettingsProvider.cs
+++ b/src/VisualStudio/CSharp/Impl/EditorConfigSettings/DataProvider/CodeStyle/CSharpCodeStyleSettingsProvider.cs
@@ -136,6 +136,10 @@ private IEnumerable<CodeStyleSetting> GetCodeBlockCodeStyleOptions(AnalyzerConfi
                 valueDescriptions: new[] { CSharpVSResources.Block_scoped, CSharpVSResources.File_scoped },
                 editorConfigOptions: editorConfigOptions, visualStudioOptions: visualStudioOptions, updater: updaterService, fileName: FileName);
 
+            yield return CodeStyleSetting.Create(option: CSharpCodeStyleOptions.PreferMethodGroupConversion,
+                description: ServicesVSResources.Prefer_method_group_conversion,
+                editorConfigOptions: editorConfigOptions,
+                visualStudioOptions: visualStudioOptions, updater: updaterService, fileName: FileName);
         }
 
         private IEnumerable<CodeStyleSetting> GetExpressionCodeStyleOptions(AnalyzerConfigOptions editorConfigOptions, OptionSet visualStudioOptions, OptionUpdater updaterService)

From aab79517ddcc5e33ac9fac088e168b393245c07f Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Sat, 15 Jan 2022 12:48:05 -0800
Subject: [PATCH 394/444] Fix off by one

---
 .../RemoveUnnecessaryLambdaExpressionTests.cs | 54 +++++++++++++++++++
 ...ssaryLambdaExpressionDiagnosticAnalyzer.cs |  2 +-
 2 files changed, 55 insertions(+), 1 deletion(-)

diff --git a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
index df67e4e589491..60095aaba59fe 100644
--- a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
+++ b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
@@ -527,6 +527,60 @@ void Goo()
         Bar(Quux);
     }
 
+    void Bar(Func<int, bool, string> f) { }
+    string Quux(int i, bool b) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestMultipleArgIncorrectPassing1()
+        {
+            await TestMissingInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void Goo()
+    {
+        Bar((s1, s2) => Quux(s2, s1));
+    }
+
+    void Bar(Func<int, int, string> f) { }
+    string Quux(int i, int b) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestMultipleArgIncorrectPassing2()
+        {
+            await TestMissingInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void Goo()
+    {
+        Bar((s1, s2) => Quux(s1, s1));
+    }
+
+    void Bar(Func<int, int, string> f) { }
+    string Quux(int i, int b) => default;
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestMultipleArgIncorrectPassing3()
+        {
+            await TestMissingInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void Goo()
+    {
+        Bar((s1, s2) => Quux(s1, true));
+    }
+
     void Bar(Func<int, bool, string> f) { }
     string Quux(int i, bool b) => default;
 }");
diff --git a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
index f97f4ce2afb97..c0e73fa615b30 100644
--- a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
@@ -96,7 +96,7 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol?
                 return;
 
             // parameters must be passed 1:1 from lambda to invocation.
-            for (int i = 0, n = parameters.Count - 1; i < n; i++)
+            for (int i = 0, n = parameters.Count; i < n; i++)
             {
                 var parameter = parameters[i];
                 var argument = invocation.ArgumentList.Arguments[i];

From a38107f3bf6fbaff7d8a9929a61ed1b13e23296c Mon Sep 17 00:00:00 2001
From: Andrew Hall <andrha@microsoft.com>
Date: Sun, 16 Jan 2022 16:11:58 -0800
Subject: [PATCH 395/444] Add Stack Trace Explorer to our searchable options
 (#58869)

---
 src/VisualStudio/CSharp/Impl/Options/Readme.md      | 13 +++++++++++++
 src/VisualStudio/CSharp/Impl/VSPackage.resx         |  3 ++-
 src/VisualStudio/CSharp/Impl/xlf/VSPackage.cs.xlf   |  5 +++--
 src/VisualStudio/CSharp/Impl/xlf/VSPackage.de.xlf   |  5 +++--
 src/VisualStudio/CSharp/Impl/xlf/VSPackage.es.xlf   |  5 +++--
 src/VisualStudio/CSharp/Impl/xlf/VSPackage.fr.xlf   |  5 +++--
 src/VisualStudio/CSharp/Impl/xlf/VSPackage.it.xlf   |  5 +++--
 src/VisualStudio/CSharp/Impl/xlf/VSPackage.ja.xlf   |  5 +++--
 src/VisualStudio/CSharp/Impl/xlf/VSPackage.ko.xlf   |  5 +++--
 src/VisualStudio/CSharp/Impl/xlf/VSPackage.pl.xlf   |  5 +++--
 .../CSharp/Impl/xlf/VSPackage.pt-BR.xlf             |  5 +++--
 src/VisualStudio/CSharp/Impl/xlf/VSPackage.ru.xlf   |  5 +++--
 src/VisualStudio/CSharp/Impl/xlf/VSPackage.tr.xlf   |  5 +++--
 .../CSharp/Impl/xlf/VSPackage.zh-Hans.xlf           |  5 +++--
 .../CSharp/Impl/xlf/VSPackage.zh-Hant.xlf           |  5 +++--
 15 files changed, 54 insertions(+), 27 deletions(-)
 create mode 100644 src/VisualStudio/CSharp/Impl/Options/Readme.md

diff --git a/src/VisualStudio/CSharp/Impl/Options/Readme.md b/src/VisualStudio/CSharp/Impl/Options/Readme.md
new file mode 100644
index 0000000000000..82e0a0f21f910
--- /dev/null
+++ b/src/VisualStudio/CSharp/Impl/Options/Readme.md
@@ -0,0 +1,13 @@
+# Adding Options
+
+To add an option to the options page, follow these instructions.
+
+1. Determine what page it goes on (Advanced Options, IntelliSenseOptions, NamingStyles, etc)
+2. Add the control to the appropriate xaml file
+3. Bind the control in the backing cs file. Example from [AdvancedOptionPageControl](https://github.com/dotnet/roslyn/blob/591e899025f1d4cf9bbb6e9af3ef82506b46f501/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs#L43)
+```csharp
+// BindToOption helper binds known controls, in this case "PlaceSystemNamespaceFirst"
+// to the backing "GenerationOptions.PlaceSystemNamespaceFirst" for the language "CSharp"
+BindToOption(PlaceSystemNamespaceFirst, GenerationOptions.PlaceSystemNamespaceFirst, LanguageNames.CSharp);
+```
+4. If you want the option to be searchable in the search bar, add to [VSPackage.resx](https://github.com/dotnet/roslyn/blob/591e899025f1d4cf9bbb6e9af3ef82506b46f501/src/VisualStudio/CSharp/Impl/VSPackage.resx) in the appropriate block. Each block of terms has a comment describing what page it's for.
diff --git a/src/VisualStudio/CSharp/Impl/VSPackage.resx b/src/VisualStudio/CSharp/Impl/VSPackage.resx
index dd11388e0fa0c..3e030c6f1a6e0 100644
--- a/src/VisualStudio/CSharp/Impl/VSPackage.resx
+++ b/src/VisualStudio/CSharp/Impl/VSPackage.resx
@@ -191,7 +191,8 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</value>
+Inheritance Margin;
+Stack Trace Explorer;</value>
     <comment>C# Advanced options page keywords</comment>
   </data>
   <data name="307" xml:space="preserve">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.cs.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.cs.xlf
index 4a962af9237f0..c49074031cdfd 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.cs.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.cs.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">Podtrhnout znovu přiřazené proměnné;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">Podtrhnout znovu přiřazené proměnné;
 Zobrazovat vložené nápovědy;
 Zobrazit diagnostiku pro zavřené soubory;
 Vybarvit regulární výraz;
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.de.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.de.xlf
index cdcffac650c01..1fed08b1cf25e 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.de.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.de.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">Neu zugewiesene Variablen unterstreichen;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">Neu zugewiesene Variablen unterstreichen;
 Inlinehinweise anzeigen;
 Diagnoseinformationen für geschlossene Dateien anzeigen;
 Reguläre Ausdrücke farbig hervorheben;
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.es.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.es.xlf
index f2b956dcf038d..181691d7fab3e 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.es.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.es.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">Subrayar variables reasignadas;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">Subrayar variables reasignadas;
 Mostrar sugerencias insertadas;
 Mostrar diagnóstico para archivos cerrados;
 Colorear expresión regular;
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.fr.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.fr.xlf
index 80973c927a777..7024d2f2729f4 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.fr.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.fr.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">Souligner les variables réaffectées;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">Souligner les variables réaffectées;
 Afficher les indicateurs inline;
 Afficher les diagnostics pour les fichiers fermés;
 Mettre en couleurs l'expression régulière; 
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.it.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.it.xlf
index 45c52df88d926..28a178377a0dd 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.it.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.it.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">Sottolinea variabili riassegnate;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">Sottolinea variabili riassegnate;
 Visualizza suggerimenti inline;
 Mostra diagnostica per file chiusi;
 Colora espressione regolare;
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ja.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ja.xlf
index 859dec89df363..aed128247de03 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ja.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ja.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">再割り当てされる変数に下線を引く;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">再割り当てされる変数に下線を引く;
 インラインのヒントを表示する;
 閉じているファイルの診断結果を表示する;
 正規表現をカラー化する;
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ko.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ko.xlf
index 9c983ca43da96..2ea02da1708ac 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ko.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ko.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">다시 할당된 변수에 밑줄 긋기;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">다시 할당된 변수에 밑줄 긋기;
 인라인 힌트 표시;
 닫힌 파일에 대한 진단 표시;
 정규식 색 지정; 
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pl.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pl.xlf
index ee5998ecfb005..38021f4dfbac2 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pl.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pl.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">Podkreślaj ponownie przypisane zmienne;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">Podkreślaj ponownie przypisane zmienne;
 Wyświetlaj wskazówki w tekście;
 Pokaż dane diagnostyczne dla zamkniętych plików;
 Koloruj wyrażenia regularne; 
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pt-BR.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pt-BR.xlf
index 4edf5b475cde9..a8bda4bd55e01 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pt-BR.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pt-BR.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">Variáveis reatribuídas de sublinhado;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">Variáveis reatribuídas de sublinhado;
 Exibir as dicas embutidas;
 Mostrar os diagnósticos de arquivos fechados;
 Colorir a expressão regular; 
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ru.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ru.xlf
index df37718f316be..ea30c9ca9f704 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ru.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ru.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">Подчеркивать переназначенные переменные;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">Подчеркивать переназначенные переменные;
 Показывать встроенные подсказки;
 Показывать диагностику для закрытых файлов;
 Выделять регулярные выражения;
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.tr.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.tr.xlf
index 13a6dbd572bf5..4dd59d80d97bb 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.tr.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.tr.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">Yeniden atanan değişkenleri altını çiz;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">Yeniden atanan değişkenleri altını çiz;
 Satır içi ipuçlarını göster;
 Kapatılan dosyalara ilişkin tanılamaları göster;
 Normal ifadeyi renklendir; 
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hans.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hans.xlf
index 2971389876885..fbb81954efc1d 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hans.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hans.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">为重新分配变量添加下划线;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">为重新分配变量添加下划线;
 显示内联提示;
 显示对已关闭文件的诊断;
 对正则表达式着色;
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hant.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hant.xlf
index 75c3cb917183e..e3d46fde4415c 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hant.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hant.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">為重新指派的變數加上底線;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">為重新指派的變數加上底線;
 顯示內嵌提示;
 顯示已關閉檔案的診斷;
 為規則運算式添加色彩; 

From 41d21e73f5b5e7b09ffc2b7dde44be6ed40579ba Mon Sep 17 00:00:00 2001
From: Andrew Hall <andrha@microsoft.com>
Date: Sun, 16 Jan 2022 18:12:14 -0800
Subject: [PATCH 396/444] Cherry-Pick  58869 (#58892)

original PR: #58869
---
 src/VisualStudio/CSharp/Impl/Options/Readme.md      | 13 +++++++++++++
 src/VisualStudio/CSharp/Impl/VSPackage.resx         |  3 ++-
 src/VisualStudio/CSharp/Impl/xlf/VSPackage.cs.xlf   |  5 +++--
 src/VisualStudio/CSharp/Impl/xlf/VSPackage.de.xlf   |  5 +++--
 src/VisualStudio/CSharp/Impl/xlf/VSPackage.es.xlf   |  5 +++--
 src/VisualStudio/CSharp/Impl/xlf/VSPackage.fr.xlf   |  5 +++--
 src/VisualStudio/CSharp/Impl/xlf/VSPackage.it.xlf   |  5 +++--
 src/VisualStudio/CSharp/Impl/xlf/VSPackage.ja.xlf   |  5 +++--
 src/VisualStudio/CSharp/Impl/xlf/VSPackage.ko.xlf   |  5 +++--
 src/VisualStudio/CSharp/Impl/xlf/VSPackage.pl.xlf   |  5 +++--
 .../CSharp/Impl/xlf/VSPackage.pt-BR.xlf             |  5 +++--
 src/VisualStudio/CSharp/Impl/xlf/VSPackage.ru.xlf   |  5 +++--
 src/VisualStudio/CSharp/Impl/xlf/VSPackage.tr.xlf   |  5 +++--
 .../CSharp/Impl/xlf/VSPackage.zh-Hans.xlf           |  5 +++--
 .../CSharp/Impl/xlf/VSPackage.zh-Hant.xlf           |  5 +++--
 15 files changed, 54 insertions(+), 27 deletions(-)
 create mode 100644 src/VisualStudio/CSharp/Impl/Options/Readme.md

diff --git a/src/VisualStudio/CSharp/Impl/Options/Readme.md b/src/VisualStudio/CSharp/Impl/Options/Readme.md
new file mode 100644
index 0000000000000..82e0a0f21f910
--- /dev/null
+++ b/src/VisualStudio/CSharp/Impl/Options/Readme.md
@@ -0,0 +1,13 @@
+# Adding Options
+
+To add an option to the options page, follow these instructions.
+
+1. Determine what page it goes on (Advanced Options, IntelliSenseOptions, NamingStyles, etc)
+2. Add the control to the appropriate xaml file
+3. Bind the control in the backing cs file. Example from [AdvancedOptionPageControl](https://github.com/dotnet/roslyn/blob/591e899025f1d4cf9bbb6e9af3ef82506b46f501/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs#L43)
+```csharp
+// BindToOption helper binds known controls, in this case "PlaceSystemNamespaceFirst"
+// to the backing "GenerationOptions.PlaceSystemNamespaceFirst" for the language "CSharp"
+BindToOption(PlaceSystemNamespaceFirst, GenerationOptions.PlaceSystemNamespaceFirst, LanguageNames.CSharp);
+```
+4. If you want the option to be searchable in the search bar, add to [VSPackage.resx](https://github.com/dotnet/roslyn/blob/591e899025f1d4cf9bbb6e9af3ef82506b46f501/src/VisualStudio/CSharp/Impl/VSPackage.resx) in the appropriate block. Each block of terms has a comment describing what page it's for.
diff --git a/src/VisualStudio/CSharp/Impl/VSPackage.resx b/src/VisualStudio/CSharp/Impl/VSPackage.resx
index dd11388e0fa0c..3e030c6f1a6e0 100644
--- a/src/VisualStudio/CSharp/Impl/VSPackage.resx
+++ b/src/VisualStudio/CSharp/Impl/VSPackage.resx
@@ -191,7 +191,8 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</value>
+Inheritance Margin;
+Stack Trace Explorer;</value>
     <comment>C# Advanced options page keywords</comment>
   </data>
   <data name="307" xml:space="preserve">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.cs.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.cs.xlf
index 4a962af9237f0..c49074031cdfd 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.cs.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.cs.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">Podtrhnout znovu přiřazené proměnné;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">Podtrhnout znovu přiřazené proměnné;
 Zobrazovat vložené nápovědy;
 Zobrazit diagnostiku pro zavřené soubory;
 Vybarvit regulární výraz;
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.de.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.de.xlf
index cdcffac650c01..1fed08b1cf25e 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.de.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.de.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">Neu zugewiesene Variablen unterstreichen;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">Neu zugewiesene Variablen unterstreichen;
 Inlinehinweise anzeigen;
 Diagnoseinformationen für geschlossene Dateien anzeigen;
 Reguläre Ausdrücke farbig hervorheben;
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.es.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.es.xlf
index f2b956dcf038d..181691d7fab3e 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.es.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.es.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">Subrayar variables reasignadas;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">Subrayar variables reasignadas;
 Mostrar sugerencias insertadas;
 Mostrar diagnóstico para archivos cerrados;
 Colorear expresión regular;
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.fr.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.fr.xlf
index 80973c927a777..7024d2f2729f4 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.fr.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.fr.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">Souligner les variables réaffectées;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">Souligner les variables réaffectées;
 Afficher les indicateurs inline;
 Afficher les diagnostics pour les fichiers fermés;
 Mettre en couleurs l'expression régulière; 
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.it.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.it.xlf
index 45c52df88d926..28a178377a0dd 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.it.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.it.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">Sottolinea variabili riassegnate;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">Sottolinea variabili riassegnate;
 Visualizza suggerimenti inline;
 Mostra diagnostica per file chiusi;
 Colora espressione regolare;
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ja.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ja.xlf
index 859dec89df363..aed128247de03 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ja.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ja.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">再割り当てされる変数に下線を引く;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">再割り当てされる変数に下線を引く;
 インラインのヒントを表示する;
 閉じているファイルの診断結果を表示する;
 正規表現をカラー化する;
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ko.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ko.xlf
index c44ad75ca228c..07d63f3ab1ef3 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ko.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ko.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">다시 할당된 변수에 밑줄 긋기;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">다시 할당된 변수에 밑줄 긋기;
 인라인 힌트 표시;
 닫힌 파일에 대한 진단 표시;
 정규식 색 지정; 
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pl.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pl.xlf
index ee5998ecfb005..38021f4dfbac2 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pl.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pl.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">Podkreślaj ponownie przypisane zmienne;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">Podkreślaj ponownie przypisane zmienne;
 Wyświetlaj wskazówki w tekście;
 Pokaż dane diagnostyczne dla zamkniętych plików;
 Koloruj wyrażenia regularne; 
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pt-BR.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pt-BR.xlf
index 4edf5b475cde9..a8bda4bd55e01 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pt-BR.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pt-BR.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">Variáveis reatribuídas de sublinhado;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">Variáveis reatribuídas de sublinhado;
 Exibir as dicas embutidas;
 Mostrar os diagnósticos de arquivos fechados;
 Colorir a expressão regular; 
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ru.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ru.xlf
index df37718f316be..ea30c9ca9f704 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ru.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ru.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">Подчеркивать переназначенные переменные;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">Подчеркивать переназначенные переменные;
 Показывать встроенные подсказки;
 Показывать диагностику для закрытых файлов;
 Выделять регулярные выражения;
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.tr.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.tr.xlf
index 13a6dbd572bf5..4dd59d80d97bb 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.tr.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.tr.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">Yeniden atanan değişkenleri altını çiz;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">Yeniden atanan değişkenleri altını çiz;
 Satır içi ipuçlarını göster;
 Kapatılan dosyalara ilişkin tanılamaları göster;
 Normal ifadeyi renklendir; 
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hans.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hans.xlf
index 2971389876885..fbb81954efc1d 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hans.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hans.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">为重新分配变量添加下划线;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">为重新分配变量添加下划线;
 显示内联提示;
 显示对已关闭文件的诊断;
 对正则表达式着色;
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hant.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hant.xlf
index 75c3cb917183e..e3d46fde4415c 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hant.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hant.xlf
@@ -82,8 +82,9 @@ regex;
 regular expression;
 Use enhanced colors;
 Editor Color Scheme;
-Inheritance Margin;</source>
-        <target state="translated">為重新指派的變數加上底線;
+Inheritance Margin;
+Stack Trace Explorer;</source>
+        <target state="needs-review-translation">為重新指派的變數加上底線;
 顯示內嵌提示;
 顯示已關閉檔案的診斷;
 為規則運算式添加色彩; 

From 0c0a1deb7ed6df047fa2e5dee549eb6387e889f4 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Sun, 16 Jan 2022 22:13:20 -0800
Subject: [PATCH 397/444] Make helper

---
 ...SharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs | 3 ++-
 .../Compiler/CSharp/Extensions/LanguageVersionExtensions.cs    | 3 +++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
index c0e73fa615b30..d671d0fd86649 100644
--- a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
@@ -10,6 +10,7 @@
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
+using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CSharp.Utilities;
 using Microsoft.CodeAnalysis.Diagnostics;
@@ -45,7 +46,7 @@ protected override void InitializeWorker(AnalysisContext context)
         {
             context.RegisterCompilationStartAction(context =>
             {
-                if (((CSharpCompilation)context.Compilation).LanguageVersion >= LanguageVersion.Preview)
+                if (((CSharpCompilation)context.Compilation).LanguageVersion.IsCSharp11OrAbove())
                 {
                     var expressionType = context.Compilation.ExpressionOfTType();
                     context.RegisterSyntaxNodeAction(
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/LanguageVersionExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/LanguageVersionExtensions.cs
index 67faee49d91e6..0094c1e878947 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/LanguageVersionExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/LanguageVersionExtensions.cs
@@ -12,6 +12,9 @@ public static bool IsCSharp9OrAbove(this LanguageVersion languageVersion)
         public static bool IsCSharp10OrAbove(this LanguageVersion languageVersion)
             => languageVersion >= LanguageVersion.CSharp10;
 
+        public static bool IsCSharp11OrAbove(this LanguageVersion languageVersion)
+            => languageVersion >= LanguageVersion.Preview;
+
         public static bool HasConstantInterpolatedStrings(this LanguageVersion languageVersion)
             => languageVersion.IsCSharp10OrAbove();
 

From 767e2d0396eec4e8b1d697653d495388f657b0c2 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Sun, 16 Jan 2022 22:25:59 -0800
Subject: [PATCH 398/444] Introduce helpers

---
 .../ConvertNamespace/ConvertNamespaceAnalysis.cs   |  2 +-
 ...ementToExpressionDiagnosticAnalyzer.Analyzer.cs |  3 +--
 ...witchStatementToExpressionDiagnosticAnalyzer.cs |  5 ++---
 .../MakeLocalFunctionStaticDiagnosticAnalyzer.cs   |  5 ++---
 ...ecessaryDiscardDesignationDiagnosticAnalyzer.cs |  5 ++---
 ...arpSimplifyPropertyPatternDiagnosticAnalyzer.cs |  3 ++-
 .../CSharpUseAutoPropertyAnalyzer.cs               |  5 +++--
 ...rpUseCollectionInitializerDiagnosticAnalyzer.cs |  3 ++-
 ...ForCastAndEqualityOperatorDiagnosticAnalyzer.cs |  5 ++---
 ...ullCheckForReferenceEqualsDiagnosticAnalyzer.cs |  4 ++--
 ...pUseNullCheckOverTypeCheckDiagnosticAnalyzer.cs |  5 ++---
 .../CSharpUseLocalFunctionDiagnosticAnalyzer.cs    |  2 +-
 .../CSharpUseNullPropagationDiagnosticAnalyzer.cs  |  2 +-
 ...CSharpUseObjectInitializerDiagnosticAnalyzer.cs |  2 +-
 .../CSharpUseNotPatternDiagnosticAnalyzer.cs       |  2 +-
 .../CSharpUseThrowExpressionDiagnosticAnalyzer.cs  |  2 +-
 .../CSharpUseTupleSwapDiagnosticAnalyzer.cs        |  2 +-
 .../CSharpRemoveUnusedValuesCodeFixProvider.cs     |  2 +-
 ...IsNullCheckForReferenceEqualsCodeFixProvider.cs |  3 +--
 ...harpConvertIfToSwitchCodeRefactoringProvider.cs |  5 +++--
 .../CSharpUseAutoPropertyCodeFixProvider.cs        |  2 +-
 .../CSharp/CSharpCompilerExtensions.projitems      |  2 ++
 .../CSharp/Extensions/CompilationExtensions.cs     | 12 ++++++++++++
 .../CSharp/Extensions/LanguageVersionExtensions.cs |  8 +-------
 .../CSharp/Extensions/ParseOptionsExtensions.cs    | 12 ++++++++++++
 .../CSharp/Extensions/SyntaxTreeExtensions.cs      |  1 +
 .../Services/SyntaxFacts/CSharpSyntaxFacts.cs      | 14 +++++++-------
 .../Simplification/Simplifiers/CastSimplifier.cs   |  2 +-
 .../LanguageServices/CSharpSemanticFactsService.cs |  2 +-
 29 files changed, 70 insertions(+), 52 deletions(-)
 create mode 100644 src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/CompilationExtensions.cs
 create mode 100644 src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ParseOptionsExtensions.cs

diff --git a/src/Analyzers/CSharp/Analyzers/ConvertNamespace/ConvertNamespaceAnalysis.cs b/src/Analyzers/CSharp/Analyzers/ConvertNamespace/ConvertNamespaceAnalysis.cs
index a605d1b98802a..7d3ca5eea80b3 100644
--- a/src/Analyzers/CSharp/Analyzers/ConvertNamespace/ConvertNamespaceAnalysis.cs
+++ b/src/Analyzers/CSharp/Analyzers/ConvertNamespace/ConvertNamespaceAnalysis.cs
@@ -48,7 +48,7 @@ public static bool CanOfferUseBlockScoped(OptionSet optionSet, BaseNamespaceDecl
         }
 
         internal static bool CanOfferUseFileScoped(OptionSet optionSet, CompilationUnitSyntax root, BaseNamespaceDeclarationSyntax declaration, bool forAnalyzer)
-            => CanOfferUseFileScoped(optionSet, root, declaration, forAnalyzer, ((CSharpParseOptions)root.SyntaxTree.Options).LanguageVersion);
+            => CanOfferUseFileScoped(optionSet, root, declaration, forAnalyzer, root.SyntaxTree.Options.LanguageVersion());
 
         internal static bool CanOfferUseFileScoped(
             OptionSet optionSet,
diff --git a/src/Analyzers/CSharp/Analyzers/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionDiagnosticAnalyzer.Analyzer.cs b/src/Analyzers/CSharp/Analyzers/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionDiagnosticAnalyzer.Analyzer.cs
index 8847203847c04..e4ef97b6340ee 100644
--- a/src/Analyzers/CSharp/Analyzers/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionDiagnosticAnalyzer.Analyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionDiagnosticAnalyzer.Analyzer.cs
@@ -35,8 +35,7 @@ public static (SyntaxKind nodeToGenerate, VariableDeclaratorSyntax declaratorToR
                 SemanticModel semanticModel,
                 out bool shouldRemoveNextStatement)
             {
-                var parseOptions = (CSharpParseOptions)semanticModel.SyntaxTree.Options;
-                var analyzer = new Analyzer(supportsOrPatterns: parseOptions.LanguageVersion.IsCSharp9OrAbove());
+                var analyzer = new Analyzer(supportsOrPatterns: semanticModel.SyntaxTree.Options.LanguageVersion() >= LanguageVersion.CSharp9);
                 var nodeToGenerate = analyzer.AnalyzeSwitchStatement(node, out shouldRemoveNextStatement);
 
                 if (nodeToGenerate == SyntaxKind.SimpleAssignmentExpression &&
diff --git a/src/Analyzers/CSharp/Analyzers/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionDiagnosticAnalyzer.cs
index d593bf47c6d2e..a1a72c4507d48 100644
--- a/src/Analyzers/CSharp/Analyzers/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionDiagnosticAnalyzer.cs
@@ -7,6 +7,7 @@
 using System.Linq;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.PooledObjects;
@@ -31,10 +32,8 @@ public ConvertSwitchStatementToExpressionDiagnosticAnalyzer()
         protected override void InitializeWorker(AnalysisContext context)
             => context.RegisterCompilationStartAction(context =>
             {
-                if (((CSharpCompilation)context.Compilation).LanguageVersion < LanguageVersion.CSharp8)
-                {
+                if (context.Compilation.LanguageVersion() < LanguageVersion.CSharp8)
                     return;
-                }
 
                 context.RegisterSyntaxNodeAction(AnalyzeSyntax, SyntaxKind.SwitchStatement);
             });
diff --git a/src/Analyzers/CSharp/Analyzers/MakeLocalFunctionStatic/MakeLocalFunctionStaticDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/MakeLocalFunctionStatic/MakeLocalFunctionStaticDiagnosticAnalyzer.cs
index 161b1405373c9..584224096f5be 100644
--- a/src/Analyzers/CSharp/Analyzers/MakeLocalFunctionStatic/MakeLocalFunctionStaticDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/MakeLocalFunctionStatic/MakeLocalFunctionStaticDiagnosticAnalyzer.cs
@@ -6,6 +6,7 @@
 using System.Linq;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
@@ -30,10 +31,8 @@ public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
         protected override void InitializeWorker(AnalysisContext context)
             => context.RegisterCompilationStartAction(context =>
             {
-                if (MakeLocalFunctionStaticHelper.IsStaticLocalFunctionSupported(((CSharpCompilation)context.Compilation).LanguageVersion))
-                {
+                if (MakeLocalFunctionStaticHelper.IsStaticLocalFunctionSupported(context.Compilation.LanguageVersion()))
                     context.RegisterSyntaxNodeAction(AnalyzeSyntax, SyntaxKind.LocalFunctionStatement);
-                }
             });
 
         private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
diff --git a/src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryDiscardDesignation/CSharpRemoveUnnecessaryDiscardDesignationDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryDiscardDesignation/CSharpRemoveUnnecessaryDiscardDesignationDiagnosticAnalyzer.cs
index a95e482559fd8..9301b283f266b 100644
--- a/src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryDiscardDesignation/CSharpRemoveUnnecessaryDiscardDesignationDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryDiscardDesignation/CSharpRemoveUnnecessaryDiscardDesignationDiagnosticAnalyzer.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using Microsoft.CodeAnalysis.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
@@ -32,10 +33,8 @@ protected override void InitializeWorker(AnalysisContext context)
         {
             context.RegisterCompilationStartAction(context =>
             {
-                if (((CSharpCompilation)context.Compilation).LanguageVersion < LanguageVersion.CSharp9)
-                {
+                if (context.Compilation.LanguageVersion() < LanguageVersion.CSharp9)
                     return;
-                }
 
                 context.RegisterSyntaxNodeAction(AnalyzeDiscardDesignation, SyntaxKind.DiscardDesignation);
             });
diff --git a/src/Analyzers/CSharp/Analyzers/SimplifyPropertyPattern/CSharpSimplifyPropertyPatternDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/SimplifyPropertyPattern/CSharpSimplifyPropertyPatternDiagnosticAnalyzer.cs
index 6378ce4725fb2..3e71510e9c3d8 100644
--- a/src/Analyzers/CSharp/Analyzers/SimplifyPropertyPattern/CSharpSimplifyPropertyPatternDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/SimplifyPropertyPattern/CSharpSimplifyPropertyPatternDiagnosticAnalyzer.cs
@@ -5,6 +5,7 @@
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Roslyn.Utilities;
@@ -44,7 +45,7 @@ protected override void InitializeWorker(AnalysisContext context)
                 // in projects targeting a lesser version.
 
                 var compilation = compilationContext.Compilation;
-                if (((CSharpCompilation)compilation).LanguageVersion < LanguageVersion.CSharp10)
+                if (compilation.LanguageVersion() < LanguageVersion.CSharp10)
                     return;
 
                 context.RegisterSyntaxNodeAction(AnalyzeSubpattern, SyntaxKind.Subpattern);
diff --git a/src/Analyzers/CSharp/Analyzers/UseAutoProperty/CSharpUseAutoPropertyAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseAutoProperty/CSharpUseAutoPropertyAnalyzer.cs
index 57d96a81cdb84..94a273b10fe09 100644
--- a/src/Analyzers/CSharp/Analyzers/UseAutoProperty/CSharpUseAutoPropertyAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseAutoProperty/CSharpUseAutoPropertyAnalyzer.cs
@@ -6,6 +6,7 @@
 using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
+using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.UseAutoProperty;
@@ -18,10 +19,10 @@ internal class CSharpUseAutoPropertyAnalyzer : AbstractUseAutoPropertyAnalyzer<
         PropertyDeclarationSyntax, FieldDeclarationSyntax, VariableDeclaratorSyntax, ExpressionSyntax>
     {
         protected override bool SupportsReadOnlyProperties(Compilation compilation)
-            => ((CSharpCompilation)compilation).LanguageVersion >= LanguageVersion.CSharp6;
+            => compilation.LanguageVersion() >= LanguageVersion.CSharp6;
 
         protected override bool SupportsPropertyInitializer(Compilation compilation)
-            => ((CSharpCompilation)compilation).LanguageVersion >= LanguageVersion.CSharp6;
+            => compilation.LanguageVersion() >= LanguageVersion.CSharp6;
 
         protected override bool CanExplicitInterfaceImplementationsBeFixed()
             => false;
diff --git a/src/Analyzers/CSharp/Analyzers/UseCollectionInitializer/CSharpUseCollectionInitializerDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseCollectionInitializer/CSharpUseCollectionInitializerDiagnosticAnalyzer.cs
index 7c799f9af62d9..38cdd999b097d 100644
--- a/src/Analyzers/CSharp/Analyzers/UseCollectionInitializer/CSharpUseCollectionInitializerDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseCollectionInitializer/CSharpUseCollectionInitializerDiagnosticAnalyzer.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using Microsoft.CodeAnalysis.CSharp.LanguageServices;
+using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.LanguageServices;
@@ -23,7 +24,7 @@ internal class CSharpUseCollectionInitializerDiagnosticAnalyzer :
             VariableDeclaratorSyntax>
     {
         protected override bool AreCollectionInitializersSupported(Compilation compilation)
-            => ((CSharpCompilation)compilation).LanguageVersion >= LanguageVersion.CSharp3;
+            => compilation.LanguageVersion() >= LanguageVersion.CSharp3;
 
         protected override ISyntaxFacts GetSyntaxFacts() => CSharpSyntaxFacts.Instance;
     }
diff --git a/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForCastAndEqualityOperatorDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForCastAndEqualityOperatorDiagnosticAnalyzer.cs
index 34fd781be78a6..d93931c77968a 100644
--- a/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForCastAndEqualityOperatorDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForCastAndEqualityOperatorDiagnosticAnalyzer.cs
@@ -4,6 +4,7 @@
 
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.UseIsNullCheck;
@@ -32,10 +33,8 @@ public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
         protected override void InitializeWorker(AnalysisContext context)
             => context.RegisterCompilationStartAction(context =>
             {
-                if (((CSharpCompilation)context.Compilation).LanguageVersion < LanguageVersion.CSharp7)
-                {
+                if (context.Compilation.LanguageVersion() < LanguageVersion.CSharp7)
                     return;
-                }
 
                 context.RegisterSyntaxNodeAction(n => AnalyzeSyntax(n), SyntaxKind.EqualsExpression, SyntaxKind.NotEqualsExpression);
             });
diff --git a/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForReferenceEqualsDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForReferenceEqualsDiagnosticAnalyzer.cs
index 44bd1fca2e535..cd0a661a322a7 100644
--- a/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForReferenceEqualsDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForReferenceEqualsDiagnosticAnalyzer.cs
@@ -18,10 +18,10 @@ public CSharpUseIsNullCheckForReferenceEqualsDiagnosticAnalyzer()
         }
 
         protected override bool IsLanguageVersionSupported(Compilation compilation)
-            => ((CSharpCompilation)compilation).LanguageVersion >= LanguageVersion.CSharp7;
+            => compilation.LanguageVersion() >= LanguageVersion.CSharp7;
 
         protected override bool IsUnconstrainedGenericSupported(Compilation compilation)
-            => ((CSharpCompilation)compilation).LanguageVersion >= LanguageVersion.CSharp8;
+            => compilation.LanguageVersion() >= LanguageVersion.CSharp8;
 
         protected override ISyntaxFacts GetSyntaxFacts()
             => CSharpSyntaxFacts.Instance;
diff --git a/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseNullCheckOverTypeCheckDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseNullCheckOverTypeCheckDiagnosticAnalyzer.cs
index 22e128c62353b..8a94a5821a7f8 100644
--- a/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseNullCheckOverTypeCheckDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseNullCheckOverTypeCheckDiagnosticAnalyzer.cs
@@ -4,6 +4,7 @@
 
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Operations;
@@ -31,10 +32,8 @@ protected override void InitializeWorker(AnalysisContext context)
         {
             context.RegisterCompilationStartAction(context =>
             {
-                if (((CSharpCompilation)context.Compilation).LanguageVersion < LanguageVersion.CSharp9)
-                {
+                if (context.Compilation.LanguageVersion() < LanguageVersion.CSharp9)
                     return;
-                }
 
                 context.RegisterOperationAction(c => AnalyzeIsTypeOperation(c), OperationKind.IsType);
                 context.RegisterOperationAction(c => AnalyzeNegatedPatternOperation(c), OperationKind.NegatedPattern);
diff --git a/src/Analyzers/CSharp/Analyzers/UseLocalFunction/CSharpUseLocalFunctionDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseLocalFunction/CSharpUseLocalFunctionDiagnosticAnalyzer.cs
index 991eadaf65ebd..0a744ffc75192 100644
--- a/src/Analyzers/CSharp/Analyzers/UseLocalFunction/CSharpUseLocalFunctionDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseLocalFunction/CSharpUseLocalFunctionDiagnosticAnalyzer.cs
@@ -59,7 +59,7 @@ protected override void InitializeWorker(AnalysisContext context)
 
                 // Local functions are only available in C# 7.0 and above.  Don't offer this refactoring
                 // in projects targeting a lesser version.
-                if (((CSharpCompilation)compilation).LanguageVersion < LanguageVersion.CSharp7)
+                if (compilation.LanguageVersion() < LanguageVersion.CSharp7)
                     return;
 
                 var expressionType = compilation.GetTypeByMetadataName(typeof(Expression<>).FullName!);
diff --git a/src/Analyzers/CSharp/Analyzers/UseNullPropagation/CSharpUseNullPropagationDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseNullPropagation/CSharpUseNullPropagationDiagnosticAnalyzer.cs
index 596a97ddd10bb..899d16611d29d 100644
--- a/src/Analyzers/CSharp/Analyzers/UseNullPropagation/CSharpUseNullPropagationDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseNullPropagation/CSharpUseNullPropagationDiagnosticAnalyzer.cs
@@ -26,7 +26,7 @@ internal class CSharpUseNullPropagationDiagnosticAnalyzer :
             ElementAccessExpressionSyntax>
     {
         protected override bool ShouldAnalyze(Compilation compilation)
-            => ((CSharpCompilation)compilation).LanguageVersion >= LanguageVersion.CSharp6;
+            => compilation.LanguageVersion() >= LanguageVersion.CSharp6;
 
         protected override ISyntaxFacts GetSyntaxFacts()
             => CSharpSyntaxFacts.Instance;
diff --git a/src/Analyzers/CSharp/Analyzers/UseObjectInitializer/CSharpUseObjectInitializerDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseObjectInitializer/CSharpUseObjectInitializerDiagnosticAnalyzer.cs
index 74fd38b60904b..78f68133ae74a 100644
--- a/src/Analyzers/CSharp/Analyzers/UseObjectInitializer/CSharpUseObjectInitializerDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseObjectInitializer/CSharpUseObjectInitializerDiagnosticAnalyzer.cs
@@ -27,7 +27,7 @@ protected override bool AreObjectInitializersSupported(Compilation compilation)
         {
             // object initializers are only available in C# 3.0 and above.  Don't offer this refactoring
             // in projects targeting a lesser version.
-            return ((CSharpCompilation)compilation).LanguageVersion >= LanguageVersion.CSharp3;
+            return compilation.LanguageVersion() >= LanguageVersion.CSharp3;
         }
 
         protected override ISyntaxFacts GetSyntaxFacts() => CSharpSyntaxFacts.Instance;
diff --git a/src/Analyzers/CSharp/Analyzers/UsePatternMatching/CSharpUseNotPatternDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UsePatternMatching/CSharpUseNotPatternDiagnosticAnalyzer.cs
index e9e1372f02e80..8573a3cc7dcf9 100644
--- a/src/Analyzers/CSharp/Analyzers/UsePatternMatching/CSharpUseNotPatternDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UsePatternMatching/CSharpUseNotPatternDiagnosticAnalyzer.cs
@@ -45,7 +45,7 @@ protected override void InitializeWorker(AnalysisContext context)
             {
                 // "x is not Type y" is only available in C# 9.0 and above. Don't offer this refactoring
                 // in projects targeting a lesser version.
-                if (!((CSharpCompilation)context.Compilation).LanguageVersion.IsCSharp9OrAbove())
+                if (context.Compilation.LanguageVersion() < LanguageVersion.CSharp9)
                     return;
 
                 context.RegisterSyntaxNodeAction(n => SyntaxNodeAction(n), SyntaxKind.LogicalNotExpression);
diff --git a/src/Analyzers/CSharp/Analyzers/UseThrowExpression/CSharpUseThrowExpressionDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseThrowExpression/CSharpUseThrowExpressionDiagnosticAnalyzer.cs
index ccc8b56b7d758..4948b0367e988 100644
--- a/src/Analyzers/CSharp/Analyzers/UseThrowExpression/CSharpUseThrowExpressionDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseThrowExpression/CSharpUseThrowExpressionDiagnosticAnalyzer.cs
@@ -20,7 +20,7 @@ public CSharpUseThrowExpressionDiagnosticAnalyzer()
 
         protected override bool IsSupported(Compilation compilation)
         {
-            return ((CSharpCompilation)compilation).LanguageVersion >= LanguageVersion.CSharp7;
+            return compilation.LanguageVersion() >= LanguageVersion.CSharp7;
         }
 
         protected override bool IsInExpressionTree(SemanticModel semanticModel, SyntaxNode node, INamedTypeSymbol? expressionTypeOpt, CancellationToken cancellationToken)
diff --git a/src/Analyzers/CSharp/Analyzers/UseTupleSwap/CSharpUseTupleSwapDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseTupleSwap/CSharpUseTupleSwapDiagnosticAnalyzer.cs
index b85b5bd837098..ab56c84b265c3 100644
--- a/src/Analyzers/CSharp/Analyzers/UseTupleSwap/CSharpUseTupleSwapDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseTupleSwap/CSharpUseTupleSwapDiagnosticAnalyzer.cs
@@ -50,7 +50,7 @@ protected override void InitializeWorker(AnalysisContext context)
             {
                 // Tuples are only available in C# 7 and above.
                 var compilation = context.Compilation;
-                if (((CSharpCompilation)compilation).LanguageVersion < LanguageVersion.CSharp7)
+                if (compilation.LanguageVersion() < LanguageVersion.CSharp7)
                     return;
 
                 context.RegisterSyntaxNodeAction(
diff --git a/src/Analyzers/CSharp/CodeFixes/RemoveUnusedParametersAndValues/CSharpRemoveUnusedValuesCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/RemoveUnusedParametersAndValues/CSharpRemoveUnusedValuesCodeFixProvider.cs
index 24f21e1674b39..a42d5202f4a8f 100644
--- a/src/Analyzers/CSharp/CodeFixes/RemoveUnusedParametersAndValues/CSharpRemoveUnusedValuesCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/RemoveUnusedParametersAndValues/CSharpRemoveUnusedValuesCodeFixProvider.cs
@@ -74,7 +74,7 @@ protected override SyntaxNode TryUpdateParentOfUpdatedNode(SyntaxNode parent, Sy
         {
             if (newNameNode.IsKind(SyntaxKind.DiscardDesignation)
                 && parent.IsKind(SyntaxKind.DeclarationPattern, out DeclarationPatternSyntax declarationPattern)
-                && ((CSharpParseOptions)parent.SyntaxTree.Options).LanguageVersion.IsCSharp9OrAbove())
+                && parent.SyntaxTree.Options.LanguageVersion() >= LanguageVersion.CSharp9)
             {
                 var trailingTrivia = declarationPattern.Type.GetTrailingTrivia()
                     .AddRange(newNameNode.GetLeadingTrivia())
diff --git a/src/Analyzers/CSharp/CodeFixes/UseIsNullCheck/CSharpUseIsNullCheckForReferenceEqualsCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/UseIsNullCheck/CSharpUseIsNullCheckForReferenceEqualsCodeFixProvider.cs
index 81898868edee8..cd7d69f2f6ca7 100644
--- a/src/Analyzers/CSharp/CodeFixes/UseIsNullCheck/CSharpUseIsNullCheckForReferenceEqualsCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/UseIsNullCheck/CSharpUseIsNullCheckForReferenceEqualsCodeFixProvider.cs
@@ -46,8 +46,7 @@ private static SyntaxNode CreateIsNullCheck(ExpressionSyntax argument)
 
         private static SyntaxNode CreateIsNotNullCheck(ExpressionSyntax argument)
         {
-            var parseOptions = (CSharpParseOptions)argument.SyntaxTree.Options;
-            if (parseOptions.LanguageVersion.IsCSharp9OrAbove())
+            if (argument.SyntaxTree.Options.LanguageVersion() >= LanguageVersion.CSharp9)
             {
                 return IsPatternExpression(
                     argument,
diff --git a/src/Features/CSharp/Portable/ConvertIfToSwitch/CSharpConvertIfToSwitchCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ConvertIfToSwitch/CSharpConvertIfToSwitchCodeRefactoringProvider.cs
index 3b9f09193ebc3..f28d11846f910 100644
--- a/src/Features/CSharp/Portable/ConvertIfToSwitch/CSharpConvertIfToSwitchCodeRefactoringProvider.cs
+++ b/src/Features/CSharp/Portable/ConvertIfToSwitch/CSharpConvertIfToSwitchCodeRefactoringProvider.cs
@@ -6,6 +6,7 @@
 using System.Composition;
 using Microsoft.CodeAnalysis.CodeRefactorings;
 using Microsoft.CodeAnalysis.ConvertIfToSwitch;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Host.Mef;
@@ -30,11 +31,11 @@ public override string GetTitle(bool forSwitchExpression)
 
         public override Analyzer CreateAnalyzer(ISyntaxFacts syntaxFacts, ParseOptions options)
         {
-            var version = ((CSharpParseOptions)options).LanguageVersion;
+            var version = options.LanguageVersion();
             var features =
                 (version >= LanguageVersion.CSharp7 ? Feature.SourcePattern | Feature.IsTypePattern | Feature.CaseGuard : 0) |
                 (version >= LanguageVersion.CSharp8 ? Feature.SwitchExpression : 0) |
-                (version.IsCSharp9OrAbove() ? Feature.RelationalPattern | Feature.OrPattern | Feature.AndPattern | Feature.TypePattern : 0);
+                (version >= LanguageVersion.CSharp9 ? Feature.RelationalPattern | Feature.OrPattern | Feature.AndPattern | Feature.TypePattern : 0);
             return new CSharpAnalyzer(syntaxFacts, features);
         }
     }
diff --git a/src/Features/CSharp/Portable/UseAutoProperty/CSharpUseAutoPropertyCodeFixProvider.cs b/src/Features/CSharp/Portable/UseAutoProperty/CSharpUseAutoPropertyCodeFixProvider.cs
index e380eb18e88a3..3ed28729ad9bf 100644
--- a/src/Features/CSharp/Portable/UseAutoProperty/CSharpUseAutoPropertyCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/UseAutoProperty/CSharpUseAutoPropertyCodeFixProvider.cs
@@ -157,7 +157,7 @@ private static bool NeedsSetter(Compilation compilation, PropertyDeclarationSynt
         }
 
         private static bool SupportsReadOnlyProperties(Compilation compilation)
-            => ((CSharpCompilation)compilation).LanguageVersion >= LanguageVersion.CSharp6;
+            => compilation.LanguageVersion() >= LanguageVersion.CSharp6;
 
         private static AccessorListSyntax UpdateAccessorList(AccessorListSyntax accessorList)
         {
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/CSharpCompilerExtensions.projitems b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/CSharpCompilerExtensions.projitems
index 7a9bd58376191..5dcf9a116468c 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/CSharpCompilerExtensions.projitems
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/CSharpCompilerExtensions.projitems
@@ -20,6 +20,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\AssignmentExpressionSyntaxExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\AttributeArgumentSyntaxExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\BlockSyntaxExtensions.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Extensions\CompilationExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\ContextQuery\SyntaxTreeExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\ConversionExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\DefaultExpressionSyntaxExtensions.cs" />
@@ -38,6 +39,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\MemberDeclarationSyntaxExtensions_GetAttributes.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\OperatorPrecedence.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\ParenthesizedExpressionSyntaxExtensions.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Extensions\ParseOptionsExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\SemanticModelExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\SimpleNameSyntaxExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\StatementSyntaxExtensions.cs" />
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/CompilationExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/CompilationExtensions.cs
new file mode 100644
index 0000000000000..375e6188abf82
--- /dev/null
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/CompilationExtensions.cs
@@ -0,0 +1,12 @@
+// 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.CSharp.Shared.Extensions
+{
+    internal static class CompilationExtensions
+    {
+        public static LanguageVersion LanguageVersion(this Compilation compilation)
+            => ((CSharpCompilation)compilation).LanguageVersion;
+    }
+}
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/LanguageVersionExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/LanguageVersionExtensions.cs
index 67faee49d91e6..b84c4abd638c9 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/LanguageVersionExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/LanguageVersionExtensions.cs
@@ -6,14 +6,8 @@ namespace Microsoft.CodeAnalysis.CSharp.Shared.Extensions
 {
     internal static class LanguageVersionExtensions
     {
-        public static bool IsCSharp9OrAbove(this LanguageVersion languageVersion)
-            => languageVersion >= LanguageVersion.CSharp9;
-
-        public static bool IsCSharp10OrAbove(this LanguageVersion languageVersion)
-            => languageVersion >= LanguageVersion.CSharp10;
-
         public static bool HasConstantInterpolatedStrings(this LanguageVersion languageVersion)
-            => languageVersion.IsCSharp10OrAbove();
+            => languageVersion >= LanguageVersion.CSharp10;
 
         /// <remarks>
         /// Corresponds to Microsoft.CodeAnalysis.CSharp.LanguageVersionFacts.CSharpNext.
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ParseOptionsExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ParseOptionsExtensions.cs
new file mode 100644
index 0000000000000..01c8ef4d8937f
--- /dev/null
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ParseOptionsExtensions.cs
@@ -0,0 +1,12 @@
+// 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.CSharp.Extensions
+{
+    internal static class ParseOptionsExtensions
+    {
+        public static LanguageVersion LanguageVersion(this ParseOptions options)
+            => ((CSharpParseOptions)options).LanguageVersion;
+    }
+}
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/SyntaxTreeExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/SyntaxTreeExtensions.cs
index 340894c738a58..03287583d8f5f 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/SyntaxTreeExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/SyntaxTreeExtensions.cs
@@ -12,6 +12,7 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.Extensions
 {
+
     internal static partial class SyntaxTreeExtensions
     {
         public static ISet<SyntaxKind> GetPrecedingModifiers(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken)
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs
index c84b60696c5cd..e9cc29d9fe2f7 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs
@@ -50,22 +50,22 @@ public SyntaxTrivia ElasticCarriageReturnLineFeed
         public ISyntaxKinds SyntaxKinds { get; } = CSharpSyntaxKinds.Instance;
 
         public bool SupportsIndexingInitializer(ParseOptions options)
-            => ((CSharpParseOptions)options).LanguageVersion >= LanguageVersion.CSharp6;
+            => options.LanguageVersion() >= LanguageVersion.CSharp6;
 
         public bool SupportsThrowExpression(ParseOptions options)
-            => ((CSharpParseOptions)options).LanguageVersion >= LanguageVersion.CSharp7;
+            => options.LanguageVersion() >= LanguageVersion.CSharp7;
 
         public bool SupportsLocalFunctionDeclaration(ParseOptions options)
-            => ((CSharpParseOptions)options).LanguageVersion >= LanguageVersion.CSharp7;
+            => options.LanguageVersion() >= LanguageVersion.CSharp7;
 
         public bool SupportsRecord(ParseOptions options)
-            => ((CSharpParseOptions)options).LanguageVersion >= LanguageVersion.CSharp9;
+            => options.LanguageVersion() >= LanguageVersion.CSharp9;
 
         public bool SupportsRecordStruct(ParseOptions options)
-            => ((CSharpParseOptions)options).LanguageVersion.IsCSharp10OrAbove();
+            => options.LanguageVersion() >= LanguageVersion.CSharp10;
 
         public bool SupportsTargetTypedConditionalExpression(ParseOptions options)
-            => ((CSharpParseOptions)options).LanguageVersion >= LanguageVersion.CSharp9;
+            => options.LanguageVersion() >= LanguageVersion.CSharp9;
 
         public SyntaxToken ParseToken(string text)
             => SyntaxFactory.ParseToken(text);
@@ -1492,7 +1492,7 @@ public void GetPartsOfRecursivePattern(SyntaxNode node, out SyntaxNode? type, ou
         }
 
         public bool SupportsNotPattern(ParseOptions options)
-            => ((CSharpParseOptions)options).LanguageVersion.IsCSharp9OrAbove();
+            => options.LanguageVersion() >= LanguageVersion.CSharp9;
 
         public bool IsAndPattern([NotNullWhen(true)] SyntaxNode? node)
             => node.IsKind(SyntaxKind.AndPattern);
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
index 0e6f3b05c323a..4063111e3d510 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
@@ -1248,7 +1248,7 @@ private static (SemanticModel? rewrittenSemanticModel, ExpressionSyntax? rewritt
 
             // Removing a cast may cause a conditional-expression conversion to come into existence.  This is
             // fine as long as we're in C# 9 or above.
-            var languageVersion = ((CSharpCompilation)originalSemanticModel.Compilation).LanguageVersion;
+            var languageVersion = originalSemanticModel.Compilation.LanguageVersion();
             if (languageVersion < LanguageVersion.CSharp9 &&
                 IntroducedConditionalExpressionConversion(rewrittenExpression, rewrittenSemanticModel, cancellationToken))
             {
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSemanticFactsService.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSemanticFactsService.cs
index d208cbee118d2..0c7bbec077a27 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSemanticFactsService.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSemanticFactsService.cs
@@ -39,7 +39,7 @@ protected override IEnumerable<ISymbol> GetCollidableSymbols(SemanticModel seman
             var visibleSymbols = semanticModel.LookupSymbols(location.SpanStart);
 
             // Local function parameter is allowed to shadow variables since C# 8.
-            if (((CSharpCompilation)semanticModel.Compilation).LanguageVersion.MapSpecifiedToEffectiveVersion() >= LanguageVersion.CSharp8)
+            if (semanticModel.Compilation.LanguageVersion().MapSpecifiedToEffectiveVersion() >= LanguageVersion.CSharp8)
             {
                 if (SyntaxFacts.IsParameterList(container) && SyntaxFacts.IsLocalFunctionStatement(container.Parent))
                 {

From cd6835229ec348f3af003429bd3a9d952dbd8a6e Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Sun, 16 Jan 2022 22:26:49 -0800
Subject: [PATCH 399/444] Introduce helpers

---
 .../InvokeDelegateWithConditionalAccessAnalyzer.cs              | 2 +-
 .../CSharpRemoveUnusedParametersAndValuesDiagnosticAnalyzer.cs  | 2 +-
 .../CSharpUseCompoundAssignmentDiagnosticAnalyzer.cs            | 2 +-
 .../UseExpressionBody/Helpers/UseExpressionBodyHelper`1.cs      | 2 +-
 .../CSharpUseImplicitObjectCreationDiagnosticAnalyzer.cs        | 2 +-
 .../CSharpUsePatternCombinatorsDiagnosticAnalyzer.cs            | 2 +-
 .../CSharpAsAndNullCheckDiagnosticAnalyzer.cs                   | 2 +-
 .../CSharpIsAndCastCheckDiagnosticAnalyzer.cs                   | 2 +-
 8 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/Analyzers/CSharp/Analyzers/InvokeDelegateWithConditionalAccess/InvokeDelegateWithConditionalAccessAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/InvokeDelegateWithConditionalAccess/InvokeDelegateWithConditionalAccessAnalyzer.cs
index 2c8ccdf29994b..6a4ef5206002c 100644
--- a/src/Analyzers/CSharp/Analyzers/InvokeDelegateWithConditionalAccess/InvokeDelegateWithConditionalAccessAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/InvokeDelegateWithConditionalAccess/InvokeDelegateWithConditionalAccessAnalyzer.cs
@@ -55,7 +55,7 @@ private void SyntaxNodeAction(SyntaxNodeAnalysisContext syntaxContext)
 
             // ?. is only available in C# 6.0 and above.  Don't offer this refactoring
             // in projects targeting a lesser version.
-            if (((CSharpParseOptions)ifStatement.SyntaxTree.Options).LanguageVersion < LanguageVersion.CSharp6)
+            if (ifStatement.SyntaxTree.Options.LanguageVersion() < LanguageVersion.CSharp6)
             {
                 return;
             }
diff --git a/src/Analyzers/CSharp/Analyzers/RemoveUnusedParametersAndValues/CSharpRemoveUnusedParametersAndValuesDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/RemoveUnusedParametersAndValues/CSharpRemoveUnusedParametersAndValuesDiagnosticAnalyzer.cs
index 18df6089dd27c..2a1df50a21f6b 100644
--- a/src/Analyzers/CSharp/Analyzers/RemoveUnusedParametersAndValues/CSharpRemoveUnusedParametersAndValuesDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/RemoveUnusedParametersAndValues/CSharpRemoveUnusedParametersAndValuesDiagnosticAnalyzer.cs
@@ -24,7 +24,7 @@ protected override bool IsRecordDeclaration(SyntaxNode node)
             => node is RecordDeclarationSyntax;
 
         protected override bool SupportsDiscard(SyntaxTree tree)
-            => ((CSharpParseOptions)tree.Options).LanguageVersion >= LanguageVersion.CSharp7;
+            => tree.Options.LanguageVersion() >= LanguageVersion.CSharp7;
 
         protected override bool MethodHasHandlesClause(IMethodSymbol method)
             => false;
diff --git a/src/Analyzers/CSharp/Analyzers/UseCompoundAssignment/CSharpUseCompoundAssignmentDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseCompoundAssignment/CSharpUseCompoundAssignmentDiagnosticAnalyzer.cs
index 5b33da057bf03..28ca18e29a314 100644
--- a/src/Analyzers/CSharp/Analyzers/UseCompoundAssignment/CSharpUseCompoundAssignmentDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseCompoundAssignment/CSharpUseCompoundAssignmentDiagnosticAnalyzer.cs
@@ -23,7 +23,7 @@ protected override SyntaxKind GetAnalysisKind()
 
         protected override bool IsSupported(SyntaxKind assignmentKind, ParseOptions options)
             => assignmentKind != SyntaxKind.CoalesceExpression ||
-            ((CSharpParseOptions)options).LanguageVersion >= LanguageVersion.CSharp8;
+            options.LanguageVersion() >= LanguageVersion.CSharp8;
 
         protected override int TryGetIncrementOrDecrement(SyntaxKind opKind, object constantValue)
         {
diff --git a/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyHelper`1.cs b/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyHelper`1.cs
index d76971155b75b..b8f2049c95638 100644
--- a/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyHelper`1.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyHelper`1.cs
@@ -143,7 +143,7 @@ private bool TryConvertToExpressionBodyWorker(
                 return false;
             }
 
-            var languageVersion = ((CSharpParseOptions)body.SyntaxTree.Options).LanguageVersion;
+            var languageVersion = body.SyntaxTree.Options.LanguageVersion();
 
             return body.TryConvertToArrowExpressionBody(
                 declaration.Kind(), languageVersion, conversionPreference,
diff --git a/src/Analyzers/CSharp/Analyzers/UseImplicitObjectCreation/CSharpUseImplicitObjectCreationDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseImplicitObjectCreation/CSharpUseImplicitObjectCreationDiagnosticAnalyzer.cs
index ada69073628dc..a57f154190838 100644
--- a/src/Analyzers/CSharp/Analyzers/UseImplicitObjectCreation/CSharpUseImplicitObjectCreationDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseImplicitObjectCreation/CSharpUseImplicitObjectCreationDiagnosticAnalyzer.cs
@@ -41,7 +41,7 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
             var cancellationToken = context.CancellationToken;
 
             // Not available prior to C# 9.
-            if (((CSharpParseOptions)syntaxTree.Options).LanguageVersion < LanguageVersion.CSharp9)
+            if (syntaxTree.Options.LanguageVersion() < LanguageVersion.CSharp9)
                 return;
 
             var optionSet = options.GetAnalyzerOptionSet(syntaxTree, cancellationToken);
diff --git a/src/Analyzers/CSharp/Analyzers/UsePatternCombinators/CSharpUsePatternCombinatorsDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UsePatternCombinators/CSharpUsePatternCombinatorsDiagnosticAnalyzer.cs
index c10714973ca04..ab35e699fba96 100644
--- a/src/Analyzers/CSharp/Analyzers/UsePatternCombinators/CSharpUsePatternCombinatorsDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UsePatternCombinators/CSharpUsePatternCombinatorsDiagnosticAnalyzer.cs
@@ -62,7 +62,7 @@ private void AnalyzeNode(SyntaxNodeAnalysisContext context)
                 return;
 
             var syntaxTree = expression.SyntaxTree;
-            if (((CSharpParseOptions)syntaxTree.Options).LanguageVersion < LanguageVersion.CSharp9)
+            if (syntaxTree.Options.LanguageVersion() < LanguageVersion.CSharp9)
                 return;
 
             var cancellationToken = context.CancellationToken;
diff --git a/src/Analyzers/CSharp/Analyzers/UsePatternMatching/CSharpAsAndNullCheckDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UsePatternMatching/CSharpAsAndNullCheckDiagnosticAnalyzer.cs
index 19d4f426e4295..882fabea89b1e 100644
--- a/src/Analyzers/CSharp/Analyzers/UsePatternMatching/CSharpAsAndNullCheckDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UsePatternMatching/CSharpAsAndNullCheckDiagnosticAnalyzer.cs
@@ -53,7 +53,7 @@ private void SyntaxNodeAction(SyntaxNodeAnalysisContext syntaxContext)
 
             // "x is Type y" is only available in C# 7.0 and above. Don't offer this refactoring
             // in projects targeting a lesser version.
-            if (((CSharpParseOptions)syntaxTree.Options).LanguageVersion < LanguageVersion.CSharp7)
+            if (syntaxTree.Options.LanguageVersion() < LanguageVersion.CSharp7)
             {
                 return;
             }
diff --git a/src/Analyzers/CSharp/Analyzers/UsePatternMatching/CSharpIsAndCastCheckDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UsePatternMatching/CSharpIsAndCastCheckDiagnosticAnalyzer.cs
index b77e0d1955def..7a66739e9247c 100644
--- a/src/Analyzers/CSharp/Analyzers/UsePatternMatching/CSharpIsAndCastCheckDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UsePatternMatching/CSharpIsAndCastCheckDiagnosticAnalyzer.cs
@@ -64,7 +64,7 @@ private void SyntaxNodeAction(SyntaxNodeAnalysisContext syntaxContext)
 
             // "x is Type y" is only available in C# 7.0 and above.  Don't offer this refactoring
             // in projects targeting a lesser version.
-            if (((CSharpParseOptions)syntaxTree.Options).LanguageVersion < LanguageVersion.CSharp7)
+            if (syntaxTree.Options.LanguageVersion() < LanguageVersion.CSharp7)
             {
                 return;
             }

From 0d27ecd4cb5752cdc6a6366bdfdee8fabd06bc8a Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Sun, 16 Jan 2022 22:33:06 -0800
Subject: [PATCH 400/444] Usings

---
 .../Analyzers/ConvertNamespace/ConvertNamespaceAnalysis.cs  | 5 +----
 .../ConvertSwitchStatementToExpressionDiagnosticAnalyzer.cs | 2 +-
 .../MakeLocalFunctionStaticDiagnosticAnalyzer.cs            | 3 +--
 ...RemoveUnnecessaryDiscardDesignationDiagnosticAnalyzer.cs | 2 +-
 ...harpRemoveUnusedParametersAndValuesDiagnosticAnalyzer.cs | 1 +
 .../CSharpSimplifyPropertyPatternDiagnosticAnalyzer.cs      | 6 ++----
 .../CSharpUseCollectionInitializerDiagnosticAnalyzer.cs     | 2 +-
 .../CSharpUseCompoundAssignmentDiagnosticAnalyzer.cs        | 3 ++-
 ...NullCheckForCastAndEqualityOperatorDiagnosticAnalyzer.cs | 2 +-
 ...arpUseIsNullCheckForReferenceEqualsDiagnosticAnalyzer.cs | 1 +
 .../CSharpUseNullCheckOverTypeCheckDiagnosticAnalyzer.cs    | 2 +-
 .../CSharpUseNullPropagationDiagnosticAnalyzer.cs           | 1 +
 .../CSharpUseObjectInitializerDiagnosticAnalyzer.cs         | 1 +
 .../CSharpUseThrowExpressionDiagnosticAnalyzer.cs           | 5 ++---
 .../CSharpAsAndNullCheckCodeFixProvider.cs                  | 2 +-
 .../CSharpAddDebuggerDisplayCodeRefactoringProvider.cs      | 3 ++-
 ...rpConvertLocalFunctionToMethodCodeRefactoringProvider.cs | 2 +-
 .../UseRecursivePatternsCodeRefactoringProvider.cs          | 2 +-
 .../CompletionProviders/NamedParameterCompletionProvider.cs | 2 +-
 ...tConcatenationToInterpolatedStringRefactoringProvider.cs | 3 ++-
 .../CSharpMethodExtractor.CSharpCodeGenerator.cs            | 4 ++--
 .../MakeLocalFunctionStaticCodeRefactoringProvider.cs       | 3 ++-
 .../PassInCapturedVariablesAsArgumentsCodeFixProvider.cs    | 5 ++---
 .../CSharpReplaceMethodWithPropertyService.cs               | 2 +-
 .../CSharpReplacePropertyWithMethodsService.cs              | 2 +-
 .../UseAutoProperty/CSharpUseAutoPropertyCodeFixProvider.cs | 1 +
 .../UseExpressionBodyForLambdaCodeStyleProvider.cs          | 2 +-
 .../CSharpUseLocalFunctionCodeFixProvider.cs                | 2 +-
 .../CSharpUseNamedArgumentsCodeRefactoringProvider.cs       | 2 +-
 .../CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.cs    | 2 +-
 .../Compiler/CSharp/Extensions/CompilationExtensions.cs     | 2 +-
 .../CSharp/Simplification/Simplifiers/CastSimplifier.cs     | 3 +--
 .../CSharp/LanguageServices/CSharpSemanticFactsService.cs   | 1 +
 33 files changed, 41 insertions(+), 40 deletions(-)

diff --git a/src/Analyzers/CSharp/Analyzers/ConvertNamespace/ConvertNamespaceAnalysis.cs b/src/Analyzers/CSharp/Analyzers/ConvertNamespace/ConvertNamespaceAnalysis.cs
index 7d3ca5eea80b3..7aa7dbbead3cd 100644
--- a/src/Analyzers/CSharp/Analyzers/ConvertNamespace/ConvertNamespaceAnalysis.cs
+++ b/src/Analyzers/CSharp/Analyzers/ConvertNamespace/ConvertNamespaceAnalysis.cs
@@ -4,14 +4,11 @@
 
 using System.Collections.Immutable;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Options;
-using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;
 
 #if CODE_STYLE
diff --git a/src/Analyzers/CSharp/Analyzers/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionDiagnosticAnalyzer.cs
index a1a72c4507d48..c564bd3b73b80 100644
--- a/src/Analyzers/CSharp/Analyzers/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionDiagnosticAnalyzer.cs
@@ -7,7 +7,7 @@
 using System.Linq;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
-using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.PooledObjects;
diff --git a/src/Analyzers/CSharp/Analyzers/MakeLocalFunctionStatic/MakeLocalFunctionStaticDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/MakeLocalFunctionStatic/MakeLocalFunctionStaticDiagnosticAnalyzer.cs
index 584224096f5be..045a203d9e77e 100644
--- a/src/Analyzers/CSharp/Analyzers/MakeLocalFunctionStatic/MakeLocalFunctionStaticDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/MakeLocalFunctionStatic/MakeLocalFunctionStaticDiagnosticAnalyzer.cs
@@ -3,10 +3,9 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Collections.Immutable;
-using System.Linq;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
-using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
diff --git a/src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryDiscardDesignation/CSharpRemoveUnnecessaryDiscardDesignationDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryDiscardDesignation/CSharpRemoveUnnecessaryDiscardDesignationDiagnosticAnalyzer.cs
index 9301b283f266b..3f0d137e55d28 100644
--- a/src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryDiscardDesignation/CSharpRemoveUnnecessaryDiscardDesignationDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryDiscardDesignation/CSharpRemoveUnnecessaryDiscardDesignationDiagnosticAnalyzer.cs
@@ -3,7 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using Microsoft.CodeAnalysis.CodeStyle;
-using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
diff --git a/src/Analyzers/CSharp/Analyzers/RemoveUnusedParametersAndValues/CSharpRemoveUnusedParametersAndValuesDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/RemoveUnusedParametersAndValues/CSharpRemoveUnusedParametersAndValuesDiagnosticAnalyzer.cs
index 2a1df50a21f6b..acca9e9d33600 100644
--- a/src/Analyzers/CSharp/Analyzers/RemoveUnusedParametersAndValues/CSharpRemoveUnusedParametersAndValuesDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/RemoveUnusedParametersAndValues/CSharpRemoveUnusedParametersAndValuesDiagnosticAnalyzer.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Operations;
diff --git a/src/Analyzers/CSharp/Analyzers/SimplifyPropertyPattern/CSharpSimplifyPropertyPatternDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/SimplifyPropertyPattern/CSharpSimplifyPropertyPatternDiagnosticAnalyzer.cs
index 3e71510e9c3d8..b8c23b4bae93e 100644
--- a/src/Analyzers/CSharp/Analyzers/SimplifyPropertyPattern/CSharpSimplifyPropertyPatternDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/SimplifyPropertyPattern/CSharpSimplifyPropertyPatternDiagnosticAnalyzer.cs
@@ -5,10 +5,9 @@
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
-using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.SimplifyPropertyPattern
 {
@@ -44,8 +43,7 @@ protected override void InitializeWorker(AnalysisContext context)
                 // Dotted property patterns are only available in C# 10.0 and above.  Don't offer this refactoring
                 // in projects targeting a lesser version.
 
-                var compilation = compilationContext.Compilation;
-                if (compilation.LanguageVersion() < LanguageVersion.CSharp10)
+                if (compilationContext.Compilation.LanguageVersion() < LanguageVersion.CSharp10)
                     return;
 
                 context.RegisterSyntaxNodeAction(AnalyzeSubpattern, SyntaxKind.Subpattern);
diff --git a/src/Analyzers/CSharp/Analyzers/UseCollectionInitializer/CSharpUseCollectionInitializerDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseCollectionInitializer/CSharpUseCollectionInitializerDiagnosticAnalyzer.cs
index 38cdd999b097d..afb9368568142 100644
--- a/src/Analyzers/CSharp/Analyzers/UseCollectionInitializer/CSharpUseCollectionInitializerDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseCollectionInitializer/CSharpUseCollectionInitializerDiagnosticAnalyzer.cs
@@ -2,8 +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 Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.LanguageServices;
-using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.LanguageServices;
diff --git a/src/Analyzers/CSharp/Analyzers/UseCompoundAssignment/CSharpUseCompoundAssignmentDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseCompoundAssignment/CSharpUseCompoundAssignmentDiagnosticAnalyzer.cs
index 28ca18e29a314..1b7576995a545 100644
--- a/src/Analyzers/CSharp/Analyzers/UseCompoundAssignment/CSharpUseCompoundAssignmentDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseCompoundAssignment/CSharpUseCompoundAssignmentDiagnosticAnalyzer.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 Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.LanguageServices;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
@@ -23,7 +24,7 @@ protected override SyntaxKind GetAnalysisKind()
 
         protected override bool IsSupported(SyntaxKind assignmentKind, ParseOptions options)
             => assignmentKind != SyntaxKind.CoalesceExpression ||
-            options.LanguageVersion() >= LanguageVersion.CSharp8;
+               options.LanguageVersion() >= LanguageVersion.CSharp8;
 
         protected override int TryGetIncrementOrDecrement(SyntaxKind opKind, object constantValue)
         {
diff --git a/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForCastAndEqualityOperatorDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForCastAndEqualityOperatorDiagnosticAnalyzer.cs
index d93931c77968a..18af25fb9d424 100644
--- a/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForCastAndEqualityOperatorDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForCastAndEqualityOperatorDiagnosticAnalyzer.cs
@@ -4,7 +4,7 @@
 
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis.CodeStyle;
-using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.UseIsNullCheck;
diff --git a/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForReferenceEqualsDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForReferenceEqualsDiagnosticAnalyzer.cs
index cd0a661a322a7..0306693867510 100644
--- a/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForReferenceEqualsDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseIsNullCheckForReferenceEqualsDiagnosticAnalyzer.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 Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.LanguageServices;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.LanguageServices;
diff --git a/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseNullCheckOverTypeCheckDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseNullCheckOverTypeCheckDiagnosticAnalyzer.cs
index 8a94a5821a7f8..22b05951d2320 100644
--- a/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseNullCheckOverTypeCheckDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseIsNullCheck/CSharpUseNullCheckOverTypeCheckDiagnosticAnalyzer.cs
@@ -4,7 +4,7 @@
 
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
-using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Operations;
diff --git a/src/Analyzers/CSharp/Analyzers/UseNullPropagation/CSharpUseNullPropagationDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseNullPropagation/CSharpUseNullPropagationDiagnosticAnalyzer.cs
index 899d16611d29d..d6a8edf851e20 100644
--- a/src/Analyzers/CSharp/Analyzers/UseNullPropagation/CSharpUseNullPropagationDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseNullPropagation/CSharpUseNullPropagationDiagnosticAnalyzer.cs
@@ -6,6 +6,7 @@
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.LanguageServices;
+using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.LanguageServices;
diff --git a/src/Analyzers/CSharp/Analyzers/UseObjectInitializer/CSharpUseObjectInitializerDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseObjectInitializer/CSharpUseObjectInitializerDiagnosticAnalyzer.cs
index 78f68133ae74a..f07931c0f49df 100644
--- a/src/Analyzers/CSharp/Analyzers/UseObjectInitializer/CSharpUseObjectInitializerDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseObjectInitializer/CSharpUseObjectInitializerDiagnosticAnalyzer.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 Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.LanguageServices;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
diff --git a/src/Analyzers/CSharp/Analyzers/UseThrowExpression/CSharpUseThrowExpressionDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseThrowExpression/CSharpUseThrowExpressionDiagnosticAnalyzer.cs
index 4948b0367e988..83bf4a2a32768 100644
--- a/src/Analyzers/CSharp/Analyzers/UseThrowExpression/CSharpUseThrowExpressionDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseThrowExpression/CSharpUseThrowExpressionDiagnosticAnalyzer.cs
@@ -5,6 +5,7 @@
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
+using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.UseThrowExpression;
 
@@ -19,9 +20,7 @@ public CSharpUseThrowExpressionDiagnosticAnalyzer()
         }
 
         protected override bool IsSupported(Compilation compilation)
-        {
-            return compilation.LanguageVersion() >= LanguageVersion.CSharp7;
-        }
+            => compilation.LanguageVersion() >= LanguageVersion.CSharp7;
 
         protected override bool IsInExpressionTree(SemanticModel semanticModel, SyntaxNode node, INamedTypeSymbol? expressionTypeOpt, CancellationToken cancellationToken)
             => node.IsInExpressionTree(semanticModel, expressionTypeOpt, cancellationToken);
diff --git a/src/Analyzers/CSharp/CodeFixes/UsePatternMatching/CSharpAsAndNullCheckCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/UsePatternMatching/CSharpAsAndNullCheckCodeFixProvider.cs
index 0e83d3871d04d..8a18396dd7340 100644
--- a/src/Analyzers/CSharp/CodeFixes/UsePatternMatching/CSharpAsAndNullCheckCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/UsePatternMatching/CSharpAsAndNullCheckCodeFixProvider.cs
@@ -53,7 +53,7 @@ protected override async Task FixAllAsync(
             using var _2 = PooledHashSet<SyntaxNode>.GetInstance(out var statementParentScopes);
 
             var tree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
-            var languageVersion = ((CSharpParseOptions)tree.Options).LanguageVersion;
+            var languageVersion = tree.Options.LanguageVersion();
 
             foreach (var diagnostic in diagnostics)
             {
diff --git a/src/Features/CSharp/Portable/AddDebuggerDisplay/CSharpAddDebuggerDisplayCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/AddDebuggerDisplay/CSharpAddDebuggerDisplayCodeRefactoringProvider.cs
index 38875bc12b7ed..e7a01ce10b8f1 100644
--- a/src/Features/CSharp/Portable/AddDebuggerDisplay/CSharpAddDebuggerDisplayCodeRefactoringProvider.cs
+++ b/src/Features/CSharp/Portable/AddDebuggerDisplay/CSharpAddDebuggerDisplayCodeRefactoringProvider.cs
@@ -6,6 +6,7 @@
 using System.Composition;
 using Microsoft.CodeAnalysis.AddDebuggerDisplay;
 using Microsoft.CodeAnalysis.CodeRefactorings;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Host.Mef;
@@ -27,6 +28,6 @@ public CSharpAddDebuggerDisplayCodeRefactoringProvider()
         protected override bool CanNameofAccessNonPublicMembersFromAttributeArgument => true;
 
         protected override bool SupportsConstantInterpolatedStrings(Document document)
-            => ((CSharpParseOptions)document.Project.ParseOptions!).LanguageVersion.HasConstantInterpolatedStrings();
+            => document.Project.ParseOptions!.LanguageVersion().HasConstantInterpolatedStrings();
     }
 }
diff --git a/src/Features/CSharp/Portable/CodeRefactorings/ConvertLocalFunctionToMethod/CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/CodeRefactorings/ConvertLocalFunctionToMethod/CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs
index 1124b7323fc53..d0e16360066bf 100644
--- a/src/Features/CSharp/Portable/CodeRefactorings/ConvertLocalFunctionToMethod/CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs
+++ b/src/Features/CSharp/Portable/CodeRefactorings/ConvertLocalFunctionToMethod/CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs
@@ -248,7 +248,7 @@ private static async Task<Document> UpdateDocumentAsync(
         }
 
         private static bool SupportsNonTrailingNamedArguments(ParseOptions options)
-            => ((CSharpParseOptions)options).LanguageVersion >= LanguageVersion.CSharp7_2;
+            => options.LanguageVersion() >= LanguageVersion.CSharp7_2;
 
         private static SyntaxNode GenerateArgument(IParameterSymbol p, string name, bool shouldUseNamedArguments = false)
             => s_generator.Argument(shouldUseNamedArguments ? name : null, p.RefKind, name.ToIdentifierName());
diff --git a/src/Features/CSharp/Portable/CodeRefactorings/UseRecursivePatterns/UseRecursivePatternsCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/CodeRefactorings/UseRecursivePatterns/UseRecursivePatternsCodeRefactoringProvider.cs
index 19ef4ebe9d3eb..ee907050a65a0 100644
--- a/src/Features/CSharp/Portable/CodeRefactorings/UseRecursivePatterns/UseRecursivePatternsCodeRefactoringProvider.cs
+++ b/src/Features/CSharp/Portable/CodeRefactorings/UseRecursivePatterns/UseRecursivePatternsCodeRefactoringProvider.cs
@@ -57,7 +57,7 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
                 return;
 
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-            if (((CSharpParseOptions)root.SyntaxTree.Options).LanguageVersion < LanguageVersion.CSharp9)
+            if (root.SyntaxTree.Options.LanguageVersion() < LanguageVersion.CSharp9)
                 return;
 
             var model = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/NamedParameterCompletionProvider.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/NamedParameterCompletionProvider.cs
index 3c150e28420de..aff2db04346c4 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/NamedParameterCompletionProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/NamedParameterCompletionProvider.cs
@@ -100,7 +100,7 @@ public override async Task ProvideCompletionsAsync(CompletionContext context)
 
                 // Consider refining this logic to mandate completion with an argument name, if preceded by an out-of-position name
                 // See https://github.com/dotnet/roslyn/issues/20657
-                var languageVersion = ((CSharpParseOptions)document.Project.ParseOptions!).LanguageVersion;
+                var languageVersion = document.Project.ParseOptions!.LanguageVersion();
                 if (languageVersion < LanguageVersion.CSharp7_2 && token.IsMandatoryNamedParameterPosition())
                 {
                     context.IsExclusive = true;
diff --git a/src/Features/CSharp/Portable/ConvertToInterpolatedString/CSharpConvertConcatenationToInterpolatedStringRefactoringProvider.cs b/src/Features/CSharp/Portable/ConvertToInterpolatedString/CSharpConvertConcatenationToInterpolatedStringRefactoringProvider.cs
index 5506f1908e093..50be3052cd778 100644
--- a/src/Features/CSharp/Portable/ConvertToInterpolatedString/CSharpConvertConcatenationToInterpolatedStringRefactoringProvider.cs
+++ b/src/Features/CSharp/Portable/ConvertToInterpolatedString/CSharpConvertConcatenationToInterpolatedStringRefactoringProvider.cs
@@ -6,6 +6,7 @@
 using System.Composition;
 using Microsoft.CodeAnalysis.CodeRefactorings;
 using Microsoft.CodeAnalysis.ConvertToInterpolatedString;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Host.Mef;
@@ -23,7 +24,7 @@ public CSharpConvertConcatenationToInterpolatedStringRefactoringProvider()
         }
 
         protected override bool SupportsConstantInterpolatedStrings(Document document)
-            => ((CSharpParseOptions)document.Project.ParseOptions!).LanguageVersion.HasConstantInterpolatedStrings();
+            => document.Project.ParseOptions!.LanguageVersion().HasConstantInterpolatedStrings();
 
         protected override string GetTextWithoutQuotes(string text, bool isVerbatim, bool isCharacterLiteral)
             => isVerbatim
diff --git a/src/Features/CSharp/Portable/ExtractMethod/CSharpMethodExtractor.CSharpCodeGenerator.cs b/src/Features/CSharp/Portable/ExtractMethod/CSharpMethodExtractor.CSharpCodeGenerator.cs
index e64342081ccbe..0d4390d3bb316 100644
--- a/src/Features/CSharp/Portable/ExtractMethod/CSharpMethodExtractor.CSharpCodeGenerator.cs
+++ b/src/Features/CSharp/Portable/ExtractMethod/CSharpMethodExtractor.CSharpCodeGenerator.cs
@@ -177,7 +177,7 @@ selectedNode is FieldDeclarationSyntax ||
             }
 
             protected override bool ShouldLocalFunctionCaptureParameter(SyntaxNode node)
-            => ((CSharpParseOptions)node.SyntaxTree.Options).LanguageVersion < LanguageVersion.CSharp8;
+            => node.SyntaxTree.Options.LanguageVersion() < LanguageVersion.CSharp8;
 
             private static bool IsExpressionBodiedMember(SyntaxNode node)
                 => node is MemberDeclarationSyntax member && member.GetExpressionBody() != null;
@@ -230,7 +230,7 @@ private DeclarationModifiers CreateMethodModifiers()
                 var isReadOnly = AnalyzerResult.ShouldBeReadOnly;
 
                 // Static local functions are only supported in C# 8.0 and later
-                var languageVersion = ((CSharpParseOptions)SemanticDocument.SyntaxTree.Options).LanguageVersion;
+                var languageVersion = SemanticDocument.SyntaxTree.Options.LanguageVersion();
 
                 if (LocalFunction && (!Options.GetOption(CSharpCodeStyleOptions.PreferStaticLocalFunction).Value || languageVersion < LanguageVersion.CSharp8))
                 {
diff --git a/src/Features/CSharp/Portable/MakeLocalFunctionStatic/MakeLocalFunctionStaticCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/MakeLocalFunctionStatic/MakeLocalFunctionStaticCodeRefactoringProvider.cs
index 3a80dc9a83628..40b5e172323c3 100644
--- a/src/Features/CSharp/Portable/MakeLocalFunctionStatic/MakeLocalFunctionStaticCodeRefactoringProvider.cs
+++ b/src/Features/CSharp/Portable/MakeLocalFunctionStatic/MakeLocalFunctionStaticCodeRefactoringProvider.cs
@@ -9,6 +9,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeRefactorings;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 namespace Microsoft.CodeAnalysis.CSharp.MakeLocalFunctionStatic
@@ -27,7 +28,7 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
             var (document, textSpan, cancellationToken) = context;
 
             var syntaxTree = (await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false))!;
-            if (!MakeLocalFunctionStaticHelper.IsStaticLocalFunctionSupported(((CSharpParseOptions)syntaxTree.Options).LanguageVersion))
+            if (!MakeLocalFunctionStaticHelper.IsStaticLocalFunctionSupported(syntaxTree.Options.LanguageVersion()))
             {
                 return;
             }
diff --git a/src/Features/CSharp/Portable/MakeLocalFunctionStatic/PassInCapturedVariablesAsArgumentsCodeFixProvider.cs b/src/Features/CSharp/Portable/MakeLocalFunctionStatic/PassInCapturedVariablesAsArgumentsCodeFixProvider.cs
index d2d9b23211f3c..e82692de0fcc7 100644
--- a/src/Features/CSharp/Portable/MakeLocalFunctionStatic/PassInCapturedVariablesAsArgumentsCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/MakeLocalFunctionStatic/PassInCapturedVariablesAsArgumentsCodeFixProvider.cs
@@ -11,6 +11,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Editing;
 using Roslyn.Utilities;
@@ -78,10 +79,8 @@ private static async Task WrapFixAsync(
 
             // Even when the language version doesn't support staic local function, the compiler will still
             // generate this error. So we need to check to make sure we don't provide incorrect fix.
-            if (!MakeLocalFunctionStaticHelper.IsStaticLocalFunctionSupported(((CSharpParseOptions)root.SyntaxTree.Options).LanguageVersion))
-            {
+            if (!MakeLocalFunctionStaticHelper.IsStaticLocalFunctionSupported(root.SyntaxTree.Options.LanguageVersion()))
                 return;
-            }
 
             // Find all unique local functions that contain the error.
             var localFunctions = diagnostics
diff --git a/src/Features/CSharp/Portable/ReplaceMethodWithProperty/CSharpReplaceMethodWithPropertyService.cs b/src/Features/CSharp/Portable/ReplaceMethodWithProperty/CSharpReplaceMethodWithPropertyService.cs
index da26f70bf49cf..ecf15b6b8d3ed 100644
--- a/src/Features/CSharp/Portable/ReplaceMethodWithProperty/CSharpReplaceMethodWithPropertyService.cs
+++ b/src/Features/CSharp/Portable/ReplaceMethodWithProperty/CSharpReplaceMethodWithPropertyService.cs
@@ -45,7 +45,7 @@ public void ReplaceGetMethodWithProperty(
                 return;
             }
 
-            var languageVersion = ((CSharpParseOptions)parseOptions).LanguageVersion;
+            var languageVersion = parseOptions.LanguageVersion();
             var newProperty = ConvertMethodsToProperty(
                 documentOptions, languageVersion,
                 semanticModel, editor.Generator,
diff --git a/src/Features/CSharp/Portable/ReplacePropertyWithMethods/CSharpReplacePropertyWithMethodsService.cs b/src/Features/CSharp/Portable/ReplacePropertyWithMethods/CSharpReplacePropertyWithMethodsService.cs
index c28050f74a896..9d9c92bf78400 100644
--- a/src/Features/CSharp/Portable/ReplacePropertyWithMethods/CSharpReplacePropertyWithMethodsService.cs
+++ b/src/Features/CSharp/Portable/ReplacePropertyWithMethods/CSharpReplacePropertyWithMethodsService.cs
@@ -47,7 +47,7 @@ public override async Task<ImmutableArray<SyntaxNode>> GetReplacementMembersAsyn
 
             var documentOptions = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
             var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
-            var languageVersion = ((CSharpParseOptions)syntaxTree.Options).LanguageVersion;
+            var languageVersion = syntaxTree.Options.LanguageVersion();
 
             return ConvertPropertyToMembers(
                 documentOptions, languageVersion,
diff --git a/src/Features/CSharp/Portable/UseAutoProperty/CSharpUseAutoPropertyCodeFixProvider.cs b/src/Features/CSharp/Portable/UseAutoProperty/CSharpUseAutoPropertyCodeFixProvider.cs
index 3ed28729ad9bf..a94b7f7d55509 100644
--- a/src/Features/CSharp/Portable/UseAutoProperty/CSharpUseAutoPropertyCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/UseAutoProperty/CSharpUseAutoPropertyCodeFixProvider.cs
@@ -11,6 +11,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Formatting;
diff --git a/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider.cs b/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider.cs
index 7fab4e7d0636c..0357333fdb241 100644
--- a/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider.cs
+++ b/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider.cs
@@ -114,7 +114,7 @@ private static bool CanOfferUseBlockBody(
                 return false;
             }
 
-            var languageVersion = ((CSharpParseOptions)declaration.SyntaxTree.Options).LanguageVersion;
+            var languageVersion = declaration.SyntaxTree.Options.LanguageVersion();
             if (expressionBodyOpt.IsKind(SyntaxKind.ThrowExpression) &&
                 languageVersion < LanguageVersion.CSharp7)
             {
diff --git a/src/Features/CSharp/Portable/UseLocalFunction/CSharpUseLocalFunctionCodeFixProvider.cs b/src/Features/CSharp/Portable/UseLocalFunction/CSharpUseLocalFunctionCodeFixProvider.cs
index a18aab329000c..19dbb99b310eb 100644
--- a/src/Features/CSharp/Portable/UseLocalFunction/CSharpUseLocalFunctionCodeFixProvider.cs
+++ b/src/Features/CSharp/Portable/UseLocalFunction/CSharpUseLocalFunctionCodeFixProvider.cs
@@ -90,7 +90,7 @@ protected override async Task FixAllAsync(
             var currentRoot = root.TrackNodes(nodesToTrack);
 
             var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
-            var languageVersion = ((CSharpParseOptions)semanticModel.SyntaxTree.Options).LanguageVersion;
+            var languageVersion = semanticModel.SyntaxTree.Options.LanguageVersion();
             var makeStaticIfPossible = languageVersion >= LanguageVersion.CSharp8 &&
                 options.GetOption(CSharpCodeStyleOptions.PreferStaticLocalFunction).Value;
 
diff --git a/src/Features/CSharp/Portable/UseNamedArguments/CSharpUseNamedArgumentsCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/UseNamedArguments/CSharpUseNamedArgumentsCodeRefactoringProvider.cs
index 307fe5c884f04..6f65b384fd1f9 100644
--- a/src/Features/CSharp/Portable/UseNamedArguments/CSharpUseNamedArgumentsCodeRefactoringProvider.cs
+++ b/src/Features/CSharp/Portable/UseNamedArguments/CSharpUseNamedArgumentsCodeRefactoringProvider.cs
@@ -31,7 +31,7 @@ protected sealed override bool IsLegalToAddNamedArguments(ImmutableArray<IParame
                 => !parameters.Last().IsParams || parameters.Length >= argumentCount;
 
             protected override bool SupportsNonTrailingNamedArguments(ParseOptions options)
-                => ((CSharpParseOptions)options).LanguageVersion >= LanguageVersion.CSharp7_2;
+                => options.LanguageVersion() >= LanguageVersion.CSharp7_2;
 
             protected override bool IsImplicitIndexOrRangeIndexer(ImmutableArray<IParameterSymbol> parameters, TSyntax argument, SemanticModel semanticModel)
             {
diff --git a/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.cs
index 8fd22d2e3a2db..650cf7cd252d3 100644
--- a/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.cs
+++ b/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.cs
@@ -71,7 +71,7 @@ private void SyntaxNodeAction(
 
             // "x is Type y" is only available in C# 7.0 and above.  Don't offer this refactoring
             // in projects targeting a lesser version.
-            if (((CSharpParseOptions)syntaxTree.Options).LanguageVersion < LanguageVersion.CSharp7)
+            if (syntaxTree.Options.LanguageVersion() < LanguageVersion.CSharp7)
             {
                 return;
             }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/CompilationExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/CompilationExtensions.cs
index 375e6188abf82..a0ed19e53f383 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/CompilationExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/CompilationExtensions.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.
 
-namespace Microsoft.CodeAnalysis.CSharp.Shared.Extensions
+namespace Microsoft.CodeAnalysis.CSharp.Extensions
 {
     internal static class CompilationExtensions
     {
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
index 4063111e3d510..a8ad0309f17b4 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
@@ -1248,8 +1248,7 @@ private static (SemanticModel? rewrittenSemanticModel, ExpressionSyntax? rewritt
 
             // Removing a cast may cause a conditional-expression conversion to come into existence.  This is
             // fine as long as we're in C# 9 or above.
-            var languageVersion = originalSemanticModel.Compilation.LanguageVersion();
-            if (languageVersion < LanguageVersion.CSharp9 &&
+            if (originalSemanticModel.Compilation.LanguageVersion() < LanguageVersion.CSharp9 &&
                 IntroducedConditionalExpressionConversion(rewrittenExpression, rewrittenSemanticModel, cancellationToken))
             {
                 return default;
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSemanticFactsService.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSemanticFactsService.cs
index 0c7bbec077a27..0665a2f2b99eb 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSemanticFactsService.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSemanticFactsService.cs
@@ -11,6 +11,7 @@
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Extensions.ContextQuery;
 using Microsoft.CodeAnalysis.CSharp.LanguageServices;
+using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.Operations;

From 9d5415aeb80b0362b271f96882fe7305718d4798 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrus.najmabadi@gmail.com>
Date: Sun, 16 Jan 2022 20:34:40 -1000
Subject: [PATCH 401/444] Update
 src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/SyntaxTreeExtensions.cs

---
 .../Compiler/CSharp/Extensions/SyntaxTreeExtensions.cs           | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/SyntaxTreeExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/SyntaxTreeExtensions.cs
index 03287583d8f5f..340894c738a58 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/SyntaxTreeExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/SyntaxTreeExtensions.cs
@@ -12,7 +12,6 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.Extensions
 {
-
     internal static partial class SyntaxTreeExtensions
     {
         public static ISet<SyntaxKind> GetPrecedingModifiers(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken)

From 049832dedcdb09f791e54a6990b0b98f77a5f241 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 17 Jan 2022 01:34:55 -0800
Subject: [PATCH 402/444] Fix case where we were not removing a removable cast.

---
 .../RemoveUnnecessaryCastTests.cs             | 30 ++++++++++++++++
 ...ConditionalExpressionForAssignmentTests.cs | 36 +++++++++++++++++++
 .../Simplifiers/CastSimplifier.cs             | 32 +++++++++++++----
 3 files changed, 91 insertions(+), 7 deletions(-)

diff --git a/src/Analyzers/CSharp/Tests/RemoveUnnecessaryCast/RemoveUnnecessaryCastTests.cs b/src/Analyzers/CSharp/Tests/RemoveUnnecessaryCast/RemoveUnnecessaryCastTests.cs
index e456b93afccbe..43239356ec3e2 100644
--- a/src/Analyzers/CSharp/Tests/RemoveUnnecessaryCast/RemoveUnnecessaryCastTests.cs
+++ b/src/Analyzers/CSharp/Tests/RemoveUnnecessaryCast/RemoveUnnecessaryCastTests.cs
@@ -12464,5 +12464,35 @@ protected sbyte ExtractInt8(object data)
                 LanguageVersion = LanguageVersion.CSharp10,
             }.RunAsync();
         }
+
+        [WorkItem(58898, "https://github.com/dotnet/roslyn/issues/58898")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryCast)]
+        public async Task SameNullableTypeOnBothSidesOfConditional1()
+        {
+            await new VerifyCS.Test
+            {
+                TestCode = @"
+using System;
+
+class C
+{
+    void M()
+    {
+        var id = true ? [|(Guid?)|]Guid.NewGuid() : [|(Guid?)|]Guid.Empty;
+    }
+}",
+                FixedCode = @"
+using System;
+
+class C
+{
+    void M()
+    {
+        var id = true ? Guid.NewGuid() : (Guid?)Guid.Empty;
+    }
+}",
+                LanguageVersion = LanguageVersion.CSharp10,
+            }.RunAsync();
+        }
     }
 }
diff --git a/src/Analyzers/CSharp/Tests/UseConditionalExpression/UseConditionalExpressionForAssignmentTests.cs b/src/Analyzers/CSharp/Tests/UseConditionalExpression/UseConditionalExpressionForAssignmentTests.cs
index 4fc9c59a0aaf2..5ff6eb1688b3c 100644
--- a/src/Analyzers/CSharp/Tests/UseConditionalExpression/UseConditionalExpressionForAssignmentTests.cs
+++ b/src/Analyzers/CSharp/Tests/UseConditionalExpression/UseConditionalExpressionForAssignmentTests.cs
@@ -1688,5 +1688,41 @@ void M(bool i, int j)
     }
 }");
         }
+
+        [WorkItem(58898, "https://github.com/dotnet/roslyn/issues/58898")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseConditionalExpression)]
+        public async Task TestRemoveRedundantCast()
+        {
+            await TestInRegularAndScript1Async(
+@"
+using System;
+
+class C
+{
+    void M()
+    {
+        Guid? id;
+
+        [||]if (true)
+        {
+            id = Guid.NewGuid();
+        }
+        else
+        {
+            id = Guid.Empty;
+        }
+    }
+}",
+@"
+using System;
+
+class C
+{
+    void M()
+    {
+        var id = true ? Guid.NewGuid() : (Guid?)Guid.Empty;
+    }
+}", new TestParameters(options: PreferImplicitTypeAlways));
+        }
     }
 }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
index 0e6f3b05c323a..f90b4e1ddd8ff 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
@@ -264,7 +264,7 @@ private static bool IsConversionCastSafeToRemove(
             // Explicit conversions are conversions that cannot be proven to always succeed, conversions
             // that are known to possibly lose information.  As such, we need to preserve this as it 
             // has necessary runtime behavior that must be kept.
-            if (IsExplicitCastThatMustBePreserved(castNode, originalConversion))
+            if (IsExplicitCastThatMustBePreserved(originalSemanticModel, castNode, originalConversion, cancellationToken))
                 return false;
 
             // we are starting with code like `(X)expr` and converting to just `expr`. Post rewrite we need
@@ -733,7 +733,11 @@ private static bool IsExplicitCast(SyntaxNode node)
                 ? conversion.Operand
                 : value;
 
-        private static bool IsExplicitCastThatMustBePreserved(ExpressionSyntax castNode, Conversion conversion)
+        private static bool IsExplicitCastThatMustBePreserved(
+            SemanticModel semanticModel,
+            ExpressionSyntax castOrAsNode,
+            Conversion conversion,
+            CancellationToken cancellationToken)
         {
             if (!conversion.IsExplicit)
                 return false;
@@ -753,15 +757,29 @@ private static bool IsExplicitCastThatMustBePreserved(ExpressionSyntax castNode,
             //
             // Note: this does not apply for `as byte?`.  This is an explicit as-cast that can produce null values and
             // so it should be maintained.
-            if (conversion.IsNullable && castNode is CastExpressionSyntax)
+            if (conversion.IsNullable && castOrAsNode is CastExpressionSyntax castExpression)
             {
-                var parent = castNode.WalkUpParentheses();
+                var parent = castOrAsNode.WalkUpParentheses();
                 if (parent.Parent is ConditionalExpressionSyntax conditionalExpression)
                 {
-                    if ((conditionalExpression.WhenTrue == parent && conditionalExpression.WhenFalse.WalkDownParentheses().Kind() == SyntaxKind.NullLiteralExpression) ||
-                        (conditionalExpression.WhenFalse == parent && conditionalExpression.WhenTrue.WalkDownParentheses().Kind() == SyntaxKind.NullLiteralExpression))
-                    {
+                    // If we have `(T?)expr == null` or `null == (T?)expr` then we can potentially remove this cast as
+                    // the lang will implicitly create such a cast with an appropriate type and null.
+                    var (castSide, otherSide) = conditionalExpression.WhenTrue == parent
+                        ? (conditionalExpression.WhenTrue, conditionalExpression.WhenFalse)
+                        : (conditionalExpression.WhenFalse, conditionalExpression.WhenTrue);
+
+                    if (otherSide.WalkDownParentheses().Kind() == SyntaxKind.NullLiteralExpression)
                         return false;
+
+                    // if we have `(T?)TExpr == nullableTExpr` then we can also remove this cast as the language will
+                    // insert the same nullable widening cast implicitly.
+                    var castSideType = semanticModel.GetTypeInfo(castOrAsNode, cancellationToken).Type;
+                    var otherSideType = semanticModel.GetTypeInfo(otherSide, cancellationToken).Type;
+                    if (castSideType.IsNullable(out var underlyingType) && Equals(castSideType, otherSideType))
+                    {
+                        var castedType = semanticModel.GetTypeInfo(castExpression.Expression, cancellationToken).Type;
+                        if (Equals(underlyingType, castedType))
+                            return false;
                     }
                 }
             }

From 5a3b0b804aa0cfdbd44ba4c447a33e88ee5c6336 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 17 Jan 2022 01:40:53 -0800
Subject: [PATCH 403/444] Add tests

---
 .../RemoveUnnecessaryCastTests.cs             | 60 +++++++++++++++++++
 .../Simplifiers/CastSimplifier.cs             | 12 ++--
 2 files changed, 67 insertions(+), 5 deletions(-)

diff --git a/src/Analyzers/CSharp/Tests/RemoveUnnecessaryCast/RemoveUnnecessaryCastTests.cs b/src/Analyzers/CSharp/Tests/RemoveUnnecessaryCast/RemoveUnnecessaryCastTests.cs
index 43239356ec3e2..3ffa8266a7eaf 100644
--- a/src/Analyzers/CSharp/Tests/RemoveUnnecessaryCast/RemoveUnnecessaryCastTests.cs
+++ b/src/Analyzers/CSharp/Tests/RemoveUnnecessaryCast/RemoveUnnecessaryCastTests.cs
@@ -12490,6 +12490,66 @@ void M()
     {
         var id = true ? Guid.NewGuid() : (Guid?)Guid.Empty;
     }
+}",
+                LanguageVersion = LanguageVersion.CSharp10,
+            }.RunAsync();
+        }
+
+        [WorkItem(58898, "https://github.com/dotnet/roslyn/issues/58898")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryCast)]
+        public async Task SameNullableTypeOnBothSidesOfConditional2()
+        {
+            await new VerifyCS.Test
+            {
+                TestCode = @"
+using System;
+
+class C
+{
+    void M(Guid g1, Guid? g2)
+    {
+        var id = true ? [|(Guid?)|]g1 : g2;
+    }
+}",
+                FixedCode = @"
+using System;
+
+class C
+{
+    void M(Guid g1, Guid? g2)
+    {
+        var id = true ? g1 : g2;
+    }
+}",
+                LanguageVersion = LanguageVersion.CSharp10,
+            }.RunAsync();
+        }
+
+        [WorkItem(58898, "https://github.com/dotnet/roslyn/issues/58898")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryCast)]
+        public async Task SameNullableTypeOnBothSidesOfConditional3()
+        {
+            await new VerifyCS.Test
+            {
+                TestCode = @"
+using System;
+
+class C
+{
+    void M(Guid? g1, Guid g2)
+    {
+        var id = true ? g1 : [|(Guid?)|]g2;
+    }
+}",
+                FixedCode = @"
+using System;
+
+class C
+{
+    void M(Guid? g1, Guid g2)
+    {
+        var id = true ? g1 : g2;
+    }
 }",
                 LanguageVersion = LanguageVersion.CSharp10,
             }.RunAsync();
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
index f90b4e1ddd8ff..5006e28b22500 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
@@ -773,13 +773,15 @@ private static bool IsExplicitCastThatMustBePreserved(
 
                     // if we have `(T?)TExpr == nullableTExpr` then we can also remove this cast as the language will
                     // insert the same nullable widening cast implicitly.
-                    var castSideType = semanticModel.GetTypeInfo(castOrAsNode, cancellationToken).Type;
+                    var castSideType = semanticModel.GetTypeInfo(castSide, cancellationToken).Type;
                     var otherSideType = semanticModel.GetTypeInfo(otherSide, cancellationToken).Type;
-                    if (castSideType.IsNullable(out var underlyingType) && Equals(castSideType, otherSideType))
+                    var castedExpressionType = semanticModel.GetTypeInfo(castExpression.Expression, cancellationToken).Type;
+
+                    if (castSideType.IsNullable(out var underlyingType) &&
+                        Equals(underlyingType, castedExpressionType) &&
+                        Equals(castSideType, otherSideType))
                     {
-                        var castedType = semanticModel.GetTypeInfo(castExpression.Expression, cancellationToken).Type;
-                        if (Equals(underlyingType, castedType))
-                            return false;
+                        return false;
                     }
                 }
             }

From d5a90e0caf110f77738d37edd0bc04265e18e5c8 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 17 Jan 2022 01:49:08 -0800
Subject: [PATCH 404/444] Add more tests

---
 .../RemoveUnnecessaryCastTests.cs             | 90 +++++++++++++++++++
 .../Simplifiers/CastSimplifier.cs             | 13 ++-
 2 files changed, 100 insertions(+), 3 deletions(-)

diff --git a/src/Analyzers/CSharp/Tests/RemoveUnnecessaryCast/RemoveUnnecessaryCastTests.cs b/src/Analyzers/CSharp/Tests/RemoveUnnecessaryCast/RemoveUnnecessaryCastTests.cs
index 3ffa8266a7eaf..ec86c60afe864 100644
--- a/src/Analyzers/CSharp/Tests/RemoveUnnecessaryCast/RemoveUnnecessaryCastTests.cs
+++ b/src/Analyzers/CSharp/Tests/RemoveUnnecessaryCast/RemoveUnnecessaryCastTests.cs
@@ -12550,6 +12550,96 @@ void M(Guid? g1, Guid g2)
     {
         var id = true ? g1 : g2;
     }
+}",
+                LanguageVersion = LanguageVersion.CSharp10,
+            }.RunAsync();
+        }
+
+        [WorkItem(58898, "https://github.com/dotnet/roslyn/issues/58898")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryCast)]
+        public async Task SameNullableTypeOnBothSidesOfConditional4()
+        {
+            await new VerifyCS.Test
+            {
+                TestCode = @"
+using System;
+
+class C
+{
+    void M(Guid g1, Guid g2)
+    {
+        Guid? id = true ? [|(Guid?)|]g1 : g2;
+    }
+}",
+                FixedCode = @"
+using System;
+
+class C
+{
+    void M(Guid g1, Guid g2)
+    {
+        Guid? id = true ? g1 : g2;
+    }
+}",
+                LanguageVersion = LanguageVersion.CSharp10,
+            }.RunAsync();
+        }
+
+        [WorkItem(58898, "https://github.com/dotnet/roslyn/issues/58898")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryCast)]
+        public async Task SameNullableTypeOnBothSidesOfConditional5()
+        {
+            await new VerifyCS.Test
+            {
+                TestCode = @"
+using System;
+
+class C
+{
+    void M(Guid g1, Guid g2)
+    {
+        Guid? id = true ? g1 : [|(Guid?)|]g2;
+    }
+}",
+                FixedCode = @"
+using System;
+
+class C
+{
+    void M(Guid g1, Guid g2)
+    {
+        Guid? id = true ? g1 : g2;
+    }
+}",
+                LanguageVersion = LanguageVersion.CSharp10,
+            }.RunAsync();
+        }
+
+        [WorkItem(58898, "https://github.com/dotnet/roslyn/issues/58898")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryCast)]
+        public async Task SameNullableTypeOnBothSidesOfConditional6()
+        {
+            await new VerifyCS.Test
+            {
+                TestCode = @"
+using System;
+
+class C
+{
+    void M(Guid g1, Guid g2)
+    {
+        Guid? id = true ? [|(Guid?)|]g1 : [|(Guid?)|]g2;
+    }
+}",
+                FixedCode = @"
+using System;
+
+class C
+{
+    void M(Guid g1, Guid g2)
+    {
+        Guid? id = true ? g1 : g2;
+    }
 }",
                 LanguageVersion = LanguageVersion.CSharp10,
             }.RunAsync();
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
index 5006e28b22500..0a5525e588398 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
@@ -211,6 +211,7 @@ private static bool CastRemovalCouldCauseSignExtensionWarning(ExpressionSyntax c
 
             return false;
         }
+
         private static bool IsDelegateCreationCastSafeToRemove(
             ExpressionSyntax castNode, ExpressionSyntax castedExpressionNode,
             SemanticModel originalSemanticModel, IDelegateCreationOperation originalDelegateCreationOperation,
@@ -773,15 +774,21 @@ private static bool IsExplicitCastThatMustBePreserved(
 
                     // if we have `(T?)TExpr == nullableTExpr` then we can also remove this cast as the language will
                     // insert the same nullable widening cast implicitly.
+                    //
+                    // If we have `(T?)TExpr == TExpr` then we can potentially remove this cast if the caller determines
+                    // that there is an outer contextual cast to `T?` higher up.
                     var castSideType = semanticModel.GetTypeInfo(castSide, cancellationToken).Type;
                     var otherSideType = semanticModel.GetTypeInfo(otherSide, cancellationToken).Type;
                     var castedExpressionType = semanticModel.GetTypeInfo(castExpression.Expression, cancellationToken).Type;
 
                     if (castSideType.IsNullable(out var underlyingType) &&
-                        Equals(underlyingType, castedExpressionType) &&
-                        Equals(castSideType, otherSideType))
+                        Equals(underlyingType, castedExpressionType))
                     {
-                        return false;
+                        if (Equals(castSideType, otherSideType) ||
+                            Equals(underlyingType, otherSideType))
+                        {
+                            return false;
+                        }
                     }
                 }
             }

From e99be4a06406d38d6926cf953b9cec078204fe79 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 17 Jan 2022 01:52:30 -0800
Subject: [PATCH 405/444] Consistency

---
 .../CSharp/Simplification/Simplifiers/CastSimplifier.cs         | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
index 0a5525e588398..ac4c794948a47 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
@@ -229,9 +229,7 @@ private static bool IsDelegateCreationCastSafeToRemove(
 
             var rewrittenOperation = rewrittenSemanticModel.GetOperation(rewrittenExpression.WalkDownParentheses(), cancellationToken);
             if (rewrittenOperation is not (IAnonymousFunctionOperation or IMethodReferenceOperation))
-            {
                 return false;
-            }
 
             if (rewrittenOperation.Parent is not IDelegateCreationOperation rewrittenDelegateCreationOperation)
                 return false;

From 4404b0194ccb87b762fd1aeb4a3cf958926dae9b Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 17 Jan 2022 01:53:41 -0800
Subject: [PATCH 406/444] Simplify

---
 .../Simplification/Simplifiers/CastSimplifier.cs       | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
index ac4c794948a47..5162d60a94fea 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Simplification/Simplifiers/CastSimplifier.cs
@@ -776,17 +776,13 @@ private static bool IsExplicitCastThatMustBePreserved(
                     // If we have `(T?)TExpr == TExpr` then we can potentially remove this cast if the caller determines
                     // that there is an outer contextual cast to `T?` higher up.
                     var castSideType = semanticModel.GetTypeInfo(castSide, cancellationToken).Type;
-                    var otherSideType = semanticModel.GetTypeInfo(otherSide, cancellationToken).Type;
                     var castedExpressionType = semanticModel.GetTypeInfo(castExpression.Expression, cancellationToken).Type;
 
-                    if (castSideType.IsNullable(out var underlyingType) &&
-                        Equals(underlyingType, castedExpressionType))
+                    if (castSideType.IsNullable(out var underlyingType) && Equals(underlyingType, castedExpressionType))
                     {
-                        if (Equals(castSideType, otherSideType) ||
-                            Equals(underlyingType, otherSideType))
-                        {
+                        var otherSideType = semanticModel.GetTypeInfo(otherSide, cancellationToken).Type;
+                        if (Equals(castSideType, otherSideType) || Equals(underlyingType, otherSideType))
                             return false;
-                        }
                     }
                 }
             }

From 5a156a0337dfffc6ea8ac8a0b77e13e852cc47d8 Mon Sep 17 00:00:00 2001
From: "dotnet-maestro[bot]"
 <42748379+dotnet-maestro[bot]@users.noreply.github.com>
Date: Mon, 17 Jan 2022 14:58:22 +0000
Subject: [PATCH 407/444] Update dependencies from
 https://github.com/dotnet/roslyn build 20220112.11 (#58902)

[main] Update dependencies from dotnet/roslyn
---
 eng/Version.Details.xml | 4 ++--
 eng/Versions.props      | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index 1213dfd204e1b..8c1126c436718 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -18,9 +18,9 @@
       <Sha>ecf92bbdc4354adc1960fa53808e87d91624f9b5</Sha>
       <SourceBuild RepoName="arcade" ManagedOnly="true" />
     </Dependency>
-    <Dependency Name="Microsoft.Net.Compilers.Toolset" Version="4.1.0-3.22057.9">
+    <Dependency Name="Microsoft.Net.Compilers.Toolset" Version="4.1.0-3.22062.11">
       <Uri>https://github.com/dotnet/roslyn</Uri>
-      <Sha>a07da6871b3b7f53611b0f95530561286dd1e529</Sha>
+      <Sha>cc0d213b15fdda217ad888d269d19754fa556eb4</Sha>
     </Dependency>
     <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="7.0.0-beta.22063.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
diff --git a/eng/Versions.props b/eng/Versions.props
index 463595578559e..58ad1940a148c 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -15,7 +15,7 @@
       Keep the setting conditional. The toolset sets the assembly version to 42.42.42.42 if not set explicitly.
     -->
     <AssemblyVersion Condition="'$(OfficialBuild)' == 'true' or '$(DotNetUseShippingVersions)' == 'true'">$(MajorVersion).$(MinorVersion).0.0</AssemblyVersion>
-    <MicrosoftNetCompilersToolsetVersion>4.1.0-3.22057.9</MicrosoftNetCompilersToolsetVersion>
+    <MicrosoftNetCompilersToolsetVersion>4.1.0-3.22062.11</MicrosoftNetCompilersToolsetVersion>
   </PropertyGroup>
   <PropertyGroup>
     <!-- Versions used by several individual references below -->

From 71c2c5e77b2d767b60b164e56b9ba0df58e65c7d Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 17 Jan 2022 12:09:16 -0800
Subject: [PATCH 408/444] Fix 'remove unnecessary paren' case where we weren't
 removing around a suppressed expression

---
 ...veUnnecessaryExpressionParenthesesTests.cs | 52 +++++++++++++++++
 .../Extensions/ExpressionSyntaxExtensions.cs  |  3 +-
 ...ParenthesizedExpressionSyntaxExtensions.cs | 57 +++----------------
 3 files changed, 62 insertions(+), 50 deletions(-)

diff --git a/src/Analyzers/CSharp/Tests/RemoveUnnecessaryParentheses/RemoveUnnecessaryExpressionParenthesesTests.cs b/src/Analyzers/CSharp/Tests/RemoveUnnecessaryParentheses/RemoveUnnecessaryExpressionParenthesesTests.cs
index 35ab81a00acf0..be8d5e3e93685 100644
--- a/src/Analyzers/CSharp/Tests/RemoveUnnecessaryParentheses/RemoveUnnecessaryExpressionParenthesesTests.cs
+++ b/src/Analyzers/CSharp/Tests/RemoveUnnecessaryParentheses/RemoveUnnecessaryExpressionParenthesesTests.cs
@@ -2699,6 +2699,58 @@ public void M(object o)
         if (o is Goo) M(1);
     }    
 }
+", offeredWhenRequireForClarityIsEnabled: true);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryParentheses)]
+        public async Task TestElementAccessOfSuppressedExpression1()
+        {
+            await TestAsync(
+@"
+public class C
+{
+    public void M(string[] Strings)
+    {
+        var v = $$(Strings!)[Strings.Count - 1];
+    }
+}
+",
+@"
+public class C
+{
+    public void M(string[] Strings)
+    {
+        var v = Strings![Strings.Count - 1];
+    }
+}
+", offeredWhenRequireForClarityIsEnabled: true);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryParentheses)]
+        public async Task TestElementAccessOfSuppressedExpression2()
+        {
+            await TestAsync(
+@"
+public class C
+{
+    string[] Strings;
+
+    public void M()
+    {
+        var v = $$(this.Strings!)[Strings.Count - 1];
+    }
+}
+",
+@"
+public class C
+{
+    string[] Strings;
+
+    public void M()
+    {
+        var v = this.Strings![Strings.Count - 1];
+    }
+}
 ", offeredWhenRequireForClarityIsEnabled: true);
         }
     }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ExpressionSyntaxExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ExpressionSyntaxExtensions.cs
index 43a5fdbc698d4..33fba069dfed1 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ExpressionSyntaxExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ExpressionSyntaxExtensions.cs
@@ -727,11 +727,12 @@ public static OperatorPrecedence GetOperatorPrecedence(this ExpressionSyntax exp
                 case SyntaxKind.CheckedExpression:
                 case SyntaxKind.UncheckedExpression:
                 case SyntaxKind.AnonymousMethodExpression:
+                case SyntaxKind.SuppressNullableWarningExpression:
                 // unsafe code
                 case SyntaxKind.SizeOfExpression:
                 case SyntaxKind.PointerMemberAccessExpression:
                     // From C# spec, 7.3.1:
-                    // Primary: x.y  x?.y  x?[y]  f(x)  a[x]  x++  x--  new  typeof  default  checked  unchecked  delegate
+                    // Primary: x.y  x?.y  x?[y]  f(x)  a[x]  x++  x-- new  typeof  default  checked  unchecked  delegate x! 
 
                     return OperatorPrecedence.Primary;
 
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ParenthesizedExpressionSyntaxExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ParenthesizedExpressionSyntaxExtensions.cs
index cc04dbe9d5ac9..040e32a238a7f 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ParenthesizedExpressionSyntaxExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ParenthesizedExpressionSyntaxExtensions.cs
@@ -89,27 +89,19 @@ public static bool CanRemoveParentheses(
 
             // (x); -> x;
             if (node.IsParentKind(SyntaxKind.ExpressionStatement))
-            {
                 return true;
-            }
 
             // => (x)   ->   => x
             if (node.IsParentKind(SyntaxKind.ArrowExpressionClause))
-            {
                 return true;
-            }
 
             // checked((x)) -> checked(x)
-            if (node.IsParentKind(SyntaxKind.CheckedExpression) ||
-                node.IsParentKind(SyntaxKind.UncheckedExpression))
-            {
+            if (node.Parent?.Kind() is SyntaxKind.CheckedExpression or SyntaxKind.UncheckedExpression)
                 return true;
-            }
+
             // ((x, y)) -> (x, y)
             if (expression.IsKind(SyntaxKind.TupleExpression))
-            {
                 return true;
-            }
 
             // int Prop => (x); -> int Prop => x;
             if (node.Parent is ArrowExpressionClauseSyntax arrowExpressionClause && arrowExpressionClause.Expression == node)
@@ -161,30 +153,22 @@ public static bool CanRemoveParentheses(
             // Cases:
             //   (C)(this) -> (C)this
             if (node.IsParentKind(SyntaxKind.CastExpression) && expression.IsKind(SyntaxKind.ThisExpression))
-            {
                 return true;
-            }
 
             // Cases:
             //   y((x)) -> y(x)
             if (node.IsParentKind(SyntaxKind.Argument, out ArgumentSyntax argument) && argument.Expression == node)
-            {
                 return true;
-            }
 
             // Cases:
             //   $"{(x)}" -> $"{x}"
             if (node.IsParentKind(SyntaxKind.Interpolation))
-            {
                 return true;
-            }
 
             // Cases:
             //   ($"{x}") -> $"{x}"
             if (expression.IsKind(SyntaxKind.InterpolatedStringExpression))
-            {
                 return true;
-            }
 
             // Cases:
             //   {(x)} -> {x}
@@ -192,9 +176,7 @@ public static bool CanRemoveParentheses(
             {
                 // Assignment expressions are not allowed in initializers
                 if (expression.IsAnyAssignExpression())
-                {
                     return false;
-                }
 
                 return true;
             }
@@ -207,9 +189,7 @@ public static bool CanRemoveParentheses(
             {
                 // Assignment expressions are not allowed unless member is named
                 if (anonymousDeclarator.NameEquals == null && expression.IsAnyAssignExpression())
-                {
                     return false;
-                }
 
                 return true;
             }
@@ -217,17 +197,13 @@ public static bool CanRemoveParentheses(
             // Cases:
             // where (x + 1 > 14) -> where x + 1 > 14
             if (node.Parent is QueryClauseSyntax)
-            {
                 return true;
-            }
 
             // Cases:
             //   (x)   -> x
             //   (x.y) -> x.y
             if (IsSimpleOrDottedName(expression))
-            {
                 return true;
-            }
 
             // Cases:
             //   ('')      -> ''
@@ -238,15 +214,11 @@ public static bool CanRemoveParentheses(
             //   (default) -> default;
             //   (1)       -> 1
             if (expression.IsAnyLiteralExpression())
-            {
                 return true;
-            }
 
             // (this)   -> this
             if (expression.IsKind(SyntaxKind.ThisExpression))
-            {
                 return true;
-            }
 
             // x ?? (throw ...) -> x ?? throw ...
             if (expression.IsKind(SyntaxKind.ThrowExpression) &&
@@ -258,35 +230,25 @@ public static bool CanRemoveParentheses(
 
             // case (x): -> case x:
             if (node.IsParentKind(SyntaxKind.CaseSwitchLabel))
-            {
                 return true;
-            }
 
             // case (x) when y: -> case x when y:
             if (node.IsParentKind(SyntaxKind.ConstantPattern) &&
                 node.Parent.IsParentKind(SyntaxKind.CasePatternSwitchLabel))
-            {
                 return true;
-            }
 
             // case x when (y): -> case x when y:
             if (node.IsParentKind(SyntaxKind.WhenClause))
-            {
                 return true;
-            }
 
             // #if (x)   ->   #if x
             if (node.Parent is DirectiveTriviaSyntax)
-            {
                 return true;
-            }
 
             // Switch expression arm
             // x => (y)
             if (node.Parent is SwitchExpressionArmSyntax arm && arm.Expression == node)
-            {
                 return true;
-            }
 
             // If we have: (X)(++x) or (X)(--x), we don't want to remove the parens. doing so can
             // make the ++/-- now associate with the previous part of the cast expression.
@@ -313,9 +275,7 @@ public static bool CanRemoveParentheses(
             // parenthesized expression) now only conditionally run depending on if 'x' is null or
             // not.
             if (expression.IsKind(SyntaxKind.ConditionalAccessExpression))
-            {
                 return false;
-            }
 
             // Operator precedence cases:
             // - If the parent is not an expression, do not remove parentheses
@@ -542,11 +502,11 @@ private static bool RemovalMayIntroduceCastAmbiguity(ParenthesizedExpressionSynt
 
                 var expression = node.Expression;
 
-                if (expression.IsKind(
-                        SyntaxKind.UnaryMinusExpression,
-                        SyntaxKind.UnaryPlusExpression,
-                        SyntaxKind.PointerIndirectionExpression,
-                        SyntaxKind.AddressOfExpression))
+                if (expression.Kind() is
+                        SyntaxKind.UnaryMinusExpression or
+                        SyntaxKind.UnaryPlusExpression or
+                        SyntaxKind.PointerIndirectionExpression or
+                        SyntaxKind.AddressOfExpression)
                 {
                     return true;
                 }
@@ -698,8 +658,7 @@ private static bool IsNextExpressionPotentiallyAmbiguous(ExpressionSyntax node)
             }
 
             return IsSimpleOrDottedName(greaterThanExpression.Left)
-                && (greaterThanExpression.Right.IsKind(SyntaxKind.ParenthesizedExpression)
-                    || greaterThanExpression.Right.IsKind(SyntaxKind.CastExpression));
+                && greaterThanExpression.Right.Kind() is SyntaxKind.ParenthesizedExpression or SyntaxKind.CastExpression;
         }
 
         private static bool IsSimpleOrDottedName(ExpressionSyntax expression)

From df3db1b3ab96b4e7d564decb96227454e52aed45 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrus.najmabadi@gmail.com>
Date: Mon, 17 Jan 2022 10:10:15 -1000
Subject: [PATCH 409/444] Update
 src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ExpressionSyntaxExtensions.cs

---
 .../Compiler/CSharp/Extensions/ExpressionSyntaxExtensions.cs    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ExpressionSyntaxExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ExpressionSyntaxExtensions.cs
index 33fba069dfed1..3b42664bb30ca 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ExpressionSyntaxExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ExpressionSyntaxExtensions.cs
@@ -732,7 +732,7 @@ public static OperatorPrecedence GetOperatorPrecedence(this ExpressionSyntax exp
                 case SyntaxKind.SizeOfExpression:
                 case SyntaxKind.PointerMemberAccessExpression:
                     // From C# spec, 7.3.1:
-                    // Primary: x.y  x?.y  x?[y]  f(x)  a[x]  x++  x-- new  typeof  default  checked  unchecked  delegate x! 
+                    // Primary: x.y  x?.y  x?[y]  f(x)  a[x]  x++  x--  new  typeof  default  checked  unchecked  delegate  x! 
 
                     return OperatorPrecedence.Primary;
 

From fbf6d327b2fdf985946eb24a0be0968e2a31c05b Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 17 Jan 2022 12:18:42 -0800
Subject: [PATCH 410/444] NRT

---
 ...ParenthesizedExpressionSyntaxExtensions.cs | 103 +++++++++---------
 1 file changed, 51 insertions(+), 52 deletions(-)

diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ParenthesizedExpressionSyntaxExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ParenthesizedExpressionSyntaxExtensions.cs
index 040e32a238a7f..48a0ec4e07548 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ParenthesizedExpressionSyntaxExtensions.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ParenthesizedExpressionSyntaxExtensions.cs
@@ -2,8 +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.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -12,6 +10,7 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Extensions;
 using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Extensions
@@ -27,6 +26,10 @@ public static bool CanRemoveParentheses(
                 return false;
             }
 
+            var nodeParent = node.Parent;
+            if (nodeParent == null)
+                return false;
+
             var expression = node.Expression;
 
             // The 'direct' expression that contains this parenthesized node.  Note: in the case
@@ -34,9 +37,9 @@ public static bool CanRemoveParentheses(
             // node between the 'is-pattern' node and the parenthesized expression.  So we manually
             // jump past that as, for all intents and purposes, we want to consider the 'is' expression
             // as the parent expression of the (y) expression.
-            var parentExpression = node.IsParentKind(SyntaxKind.ConstantPattern)
-                ? node.Parent.Parent as ExpressionSyntax
-                : node.Parent as ExpressionSyntax;
+            var parentExpression = nodeParent.IsKind(SyntaxKind.ConstantPattern)
+                ? nodeParent.Parent as ExpressionSyntax
+                : nodeParent as ExpressionSyntax;
 
             // Have to be careful if we would remove parens and cause a + and a + to become a ++.
             // (same with - as well).
@@ -66,7 +69,7 @@ public static bool CanRemoveParentheses(
                 // The code semantics changes if the parenthesis removed.
                 // With parenthesis:    variable span is of type `Span<byte>`.
                 // Without parenthesis: variable span is of type `byte*` which can only be used in unsafe context.
-                if (node.Parent is EqualsValueClauseSyntax { Parent: VariableDeclaratorSyntax { Parent: VariableDeclarationSyntax varDecl } })
+                if (nodeParent is EqualsValueClauseSyntax { Parent: VariableDeclaratorSyntax { Parent: VariableDeclarationSyntax varDecl } })
                 {
                     // we have either `var x = (stackalloc byte[8])` or `Span<byte> x = (stackalloc byte[8])`.  The former
                     // is not safe to remove. the latter is.
@@ -88,15 +91,15 @@ public static bool CanRemoveParentheses(
                 return true;
 
             // (x); -> x;
-            if (node.IsParentKind(SyntaxKind.ExpressionStatement))
+            if (nodeParent.IsKind(SyntaxKind.ExpressionStatement))
                 return true;
 
             // => (x)   ->   => x
-            if (node.IsParentKind(SyntaxKind.ArrowExpressionClause))
+            if (nodeParent.IsKind(SyntaxKind.ArrowExpressionClause))
                 return true;
 
             // checked((x)) -> checked(x)
-            if (node.Parent?.Kind() is SyntaxKind.CheckedExpression or SyntaxKind.UncheckedExpression)
+            if (nodeParent.Kind() is SyntaxKind.CheckedExpression or SyntaxKind.UncheckedExpression)
                 return true;
 
             // ((x, y)) -> (x, y)
@@ -104,7 +107,7 @@ public static bool CanRemoveParentheses(
                 return true;
 
             // int Prop => (x); -> int Prop => x;
-            if (node.Parent is ArrowExpressionClauseSyntax arrowExpressionClause && arrowExpressionClause.Expression == node)
+            if (nodeParent is ArrowExpressionClauseSyntax arrowExpressionClause && arrowExpressionClause.Expression == node)
             {
                 return true;
             }
@@ -124,19 +127,19 @@ public static bool CanRemoveParentheses(
             //   lock ((x))             -> lock (x)
             //   using ((x))            -> using (x)
             //   catch when ((x))       -> catch when (x)
-            if ((node.IsParentKind(SyntaxKind.EqualsValueClause, out EqualsValueClauseSyntax equalsValue) && equalsValue.Value == node) ||
-                (node.IsParentKind(SyntaxKind.IfStatement, out IfStatementSyntax ifStatement) && ifStatement.Condition == node) ||
-                (node.IsParentKind(SyntaxKind.ReturnStatement, out ReturnStatementSyntax returnStatement) && returnStatement.Expression == node) ||
-                (node.IsParentKind(SyntaxKind.YieldReturnStatement, out YieldStatementSyntax yieldStatement) && yieldStatement.Expression == node) ||
-                (node.IsParentKind(SyntaxKind.ThrowStatement, out ThrowStatementSyntax throwStatement) && throwStatement.Expression == node) ||
-                (node.IsParentKind(SyntaxKind.SwitchStatement, out SwitchStatementSyntax switchStatement) && switchStatement.Expression == node) ||
-                (node.IsParentKind(SyntaxKind.WhileStatement, out WhileStatementSyntax whileStatement) && whileStatement.Condition == node) ||
-                (node.IsParentKind(SyntaxKind.DoStatement, out DoStatementSyntax doStatement) && doStatement.Condition == node) ||
-                (node.IsParentKind(SyntaxKind.ForStatement, out ForStatementSyntax forStatement) && forStatement.Condition == node) ||
-                (node.IsParentKind(SyntaxKind.ForEachStatement, SyntaxKind.ForEachVariableStatement) && ((CommonForEachStatementSyntax)node.Parent).Expression == node) ||
-                (node.IsParentKind(SyntaxKind.LockStatement, out LockStatementSyntax lockStatement) && lockStatement.Expression == node) ||
-                (node.IsParentKind(SyntaxKind.UsingStatement, out UsingStatementSyntax usingStatement) && usingStatement.Expression == node) ||
-                (node.IsParentKind(SyntaxKind.CatchFilterClause, out CatchFilterClauseSyntax catchFilter) && catchFilter.FilterExpression == node))
+            if ((nodeParent.IsKind(SyntaxKind.EqualsValueClause, out EqualsValueClauseSyntax? equalsValue) && equalsValue.Value == node) ||
+                (nodeParent.IsKind(SyntaxKind.IfStatement, out IfStatementSyntax? ifStatement) && ifStatement.Condition == node) ||
+                (nodeParent.IsKind(SyntaxKind.ReturnStatement, out ReturnStatementSyntax? returnStatement) && returnStatement.Expression == node) ||
+                (nodeParent.IsKind(SyntaxKind.YieldReturnStatement, out YieldStatementSyntax? yieldStatement) && yieldStatement.Expression == node) ||
+                (nodeParent.IsKind(SyntaxKind.ThrowStatement, out ThrowStatementSyntax? throwStatement) && throwStatement.Expression == node) ||
+                (nodeParent.IsKind(SyntaxKind.SwitchStatement, out SwitchStatementSyntax? switchStatement) && switchStatement.Expression == node) ||
+                (nodeParent.IsKind(SyntaxKind.WhileStatement, out WhileStatementSyntax? whileStatement) && whileStatement.Condition == node) ||
+                (nodeParent.IsKind(SyntaxKind.DoStatement, out DoStatementSyntax? doStatement) && doStatement.Condition == node) ||
+                (nodeParent.IsKind(SyntaxKind.ForStatement, out ForStatementSyntax? forStatement) && forStatement.Condition == node) ||
+                (nodeParent.IsKind(SyntaxKind.ForEachStatement, SyntaxKind.ForEachVariableStatement) && ((CommonForEachStatementSyntax)node.GetRequiredParent()).Expression == node) ||
+                (nodeParent.IsKind(SyntaxKind.LockStatement, out LockStatementSyntax? lockStatement) && lockStatement.Expression == node) ||
+                (nodeParent.IsKind(SyntaxKind.UsingStatement, out UsingStatementSyntax? usingStatement) && usingStatement.Expression == node) ||
+                (nodeParent.IsKind(SyntaxKind.CatchFilterClause, out CatchFilterClauseSyntax? catchFilter) && catchFilter.FilterExpression == node))
             {
                 return true;
             }
@@ -152,17 +155,17 @@ public static bool CanRemoveParentheses(
 
             // Cases:
             //   (C)(this) -> (C)this
-            if (node.IsParentKind(SyntaxKind.CastExpression) && expression.IsKind(SyntaxKind.ThisExpression))
+            if (nodeParent.IsKind(SyntaxKind.CastExpression) && expression.IsKind(SyntaxKind.ThisExpression))
                 return true;
 
             // Cases:
             //   y((x)) -> y(x)
-            if (node.IsParentKind(SyntaxKind.Argument, out ArgumentSyntax argument) && argument.Expression == node)
+            if (nodeParent.IsKind(SyntaxKind.Argument, out ArgumentSyntax? argument) && argument.Expression == node)
                 return true;
 
             // Cases:
             //   $"{(x)}" -> $"{x}"
-            if (node.IsParentKind(SyntaxKind.Interpolation))
+            if (nodeParent.IsKind(SyntaxKind.Interpolation))
                 return true;
 
             // Cases:
@@ -172,7 +175,7 @@ public static bool CanRemoveParentheses(
 
             // Cases:
             //   {(x)} -> {x}
-            if (node.Parent is InitializerExpressionSyntax)
+            if (nodeParent is InitializerExpressionSyntax)
             {
                 // Assignment expressions are not allowed in initializers
                 if (expression.IsAnyAssignExpression())
@@ -185,7 +188,7 @@ public static bool CanRemoveParentheses(
             //   new {(x)} -> {x}
             //   new { a = (x)} -> { a = x }
             //   new { a = (x = c)} -> { a = x = c }
-            if (node.Parent is AnonymousObjectMemberDeclaratorSyntax anonymousDeclarator)
+            if (nodeParent is AnonymousObjectMemberDeclaratorSyntax anonymousDeclarator)
             {
                 // Assignment expressions are not allowed unless member is named
                 if (anonymousDeclarator.NameEquals == null && expression.IsAnyAssignExpression())
@@ -196,7 +199,7 @@ public static bool CanRemoveParentheses(
 
             // Cases:
             // where (x + 1 > 14) -> where x + 1 > 14
-            if (node.Parent is QueryClauseSyntax)
+            if (nodeParent is QueryClauseSyntax)
                 return true;
 
             // Cases:
@@ -222,32 +225,34 @@ public static bool CanRemoveParentheses(
 
             // x ?? (throw ...) -> x ?? throw ...
             if (expression.IsKind(SyntaxKind.ThrowExpression) &&
-                node.IsParentKind(SyntaxKind.CoalesceExpression, out BinaryExpressionSyntax binary) &&
+                nodeParent.IsKind(SyntaxKind.CoalesceExpression, out BinaryExpressionSyntax? binary) &&
                 binary.Right == node)
             {
                 return true;
             }
 
             // case (x): -> case x:
-            if (node.IsParentKind(SyntaxKind.CaseSwitchLabel))
+            if (nodeParent.IsKind(SyntaxKind.CaseSwitchLabel))
                 return true;
 
             // case (x) when y: -> case x when y:
-            if (node.IsParentKind(SyntaxKind.ConstantPattern) &&
-                node.Parent.IsParentKind(SyntaxKind.CasePatternSwitchLabel))
+            if (nodeParent.IsKind(SyntaxKind.ConstantPattern) &&
+                nodeParent.IsParentKind(SyntaxKind.CasePatternSwitchLabel))
+            {
                 return true;
+            }
 
             // case x when (y): -> case x when y:
-            if (node.IsParentKind(SyntaxKind.WhenClause))
+            if (nodeParent.IsKind(SyntaxKind.WhenClause))
                 return true;
 
             // #if (x)   ->   #if x
-            if (node.Parent is DirectiveTriviaSyntax)
+            if (nodeParent is DirectiveTriviaSyntax)
                 return true;
 
             // Switch expression arm
             // x => (y)
-            if (node.Parent is SwitchExpressionArmSyntax arm && arm.Expression == node)
+            if (nodeParent is SwitchExpressionArmSyntax arm && arm.Expression == node)
                 return true;
 
             // If we have: (X)(++x) or (X)(--x), we don't want to remove the parens. doing so can
@@ -307,24 +312,18 @@ private static bool RemovalMayIntroduceInterpolationAmbiguity(ParenthesizedExpre
         {
             // First, find the parenting interpolation. If we find a parenthesize expression first,
             // we can bail out early.
-            InterpolationSyntax interpolation = null;
-            foreach (var ancestor in node.Parent.AncestorsAndSelf())
+            InterpolationSyntax? interpolation = null;
+            foreach (var ancestor in node.GetRequiredParent().AncestorsAndSelf())
             {
                 if (ancestor.IsKind(SyntaxKind.ParenthesizedExpression))
-                {
                     return false;
-                }
 
                 if (ancestor.IsKind(SyntaxKind.Interpolation, out interpolation))
-                {
                     break;
-                }
             }
 
             if (interpolation == null)
-            {
                 return false;
-            }
 
             // In order determine whether removing this parenthesized expression will introduce a
             // parsing ambiguity, we must dig into the child tokens and nodes to determine whether
@@ -345,7 +344,7 @@ private static bool RemovalMayIntroduceInterpolationAmbiguity(ParenthesizedExpre
                         // Note: There's no need drill into other parenthesized expressions, since any colons in them would be unambiguous.
                         if (nodeOrToken.IsNode && !nodeOrToken.IsKind(SyntaxKind.ParenthesizedExpression))
                         {
-                            stack.Push(nodeOrToken.AsNode());
+                            stack.Push(nodeOrToken.AsNode()!);
                         }
                         else if (nodeOrToken.IsToken)
                         {
@@ -484,7 +483,7 @@ private static bool RemovalMayIntroduceCastAmbiguity(ParenthesizedExpressionSynt
             //      (X?)(...)
             //      (global::X)(...)
 
-            if (node.IsParentKind(SyntaxKind.CastExpression, out CastExpressionSyntax castExpression))
+            if (node.IsParentKind(SyntaxKind.CastExpression, out CastExpressionSyntax? castExpression))
             {
                 if (castExpression.Type.IsKind(
                         SyntaxKind.PredefinedType,
@@ -594,9 +593,9 @@ private static bool RemovalMayIntroduceCommaListAmbiguity(ParenthesizedExpressio
 
         private static bool IsPreviousExpressionPotentiallyAmbiguous(ExpressionSyntax node)
         {
-            ExpressionSyntax previousExpression = null;
+            ExpressionSyntax? previousExpression = null;
 
-            if (node.IsParentKind(SyntaxKind.Argument, out ArgumentSyntax argument))
+            if (node.IsParentKind(SyntaxKind.Argument, out ArgumentSyntax? argument))
             {
                 if (argument.Parent is ArgumentListSyntax argumentList)
                 {
@@ -617,7 +616,7 @@ private static bool IsPreviousExpressionPotentiallyAmbiguous(ExpressionSyntax no
             }
 
             if (previousExpression == null ||
-                !previousExpression.IsKind(SyntaxKind.LessThanExpression, out BinaryExpressionSyntax lessThanExpression))
+                !previousExpression.IsKind(SyntaxKind.LessThanExpression, out BinaryExpressionSyntax? lessThanExpression))
             {
                 return false;
             }
@@ -629,9 +628,9 @@ private static bool IsPreviousExpressionPotentiallyAmbiguous(ExpressionSyntax no
 
         private static bool IsNextExpressionPotentiallyAmbiguous(ExpressionSyntax node)
         {
-            ExpressionSyntax nextExpression = null;
+            ExpressionSyntax? nextExpression = null;
 
-            if (node.IsParentKind(SyntaxKind.Argument, out ArgumentSyntax argument))
+            if (node.IsParentKind(SyntaxKind.Argument, out ArgumentSyntax? argument))
             {
                 if (argument.Parent is ArgumentListSyntax argumentList)
                 {
@@ -652,7 +651,7 @@ private static bool IsNextExpressionPotentiallyAmbiguous(ExpressionSyntax node)
             }
 
             if (nextExpression == null ||
-                !nextExpression.IsKind(SyntaxKind.GreaterThanExpression, out BinaryExpressionSyntax greaterThanExpression))
+                !nextExpression.IsKind(SyntaxKind.GreaterThanExpression, out BinaryExpressionSyntax? greaterThanExpression))
             {
                 return false;
             }

From 925fb7f7320a57758706ed69d90b4ea6ef433b0e Mon Sep 17 00:00:00 2001
From: dotnet bot <dotnet-bot@dotnetfoundation.org>
Date: Mon, 17 Jan 2022 17:32:59 -0800
Subject: [PATCH 411/444] Localized file check-in by OneLocBuild Task: Build
 definition ID 327: Build ID 1557542


From 1aab09a7e6d67e8bdbf6f2c9628381b3091045f0 Mon Sep 17 00:00:00 2001
From: dotnet bot <dotnet-bot@dotnetfoundation.org>
Date: Mon, 17 Jan 2022 17:35:43 -0800
Subject: [PATCH 412/444] Localized file check-in by OneLocBuild Task: Build
 definition ID 327: Build ID 1557542

---
 src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf | 2 +-
 src/Features/Core/Portable/xlf/FeaturesResources.it.xlf | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf
index b805709d77a5d..461c9bb1d6429 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf
@@ -2352,7 +2352,7 @@ Les assertions arrière positives de largeur nulle sont généralement utilisée
       </trans-unit>
       <trans-unit id="Silent">
         <source>Silent</source>
-        <target state="translated">Silent</target>
+        <target state="translated">Silencieux</target>
         <note />
       </trans-unit>
       <trans-unit id="Sort_accessibility_modifiers">
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf
index eb892febb49ba..37be60cf20496 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf
@@ -2352,7 +2352,7 @@ Le asserzioni lookbehind positive di larghezza zero vengono usate in genere all'
       </trans-unit>
       <trans-unit id="Silent">
         <source>Silent</source>
-        <target state="translated">Silent</target>
+        <target state="translated">Invisibile</target>
         <note />
       </trans-unit>
       <trans-unit id="Sort_accessibility_modifiers">

From 59fddf275398145081876010446216b38b145a09 Mon Sep 17 00:00:00 2001
From: dotnet bot <dotnet-bot@dotnetfoundation.org>
Date: Mon, 17 Jan 2022 17:41:32 -0800
Subject: [PATCH 413/444] Localized file check-in by OneLocBuild Task: Build
 definition ID 327: Build ID 1557542

---
 .../xlf/FeaturesResources.zh-Hant.xlf         |   2 +-
 .../CSharp/Impl/xlf/VSPackage.cs.xlf          | 101 +++++++++---------
 .../CSharp/Impl/xlf/VSPackage.de.xlf          |  99 ++++++++---------
 .../CSharp/Impl/xlf/VSPackage.es.xlf          | 100 ++++++++---------
 .../CSharp/Impl/xlf/VSPackage.fr.xlf          |  99 ++++++++---------
 .../CSharp/Impl/xlf/VSPackage.it.xlf          |  99 ++++++++---------
 .../CSharp/Impl/xlf/VSPackage.ja.xlf          | 101 +++++++++---------
 .../CSharp/Impl/xlf/VSPackage.ko.xlf          |  99 ++++++++---------
 .../CSharp/Impl/xlf/VSPackage.pl.xlf          | 101 +++++++++---------
 .../CSharp/Impl/xlf/VSPackage.pt-BR.xlf       |  99 ++++++++---------
 .../CSharp/Impl/xlf/VSPackage.ru.xlf          | 101 +++++++++---------
 .../CSharp/Impl/xlf/VSPackage.tr.xlf          | 101 +++++++++---------
 .../CSharp/Impl/xlf/VSPackage.zh-Hans.xlf     |  99 ++++++++---------
 .../CSharp/Impl/xlf/VSPackage.zh-Hant.xlf     |  99 ++++++++---------
 .../Core/Def/xlf/Commands.vsct.ja.xlf         |   2 +-
 15 files changed, 657 insertions(+), 645 deletions(-)

diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf
index db0472a9be682..f35e8c169d6da 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf
@@ -2352,7 +2352,7 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
       </trans-unit>
       <trans-unit id="Silent">
         <source>Silent</source>
-        <target state="translated">Silent</target>
+        <target state="translated">靜音</target>
         <note />
       </trans-unit>
       <trans-unit id="Sort_accessibility_modifiers">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.cs.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.cs.xlf
index c49074031cdfd..e99b3e0b55a33 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.cs.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.cs.xlf
@@ -84,56 +84,57 @@ Use enhanced colors;
 Editor Color Scheme;
 Inheritance Margin;
 Stack Trace Explorer;</source>
-        <target state="needs-review-translation">Podtrhnout znovu přiřazené proměnné;
-Zobrazovat vložené nápovědy;
-Zobrazit diagnostiku pro zavřené soubory;
-Vybarvit regulární výraz;
-Zvýrazňovat související komponenty pod kurzorem;
-Nahlásit neplatné regulární výrazy;
-Povolit úplnou analýzu řešení;
-Provést analýzu funkcí editoru v externím procesu;
-Povolit navigaci na dekompilované zdroje;
-Direktivy using;
-Při řazení direktiv using umístit systémové direktivy jako první;
-Oddělovat skupiny direktiv using;
-Navrhnout použití typů v sestaveních reference;
-Navrhnout použití typů v balíčcích NuGet;
-Zvýrazňování;
-Zvýrazňovat odkazy na symbol pod kurzorem;
-Zvýrazňovat související klíčová slova pod kurzorem;
-Sbalení;
-Po otevření souborů přejít do režimu osnovy;
-Zobrazovat oddělovače řádků procedur;
-Zobrazit sbalení pro konstrukty na úrovni deklarace;
-Zobrazit sbalení pro konstrukty na úrovni kódu;
-Zobrazit sbalení pro komentáře a oblasti pro preprocesor;
-Při sbalování na definice sbalovat oblasti;
-Zesvětlení;
-Zesvětlit nepoužité direktivy using;
-Zesvětlit nedosažitelný kód;
-Vodítka pro strukturu bloku;
-Zobrazit vodítka pro konstrukty na úrovni deklarace;
-Zobrazit vodítka pro konstrukty na úrovni kódu;
-Nápověda k editoru;
-Generovat komentáře dokumentace XML pro ///;
-Při psaní komentářů /* */ vkládat na začátek nových řádků hvězdičku (*);
-Zobrazovat náhled pro sledování přejmenování;
-Rozdělit literály řetězců u Enter;
-Oznamovat neplatné zástupné symboly ve voláních string.Format;
-Extrahovat metodu;
-Nevkládat odkaz nebo výstup do vlastní struktury;
-Implementovat rozhraní nebo abstraktní třídu;
-Vlastnosti, události a metody při vkládání umístit;
-s ostatními členy stejného druhu;
-na konec;
-Při generování vlastnosti;
-preferovat vyvolávací vlastnosti;
-preferovat automatické vlastnosti;
-reg. výr.;
-regulární výraz;
-Používat rozšířené barvy;
-Barevné schéma editoru;
-Okraj dědičnosti</target>
+        <target state="new">Underline reassigned variables;
+Display inline hints;
+Show diagnostics for closed files;
+Colorize regular expression; 
+Highlight related components under cursor; 
+Report invalid regular expressions;
+Enable full solution analysis;
+Perform editor feature analysis in external process;
+Enable navigation to decompiled sources;
+Using directives;
+Place system directives first when sorting usings;
+Separate using directive groups;
+Suggest usings for types in reference assemblies;
+Suggest usings for types in NuGet packages;
+Highlighting;
+Highlight references to symbol under cursor;
+Highlight related keywords under cursor;
+Outlining;
+Enter outlining mode when files open;
+Show procedure line separators;
+Show outlining for declaration level constructs;
+Show outlining for code level constructs;
+Show outlining for comments and preprocessor regions;
+Collapse regions when collapsing to definitions;
+Fading;
+Fade out unused usings;
+Fade out unreachable code;
+Block Structure Guides;
+Show guides for declaration level constructs;
+Show guides for code level constructs;
+Editor Help;
+Generate XML documentation comments for ///;
+Insert * at the start of new lines when writing /* */ comments;
+Show preview for rename tracking;
+Split string literals on Enter;
+Report invalid placeholders in string.Format calls;
+Extract Method;
+Don't put ref or out on custom struct;
+Implement Interface or Abstract Class;
+When inserting properties, events and methods, place them;
+with other members of the same kind;
+at the end;
+When generating property;
+prefer throwing properties;
+prefer auto properties;
+regex;
+regular expression;
+Use enhanced colors;
+Editor Color Scheme;
+Inheritance Margin;
+Stack Trace Explorer;</target>
         <note>C# Advanced options page keywords</note>
       </trans-unit>
       <trans-unit id="307">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.de.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.de.xlf
index 1fed08b1cf25e..79a4648506fb9 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.de.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.de.xlf
@@ -84,56 +84,57 @@ Use enhanced colors;
 Editor Color Scheme;
 Inheritance Margin;
 Stack Trace Explorer;</source>
-        <target state="needs-review-translation">Neu zugewiesene Variablen unterstreichen;
-Inlinehinweise anzeigen;
-Diagnoseinformationen für geschlossene Dateien anzeigen;
-Reguläre Ausdrücke farbig hervorheben;
-Zugehörige Komponenten unter dem Cursor markieren;
-Ungültige reguläre Ausdrücke melden;
-Vollständige Lösungsanalyse aktivieren;
-Editor-Funktionsanalyse in externem Prozess ausführen;
-Navigation zu dekompilierten Quellen aktivieren;
-using-Anweisungen;
-Systemanweisungen beim Sortieren von using-Anweisungen an erster Stelle platzieren;
-Gruppen von using-Anweisungen trennen;
-using-Anweisungen für Typen in Verweisassemblys vorschlagen;
-using-Anweisungen für Typen in NuGet-Paketen vorschlagen;
-Hervorhebung;
-Verweise auf Symbol unter Cursor hervorheben;
-Verwandte Schlüsselbegriffe unter Cursor anzeigen;
-Gliederung;
-Gliederungsmodus beim Öffnen von Dateien starten;
-Zeilentrennzeichen in Prozeduren anzeigen;
-Gliederung für Konstrukte auf Deklarationsebene anzeigen;
-Gliederung für Konstrukte auf Codeebene anzeigen;
-Gliederung für Kommentare und Präprozessorregionen anzeigen;
-Regionen beim Reduzieren auf Definitionen zuklappen;
-Ausblenden;
-Nicht verwendete using-Anweisungen ausblenden;
-Unerreichbaren Code ausblenden;
-Führungslinien für Struktur blockieren;
-Führungslinien für Konstrukte auf Deklarationsebene anzeigen;
-Führungslinien für Konstrukte auf Codeebene anzeigen;
-Editor-Hilfe;
-XML-Dokumentationskommentare für /// generieren;
-Beim Schreiben von Kommentaren (/* */) * am Beginn neuer Zeilen einfügen;
-Vorschau für Nachverfolgung beim Umbenennen anzeigen;
-Zeichenfolgenliterale bei Eingabe teilen;
-Ungültige Platzhalter in string.Format-Aufrufen melden;
-Methode extrahieren;
-ref oder out nicht in benutzerdefinierte Struktur platzieren;
-Schnittstellen- oder abstrakte Klasse implementieren;
-Eigenschaften, Ereignisse und Methoden beim Einfügen;
-bei anderen Membern derselben Art platzieren;
-am Ende platzieren;
-Beim Generieren von Eigenschaften;
-ausgelöste Eigenschaften bevorzugen;
-automatische Eigenschaften bevorzugen;
+        <target state="new">Underline reassigned variables;
+Display inline hints;
+Show diagnostics for closed files;
+Colorize regular expression; 
+Highlight related components under cursor; 
+Report invalid regular expressions;
+Enable full solution analysis;
+Perform editor feature analysis in external process;
+Enable navigation to decompiled sources;
+Using directives;
+Place system directives first when sorting usings;
+Separate using directive groups;
+Suggest usings for types in reference assemblies;
+Suggest usings for types in NuGet packages;
+Highlighting;
+Highlight references to symbol under cursor;
+Highlight related keywords under cursor;
+Outlining;
+Enter outlining mode when files open;
+Show procedure line separators;
+Show outlining for declaration level constructs;
+Show outlining for code level constructs;
+Show outlining for comments and preprocessor regions;
+Collapse regions when collapsing to definitions;
+Fading;
+Fade out unused usings;
+Fade out unreachable code;
+Block Structure Guides;
+Show guides for declaration level constructs;
+Show guides for code level constructs;
+Editor Help;
+Generate XML documentation comments for ///;
+Insert * at the start of new lines when writing /* */ comments;
+Show preview for rename tracking;
+Split string literals on Enter;
+Report invalid placeholders in string.Format calls;
+Extract Method;
+Don't put ref or out on custom struct;
+Implement Interface or Abstract Class;
+When inserting properties, events and methods, place them;
+with other members of the same kind;
+at the end;
+When generating property;
+prefer throwing properties;
+prefer auto properties;
 regex;
-regulärer Ausdruck;
-Erweiterte Farben verwenden;
-Editor-Farbschema;
-Vererbungsrand;</target>
+regular expression;
+Use enhanced colors;
+Editor Color Scheme;
+Inheritance Margin;
+Stack Trace Explorer;</target>
         <note>C# Advanced options page keywords</note>
       </trans-unit>
       <trans-unit id="307">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.es.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.es.xlf
index 181691d7fab3e..89c86e85a86ff 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.es.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.es.xlf
@@ -84,57 +84,57 @@ Use enhanced colors;
 Editor Color Scheme;
 Inheritance Margin;
 Stack Trace Explorer;</source>
-        <target state="needs-review-translation">Subrayar variables reasignadas;
-Mostrar sugerencias insertadas;
-Mostrar diagnóstico para archivos cerrados;
-Colorear expresión regular;
- 
-Resaltar componentes relacionados bajo el cursor; 
-Informar sobre expresiones regulares no válidas;
-Habilitar análisis de la solución completa;
-Realizar el análisis de características del editor en proceso externo;
-Habilitar la navegación a orígenes descompilados;
-Directivas using;
-Poner directivas del sistema primero cuando se organicen instrucciones using;
-Separar grupos de directivas using;
-Sugerir directivas using para los tipos en los ensamblados de referencia;
-Sugerir directivas using para los tipos en los paquetes NuGet;
-Resaltar;
-Resaltar referencias al símbolo bajo el cursor;
-Resaltar palabras clave relacionadas bajo el cursor;
-Esquematización;
-Especificar el modo de esquematización al abrir los archivos;
-Mostrar separadores de líneas de procedimientos;
-Mostrar esquematización para construcciones a nivel de declaración;
-Mostrar esquematización para construcciones a nivel de código;
-Mostrar esquematización para regiones de preprocesador y comentarios;
-Contraer regiones cuando se contraigan las definiciones;
-Atenuación;
-Atenuar directivas using no usadas;
-Atenuar código inaccesible;
-Guías de estructura de bloque;
-Mostrar guías para construcciones a nivel de declaración;
-Mostrar guías para construcciones a nivel de código;
-Ayuda del editor;
-Generar comentarios de documentación XML para ///;
-Insertar * al comienzo de las nuevas líneas al escribir comentarios /* */;
-Mostrar vista previa para seguimiento de cambio de nombre;
-Dividir literales de cadena al presionar Entrar;
-Informar sobre marcadores de posición no válidos en llamadas a string.Format;
-Extraer método;
-No colocar "out" o "ref" en estructura personalizada;
-Implementar interfaz o clase abstracta;
-Al insertar propiedades, eventos y métodos, colóquelos;
-con otros miembros de la misma clase;
-al final;
-Al generar una propiedad;
-preferir propiedades de lanzamiento;
-preferir propiedades automáticas;
+        <target state="new">Underline reassigned variables;
+Display inline hints;
+Show diagnostics for closed files;
+Colorize regular expression; 
+Highlight related components under cursor; 
+Report invalid regular expressions;
+Enable full solution analysis;
+Perform editor feature analysis in external process;
+Enable navigation to decompiled sources;
+Using directives;
+Place system directives first when sorting usings;
+Separate using directive groups;
+Suggest usings for types in reference assemblies;
+Suggest usings for types in NuGet packages;
+Highlighting;
+Highlight references to symbol under cursor;
+Highlight related keywords under cursor;
+Outlining;
+Enter outlining mode when files open;
+Show procedure line separators;
+Show outlining for declaration level constructs;
+Show outlining for code level constructs;
+Show outlining for comments and preprocessor regions;
+Collapse regions when collapsing to definitions;
+Fading;
+Fade out unused usings;
+Fade out unreachable code;
+Block Structure Guides;
+Show guides for declaration level constructs;
+Show guides for code level constructs;
+Editor Help;
+Generate XML documentation comments for ///;
+Insert * at the start of new lines when writing /* */ comments;
+Show preview for rename tracking;
+Split string literals on Enter;
+Report invalid placeholders in string.Format calls;
+Extract Method;
+Don't put ref or out on custom struct;
+Implement Interface or Abstract Class;
+When inserting properties, events and methods, place them;
+with other members of the same kind;
+at the end;
+When generating property;
+prefer throwing properties;
+prefer auto properties;
 regex;
-expresión regular;
-Usar colores mejorados;
-Combinación de colores del editor;
-Margen de herencia;</target>
+regular expression;
+Use enhanced colors;
+Editor Color Scheme;
+Inheritance Margin;
+Stack Trace Explorer;</target>
         <note>C# Advanced options page keywords</note>
       </trans-unit>
       <trans-unit id="307">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.fr.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.fr.xlf
index 7024d2f2729f4..effc18585f42e 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.fr.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.fr.xlf
@@ -84,56 +84,57 @@ Use enhanced colors;
 Editor Color Scheme;
 Inheritance Margin;
 Stack Trace Explorer;</source>
-        <target state="needs-review-translation">Souligner les variables réaffectées;
-Afficher les indicateurs inline;
-Afficher les diagnostics pour les fichiers fermés;
-Mettre en couleurs l'expression régulière; 
-Surligner les composants liés sous le curseur; 
-Signaler les expressions régulières non valides;
-Activer l'analyse complète de la solution;
-Effectuer l'analyse des fonctionnalités de l'éditeur dans un processus externe;
-Activer la navigation vers les sources décompilées;
-Directives using;
-Placer en premier les directives system au moment du tri des using;
-Séparer les groupes de directives using;
-Suggérer des using pour les types dans les assemblys de référence;
-Suggérer des using pour les types dans les packages NuGet;
-Mise en surbrillance;
-Mettre en surbrillance les références au symbole sous le curseur;
-Mettre en surbrillance les mots clés liés sous le curseur;
-Mode Plan;
-Passer en mode Plan à l'ouverture des fichiers;
-Afficher les séparateurs de ligne de procédure;
-Afficher le mode Plan pour les constructions au niveau des déclarations;
-Afficher le mode Plan pour les constructions au niveau du code;
-Afficher le mode Plan pour les commentaires et les régions du préprocesseur;
-Réduire les régions au moment de la réduction aux définitions;
-Atténuation;
-Atténuer les using inutilisés;
-Atténuer le code inaccessible;
-Repères de structure de bloc;
-Afficher les repères pour les constructions au niveau des déclarations;
-Afficher les repères pour les constructions au niveau du code;
-Aide de l'éditeur;
-Générer des commentaires de documentation XML pour ///;
-Insérer * au début des nouvelles lignes pour l'écriture de commentaires /* */;
-Afficher un aperçu pour le suivi des renommages;
-Diviser les littéraux de chaîne avec Entrée;
-Signaler les espaces réservés non valides dans les appels de string.Format;
-Extraire la méthode;
-Ne pas placer ref ou out dans un struct personnalisé;
-Implémenter une interface ou une classe abstraite;
-Au moment d'insérer des propriétés, des événements et des méthodes, les placer;
-avec d'autres membres du même genre;
-à la fin;
-Durant la génération de propriétés;
-préférer les propriétés de levée d'exceptions;
-préférer les propriétés automatiques;
+        <target state="new">Underline reassigned variables;
+Display inline hints;
+Show diagnostics for closed files;
+Colorize regular expression; 
+Highlight related components under cursor; 
+Report invalid regular expressions;
+Enable full solution analysis;
+Perform editor feature analysis in external process;
+Enable navigation to decompiled sources;
+Using directives;
+Place system directives first when sorting usings;
+Separate using directive groups;
+Suggest usings for types in reference assemblies;
+Suggest usings for types in NuGet packages;
+Highlighting;
+Highlight references to symbol under cursor;
+Highlight related keywords under cursor;
+Outlining;
+Enter outlining mode when files open;
+Show procedure line separators;
+Show outlining for declaration level constructs;
+Show outlining for code level constructs;
+Show outlining for comments and preprocessor regions;
+Collapse regions when collapsing to definitions;
+Fading;
+Fade out unused usings;
+Fade out unreachable code;
+Block Structure Guides;
+Show guides for declaration level constructs;
+Show guides for code level constructs;
+Editor Help;
+Generate XML documentation comments for ///;
+Insert * at the start of new lines when writing /* */ comments;
+Show preview for rename tracking;
+Split string literals on Enter;
+Report invalid placeholders in string.Format calls;
+Extract Method;
+Don't put ref or out on custom struct;
+Implement Interface or Abstract Class;
+When inserting properties, events and methods, place them;
+with other members of the same kind;
+at the end;
+When generating property;
+prefer throwing properties;
+prefer auto properties;
 regex;
-expression régulière;
-Utiliser des couleurs améliorées;
-Modèle de couleurs de l'éditeur;
-Marge d'héritage;</target>
+regular expression;
+Use enhanced colors;
+Editor Color Scheme;
+Inheritance Margin;
+Stack Trace Explorer;</target>
         <note>C# Advanced options page keywords</note>
       </trans-unit>
       <trans-unit id="307">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.it.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.it.xlf
index 28a178377a0dd..9153c5f6c2df6 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.it.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.it.xlf
@@ -84,56 +84,57 @@ Use enhanced colors;
 Editor Color Scheme;
 Inheritance Margin;
 Stack Trace Explorer;</source>
-        <target state="needs-review-translation">Sottolinea variabili riassegnate;
-Visualizza suggerimenti inline;
-Mostra diagnostica per file chiusi;
-Colora espressione regolare;
-Evidenzia i componenti correlati sotto il cursore; 
-Segnala espressioni regolari non valide;
-Abilita analisi della soluzione completa;
-Esegui analisi delle funzionalità dell'editor in processo esterno;
-Abilita spostamento a origini decompilate;
-Direttive using;
-Inserisci prima le direttive System durante l'ordinamento delle direttive using;
-Separa gruppi di direttive using;
-Suggerisci le direttive using per i tipi in assembly di riferimento;
-Suggerisci le direttive using per i tipi in pacchetti NuGet;
-Evidenziazione;
-Evidenzia riferimenti a simbolo sotto il cursore;
-Evidenzia parole chiave correlate sotto il cursore;
-Struttura;
-Attiva modalità struttura all'apertura del file;
-Mostra separatori di riga routine;
-Mostra la struttura per i costrutti a livello di dichiarazione;
-Mostra la struttura per i costrutti a livello di codice;
-Mostra la struttura per i commenti e le aree del preprocessore;
-Comprimi regioni durante la compressione delle definizioni;
-Dissolvenza;
-Applica dissolvenza a direttive using non usate;
-Applica dissolvenza a codice non eseguibile;
-Guide per strutture a blocchi;
-Mostra le guide per i costrutti a livello di dichiarazione;
-Mostra le guide per i costrutti a livello di codice;
-Guida dell'editor;
-Genera commenti relativi alla documentazione XML per ///;
-Inserisci * all'inizio di nuove righe quando si scrivono commenti /* */;
-Mostra anteprima per verifica ridenominazione;
-Dividi valori letterali stringa dopo INVIO;
-Segnala segnaposto non validi in chiamate string.Format;
-Estrai metodo;
-Non inserire out o ref in struct personalizzata;
-Implementa interfaccia o classe astratta;
-Posiziona proprietà, eventi e metodi inseriti;
-con altri membri dello stesso tipo;
-alla fine;
-Durante la generazione della proprietà;
-preferisci proprietà generate;
-preferisci proprietà automatiche;
+        <target state="new">Underline reassigned variables;
+Display inline hints;
+Show diagnostics for closed files;
+Colorize regular expression; 
+Highlight related components under cursor; 
+Report invalid regular expressions;
+Enable full solution analysis;
+Perform editor feature analysis in external process;
+Enable navigation to decompiled sources;
+Using directives;
+Place system directives first when sorting usings;
+Separate using directive groups;
+Suggest usings for types in reference assemblies;
+Suggest usings for types in NuGet packages;
+Highlighting;
+Highlight references to symbol under cursor;
+Highlight related keywords under cursor;
+Outlining;
+Enter outlining mode when files open;
+Show procedure line separators;
+Show outlining for declaration level constructs;
+Show outlining for code level constructs;
+Show outlining for comments and preprocessor regions;
+Collapse regions when collapsing to definitions;
+Fading;
+Fade out unused usings;
+Fade out unreachable code;
+Block Structure Guides;
+Show guides for declaration level constructs;
+Show guides for code level constructs;
+Editor Help;
+Generate XML documentation comments for ///;
+Insert * at the start of new lines when writing /* */ comments;
+Show preview for rename tracking;
+Split string literals on Enter;
+Report invalid placeholders in string.Format calls;
+Extract Method;
+Don't put ref or out on custom struct;
+Implement Interface or Abstract Class;
+When inserting properties, events and methods, place them;
+with other members of the same kind;
+at the end;
+When generating property;
+prefer throwing properties;
+prefer auto properties;
 regex;
-espressione regolare;
-Usa colori migliorati;
-Combinazione colori editor;
-Margine di ereditarietà;</target>
+regular expression;
+Use enhanced colors;
+Editor Color Scheme;
+Inheritance Margin;
+Stack Trace Explorer;</target>
         <note>C# Advanced options page keywords</note>
       </trans-unit>
       <trans-unit id="307">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ja.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ja.xlf
index aed128247de03..7a7cd70b7a457 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ja.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ja.xlf
@@ -84,56 +84,57 @@ Use enhanced colors;
 Editor Color Scheme;
 Inheritance Margin;
 Stack Trace Explorer;</source>
-        <target state="needs-review-translation">再割り当てされる変数に下線を引く;
-インラインのヒントを表示する;
-閉じているファイルの診断結果を表示する;
-正規表現をカラー化する;
-カーソルの下にある関連コンポーネントを強調表示する;
-無効な正規表現を報告する;
-完全ソリューション解析を有効にする;
-外部プロセスでエディター機能解析を実行する;
-逆コンパイルされたソースへのナビゲーションを有効にする;
-ディレクティブを使用する;
-using を並べ替える際に、system ディレクティブを先頭に配置する;
-using ディレクティブ グループを分離する;
-参照アセンブリの型に using を提案する;
-NuGet パッケージの型に using を提案する;
-強調表示;
-カーソルの下にあるシンボルへの参照を強調表示する;
-カーソルの下にある関連キーワードを強調表示する;
-アウトライン;
-ファイルを開くときにアウトライン モードに入る;
-プロシージャ行の区切り記号を表示する;
-宣言レベルのコンストラクトのアウトラインを表示する;
-コード レベルのコンストラクトのアウトラインを表示する;
-コメントとプリプロセッサ領域のアウトラインを表示する;
-定義を折りたたむときに regions を折りたたむ;
-フェード;
-未使用の using をフェードアウトする;
-到達できないコードをフェードアウトする;
-ブロック構造のガイド;
-宣言レベルのコンストラクトのガイドを表示する;
-コード レベルのコンストラクトのガイドを表示する;
-エディターのヘルプ;
-/// が入力されたとき、XML ドキュメント コメントを生成する;
-/* */ コメントを記述する際、新しい行の先頭に * を挿入する;
-名前変更追跡のプレビューを表示する;
-Enter で文字列リテラルを分割する;
-string.Format の呼び出しで無効なプレースホルダーをレポートする;
-メソッドを抽出する;
-カスタム構造体に ref または out を設定しない;
-インターフェイスまたは抽象クラスを実装する;
-プロパティ、イベント、メソッドを挿入する際には、次の場所に挿入する;
-同じ種類の他のメンバーと共に;
-末尾;
-プロパティの生成時;
-スロー プロパティを優先する;
-自動プロパティを優先する;
-RegEx;
-正規表現;
-拡張された色を使用する;
-エディターの配色;
-継承余白;</target>
+        <target state="new">Underline reassigned variables;
+Display inline hints;
+Show diagnostics for closed files;
+Colorize regular expression; 
+Highlight related components under cursor; 
+Report invalid regular expressions;
+Enable full solution analysis;
+Perform editor feature analysis in external process;
+Enable navigation to decompiled sources;
+Using directives;
+Place system directives first when sorting usings;
+Separate using directive groups;
+Suggest usings for types in reference assemblies;
+Suggest usings for types in NuGet packages;
+Highlighting;
+Highlight references to symbol under cursor;
+Highlight related keywords under cursor;
+Outlining;
+Enter outlining mode when files open;
+Show procedure line separators;
+Show outlining for declaration level constructs;
+Show outlining for code level constructs;
+Show outlining for comments and preprocessor regions;
+Collapse regions when collapsing to definitions;
+Fading;
+Fade out unused usings;
+Fade out unreachable code;
+Block Structure Guides;
+Show guides for declaration level constructs;
+Show guides for code level constructs;
+Editor Help;
+Generate XML documentation comments for ///;
+Insert * at the start of new lines when writing /* */ comments;
+Show preview for rename tracking;
+Split string literals on Enter;
+Report invalid placeholders in string.Format calls;
+Extract Method;
+Don't put ref or out on custom struct;
+Implement Interface or Abstract Class;
+When inserting properties, events and methods, place them;
+with other members of the same kind;
+at the end;
+When generating property;
+prefer throwing properties;
+prefer auto properties;
+regex;
+regular expression;
+Use enhanced colors;
+Editor Color Scheme;
+Inheritance Margin;
+Stack Trace Explorer;</target>
         <note>C# Advanced options page keywords</note>
       </trans-unit>
       <trans-unit id="307">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ko.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ko.xlf
index 2ea02da1708ac..e8bc8c2816960 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ko.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ko.xlf
@@ -84,56 +84,57 @@ Use enhanced colors;
 Editor Color Scheme;
 Inheritance Margin;
 Stack Trace Explorer;</source>
-        <target state="needs-review-translation">다시 할당된 변수에 밑줄 긋기;
-인라인 힌트 표시;
-닫힌 파일에 대한 진단 표시;
-정규식 색 지정; 
-커서 아래의 관련 구성 요소 강조 표시; 
-잘못된 정규식 보고;
-전체 솔루션 분석 사용;
-외부 프로세스에서 편집기 기능 분석 수행;
-디컴파일된 소스 탐색 사용;
-Using 지시문;
-using 정렬 시 system 지시문 먼저 배치;
-using 지시문 그룹 구분;
-참조 어셈블리의 형식에 using 제안;
-NuGet 패키지의 형식에 using 제안;
-강조 표시;
-커서 아래의 기호에 대한 참조 강조 표시;
-커서 아래의 관련 키워드 강조 표시;
-개요;
-개요 모드로 파일 열기;
-프로시저 줄 구분선 표시;
-선언 수준 구문에 대한 개요 표시;
-코드 수준 구문에 대한 개요 표시;
-설명 및 전처리기 영역에 대한 개요 표시;
-정의로 축소할 때 영역 축소;
-페이딩;
-사용하지 않는 using 페이드 아웃;
-접근할 수 없는 코드 페이드 아웃;
-블록 구조 가이드;
-선언 수준 구조에 대한 가이드 표시;
-코드 수준 구조에 대한 가이드 표시;
-편집기 도움말;
-///에 대해 XML 문서 주석 생성;
-/* */ 주석을 작성할 때 새 줄의 시작 부분에 * 삽입;
-이름 바꾸기 추적 미리 보기 표시;
-&lt;Enter&gt; 키를 누르면 문자열 리터럴 분할;
-string.Format 호출에서 잘못된 자리 표시자 보고;
-메서드 추출;
-사용자 지정 구조체에 ref 또는 out 추가 안 함;
-인터페이스 또는 추상 클래스 구현;
-속성, 이벤트 및 메서드 삽입 시 다음과 같이 배치;
-같은 종류의 다른 멤버와 함께;
-끝에;
-속성 생성 시;
-throw되는 속성 선호;
-자동 속성 선호;
+        <target state="new">Underline reassigned variables;
+Display inline hints;
+Show diagnostics for closed files;
+Colorize regular expression; 
+Highlight related components under cursor; 
+Report invalid regular expressions;
+Enable full solution analysis;
+Perform editor feature analysis in external process;
+Enable navigation to decompiled sources;
+Using directives;
+Place system directives first when sorting usings;
+Separate using directive groups;
+Suggest usings for types in reference assemblies;
+Suggest usings for types in NuGet packages;
+Highlighting;
+Highlight references to symbol under cursor;
+Highlight related keywords under cursor;
+Outlining;
+Enter outlining mode when files open;
+Show procedure line separators;
+Show outlining for declaration level constructs;
+Show outlining for code level constructs;
+Show outlining for comments and preprocessor regions;
+Collapse regions when collapsing to definitions;
+Fading;
+Fade out unused usings;
+Fade out unreachable code;
+Block Structure Guides;
+Show guides for declaration level constructs;
+Show guides for code level constructs;
+Editor Help;
+Generate XML documentation comments for ///;
+Insert * at the start of new lines when writing /* */ comments;
+Show preview for rename tracking;
+Split string literals on Enter;
+Report invalid placeholders in string.Format calls;
+Extract Method;
+Don't put ref or out on custom struct;
+Implement Interface or Abstract Class;
+When inserting properties, events and methods, place them;
+with other members of the same kind;
+at the end;
+When generating property;
+prefer throwing properties;
+prefer auto properties;
 regex;
-정규식;
-향상된 색 사용;
-편집기 색 구성표;
-상속 여백;</target>
+regular expression;
+Use enhanced colors;
+Editor Color Scheme;
+Inheritance Margin;
+Stack Trace Explorer;</target>
         <note>C# Advanced options page keywords</note>
       </trans-unit>
       <trans-unit id="307">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pl.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pl.xlf
index 38021f4dfbac2..f1a9527addbad 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pl.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pl.xlf
@@ -84,56 +84,57 @@ Use enhanced colors;
 Editor Color Scheme;
 Inheritance Margin;
 Stack Trace Explorer;</source>
-        <target state="needs-review-translation">Podkreślaj ponownie przypisane zmienne;
-Wyświetlaj wskazówki w tekście;
-Pokaż dane diagnostyczne dla zamkniętych plików;
-Koloruj wyrażenia regularne; 
-Wyróżnij powiązane składniki pod kursorem; 
-Raportuj nieprawidłowe wyrażenia regularne;
-Włącz pełną analizę rozwiązania;
-Wykonaj analizę funkcji edytora w procesie zewnętrznym;
-Włącz nawigowanie do dekompilowanych źródeł;
-Dyrektywy using;
-Umieść najpierw dyrektywy system podczas sortowania deklaracji using;
-Oddziel grupy dyrektywy using;
-Sugeruj dyrektywy using dla typów w zestawach odwołania;
-Sugeruj dyrektywy using dla typów w pakietach NuGet;
-Wyróżnianie;
-Wyróżnij odwołania do symbolu wskazanego przez kursor;
-Wyróżnij pokrewne słowa kluczowe wskazane przez kursor;
-Konspekt;
-Przejdź do trybu konspektu przy otwieraniu plików;
-Pokaż separatory wierszy procedury;
-Pokaż konspekt dla konstrukcji na poziomie deklaracji;
-Pokaż konspekt dla konstrukcji na poziomie kodu;
-Pokaż konspekt dla regionów komentarzy i preprocesora;
-Zwiń regiony podczas zwijania do definicji;
-Zanikanie;
-Zanikanie nieużywanych dyrektyw using;
-Zanikanie nieosiągalnego kodu;
-Prowadnice struktury blokowej;
-Pokaż prowadnice dla konstrukcji na poziomie deklaracji;
-Pokaż prowadnice dla konstrukcji na poziomie kodu;
-Pomoc edytora;
-Generuj komentarze dokumentacji XML dla elementów ///;
-Wstaw znak * na początku nowych wierszy podczas pisania komentarzy typu /* */;
-Pokaż podgląd śledzenia zmian nazw;
-Dziel literały ciągów po naciśnięciu klawisza Enter;
-Zgłaszaj nieprawidłowe symbole zastępcze w ciągu.Formatuj komórki;
-Metoda wyodrębniania;
-Nie umieszczaj parametrów ref i out w strukturze niestandardowej;
-Implementuj interfejs lub klasę abstrakcyjną;
-W przypadku wstawiania właściwości, zdarzeń i metod umieszczaj je;
-razem z innymi składowymi tego samego rodzaju;
-na końcu;
-Podczas generowania właściwości;
-preferuj zgłaszanie właściwości;
-preferuj właściwości automatyczne;
-wyrażenie regularne;
-wyrażenie regularne;
-Użyj ulepszonych kolorów;
-Schemat kolorów edytora;
-Margines dziedziczenia</target>
+        <target state="new">Underline reassigned variables;
+Display inline hints;
+Show diagnostics for closed files;
+Colorize regular expression; 
+Highlight related components under cursor; 
+Report invalid regular expressions;
+Enable full solution analysis;
+Perform editor feature analysis in external process;
+Enable navigation to decompiled sources;
+Using directives;
+Place system directives first when sorting usings;
+Separate using directive groups;
+Suggest usings for types in reference assemblies;
+Suggest usings for types in NuGet packages;
+Highlighting;
+Highlight references to symbol under cursor;
+Highlight related keywords under cursor;
+Outlining;
+Enter outlining mode when files open;
+Show procedure line separators;
+Show outlining for declaration level constructs;
+Show outlining for code level constructs;
+Show outlining for comments and preprocessor regions;
+Collapse regions when collapsing to definitions;
+Fading;
+Fade out unused usings;
+Fade out unreachable code;
+Block Structure Guides;
+Show guides for declaration level constructs;
+Show guides for code level constructs;
+Editor Help;
+Generate XML documentation comments for ///;
+Insert * at the start of new lines when writing /* */ comments;
+Show preview for rename tracking;
+Split string literals on Enter;
+Report invalid placeholders in string.Format calls;
+Extract Method;
+Don't put ref or out on custom struct;
+Implement Interface or Abstract Class;
+When inserting properties, events and methods, place them;
+with other members of the same kind;
+at the end;
+When generating property;
+prefer throwing properties;
+prefer auto properties;
+regex;
+regular expression;
+Use enhanced colors;
+Editor Color Scheme;
+Inheritance Margin;
+Stack Trace Explorer;</target>
         <note>C# Advanced options page keywords</note>
       </trans-unit>
       <trans-unit id="307">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pt-BR.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pt-BR.xlf
index a8bda4bd55e01..40399cdcb1c59 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pt-BR.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.pt-BR.xlf
@@ -84,56 +84,57 @@ Use enhanced colors;
 Editor Color Scheme;
 Inheritance Margin;
 Stack Trace Explorer;</source>
-        <target state="needs-review-translation">Variáveis reatribuídas de sublinhado;
-Exibir as dicas embutidas;
-Mostrar os diagnósticos de arquivos fechados;
-Colorir a expressão regular; 
-Realçar os componentes relacionados sob o cursor;
-Relatar as expressões regulares inválidas;
-Habilitar a análise completa da solução;
-Executar a análise de recurso do editor em processo externo;
-Habilitar a navegação para fontes decompiladas;
-Diretivas using;
-Colocar as diretivas do sistema primeiro ao classificar usings;
-Separar grupos de diretivas using;
-Sugerir usings para tipos em assemblies de referência;
-Sugerir usings para tipos em pacotes NuGet;
-Realce;
-Realçar as referências ao símbolo sob o cursor
-;Realçar as palavras-chave relacionadas sob o cursor;
-Estrutura de tópicos;
-Entrar no modo de estrutura de tópicos quando os arquivos são abertos;
-Mostrar separadores de linha de procedimento;
-Mostrar a estrutura de tópicos para constructos no nível da declaração;
-Mostrar a estrutura de tópicos para constructos no nível do código;
-Mostrar a estrutura de tópicos para comentários e regiões de pré-processador;
-Recolher as regiões ao recolher as definições;
-Esmaecimento;
-Esmaecer as usings não usadas;
-Esmaecer o código inacessível;
-Bloquear as Guias de Estrutura;
-Mostrar as guias de constructos no nível da declaração;
-Mostrar as guias de constructos no nível do código;
-Ajuda do Editor;
-Gerar comentários da documentação XML para ///;
-Inserir * no início de novas linhas ao escrever comentários de /* */;
-Mostrar a visualização para acompanhamento de renomeação;
-Dividir os literais de cadeia de caracteres ao pressionar Enter;
-Relatar os espaços reservados inválidos nas chamadas a string.Format;
-Extrair o Método;
-Não colocar ref nem out no struct personalizado;
-Implementar a Classe de Interface ou Abstrata;
-Ao inserir propriedades, eventos e métodos, colocá-los;
-com outros membros do mesmo tipo;
-no fim;
-Ao gerar uma propriedade;
-preferir propriedades de lançamento;
-preferir propriedades automáticas;
+        <target state="new">Underline reassigned variables;
+Display inline hints;
+Show diagnostics for closed files;
+Colorize regular expression; 
+Highlight related components under cursor; 
+Report invalid regular expressions;
+Enable full solution analysis;
+Perform editor feature analysis in external process;
+Enable navigation to decompiled sources;
+Using directives;
+Place system directives first when sorting usings;
+Separate using directive groups;
+Suggest usings for types in reference assemblies;
+Suggest usings for types in NuGet packages;
+Highlighting;
+Highlight references to symbol under cursor;
+Highlight related keywords under cursor;
+Outlining;
+Enter outlining mode when files open;
+Show procedure line separators;
+Show outlining for declaration level constructs;
+Show outlining for code level constructs;
+Show outlining for comments and preprocessor regions;
+Collapse regions when collapsing to definitions;
+Fading;
+Fade out unused usings;
+Fade out unreachable code;
+Block Structure Guides;
+Show guides for declaration level constructs;
+Show guides for code level constructs;
+Editor Help;
+Generate XML documentation comments for ///;
+Insert * at the start of new lines when writing /* */ comments;
+Show preview for rename tracking;
+Split string literals on Enter;
+Report invalid placeholders in string.Format calls;
+Extract Method;
+Don't put ref or out on custom struct;
+Implement Interface or Abstract Class;
+When inserting properties, events and methods, place them;
+with other members of the same kind;
+at the end;
+When generating property;
+prefer throwing properties;
+prefer auto properties;
 regex;
-expressão regular;
-Usar cores avançadas;
-Esquema de Cores do Editor;
-Margem de herança;</target>
+regular expression;
+Use enhanced colors;
+Editor Color Scheme;
+Inheritance Margin;
+Stack Trace Explorer;</target>
         <note>C# Advanced options page keywords</note>
       </trans-unit>
       <trans-unit id="307">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ru.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ru.xlf
index ea30c9ca9f704..b60ddd9b1bc6f 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ru.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.ru.xlf
@@ -84,56 +84,57 @@ Use enhanced colors;
 Editor Color Scheme;
 Inheritance Margin;
 Stack Trace Explorer;</source>
-        <target state="needs-review-translation">Подчеркивать переназначенные переменные;
-Показывать встроенные подсказки;
-Показывать диагностику для закрытых файлов;
-Выделять регулярные выражения;
-Выделять родственные компоненты под курсором;
-Сообщать о недопустимых регулярных выражениях;
-Включить полный анализ решения;
-Выполнять анализ функций редактора во внешнем процессе;
-Включить переход к декомпилированным источникам;
-Директивы using;
-Располагать директивы system первыми при сортировке директив using;
-Разделять группы директив using;
-Предлагать директивы using для типов в базовых сборках;
-Предлагать директивы using для типов в пакетах NuGet;
-Выделение;
-Выделять ссылки на символ под курсором;
-Выделять родственные ключевые слова под курсором;
-Структурирование;
-Включать режим редактирования структуры при открытии файлов;
-Показывать разделители строк процедур;
-Показывать структуру для конструкций уровня объявления;
-Показывать структуру для конструкций уровня кода;
-Показывать структуру для комментариев и областей препроцессора;
-Сворачивать области при сворачивании в определения;
-Показывать бледным цветом;
-Показывать неиспользуемые директивы using бледным цветом;
-Показывать недостижимый код бледным цветом;
-Направляющие для структуры блоков;
-Показывать направляющие для конструкций уровня объявления;
-Показывать направляющие для конструкций уровня кода;
-Справка по редактору;
-Генерировать комментарии XML-документации для ///;
-Вставлять "*" в начале новой строки при написании комментариев типа "/* */";
-Показывать предварительный просмотр для отслеживания переименований;
-Разделять строковые литералы при нажатии клавиши ВВОД;
-Сообщать о недопустимых заполнителях в вызовах string.Format;
-Извлечение метода;
-Не помещать ref и out в пользовательские структуры;
-Реализовать интерфейс или абстрактный класс;
-При вставке свойств, методов и событий помещать их 
-вместе с другими элементами того же типа 
-в конец;
-При создании свойства 
-предпочитать свойства, создающие исключения;
-предпочитать автоматические свойства;
-регулярное выражение;
-регулярное выражение;
-Использовать расширенный набор цветов;
-Цветовая схема редактора;
-Поле наследования;</target>
+        <target state="new">Underline reassigned variables;
+Display inline hints;
+Show diagnostics for closed files;
+Colorize regular expression; 
+Highlight related components under cursor; 
+Report invalid regular expressions;
+Enable full solution analysis;
+Perform editor feature analysis in external process;
+Enable navigation to decompiled sources;
+Using directives;
+Place system directives first when sorting usings;
+Separate using directive groups;
+Suggest usings for types in reference assemblies;
+Suggest usings for types in NuGet packages;
+Highlighting;
+Highlight references to symbol under cursor;
+Highlight related keywords under cursor;
+Outlining;
+Enter outlining mode when files open;
+Show procedure line separators;
+Show outlining for declaration level constructs;
+Show outlining for code level constructs;
+Show outlining for comments and preprocessor regions;
+Collapse regions when collapsing to definitions;
+Fading;
+Fade out unused usings;
+Fade out unreachable code;
+Block Structure Guides;
+Show guides for declaration level constructs;
+Show guides for code level constructs;
+Editor Help;
+Generate XML documentation comments for ///;
+Insert * at the start of new lines when writing /* */ comments;
+Show preview for rename tracking;
+Split string literals on Enter;
+Report invalid placeholders in string.Format calls;
+Extract Method;
+Don't put ref or out on custom struct;
+Implement Interface or Abstract Class;
+When inserting properties, events and methods, place them;
+with other members of the same kind;
+at the end;
+When generating property;
+prefer throwing properties;
+prefer auto properties;
+regex;
+regular expression;
+Use enhanced colors;
+Editor Color Scheme;
+Inheritance Margin;
+Stack Trace Explorer;</target>
         <note>C# Advanced options page keywords</note>
       </trans-unit>
       <trans-unit id="307">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.tr.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.tr.xlf
index 4dd59d80d97bb..a71a513086523 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.tr.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.tr.xlf
@@ -84,56 +84,57 @@ Use enhanced colors;
 Editor Color Scheme;
 Inheritance Margin;
 Stack Trace Explorer;</source>
-        <target state="needs-review-translation">Yeniden atanan değişkenleri altını çiz;
-Satır içi ipuçlarını göster;
-Kapatılan dosyalara ilişkin tanılamaları göster;
-Normal ifadeyi renklendir; 
-İmlecin altındaki ilgili bileşenleri vurgula; 
-Geçersiz normal ifadeleri bildir;
-Tam çözüm analizini etkinleştir;
-Dış işlemde düzenleyici özellik analizi gerçekleştir;
-Kaynak koda dönüştürülen kaynaklar için gezintiyi etkinleştir;
-Using yönergeleri;
-Using yönergelerini sıralarken sistem yönergelerini en başa yerleştir;
-Using yönerge gruplarını ayır;
-Başvuru bütünleştirilmiş kodlarında türler için using yönergeleri öner;
-NuGet paketlerinde türler için using yönergeleri öner;
-Vurgulama;
-İmlecin altındaki sembole yönelik başvuruları vurgula;
-İmlecin altındaki ilgili anahtar sözcükleri vurgula;
-Ana Hat Oluşturma;
-Dosyalar açılırken ana hat oluşturma moduna gir;
-Yordam satır ayırıcılarını göster;
-Bildirim düzeyinde yapılar için ana hattı göster;
-Kod düzeyinde yapılar için ana hattı göster;
-Açıklamalar ve ön işlemci bölgeleri için ana hattı göster;
-Tanımlara daraltırken bölgeleri daralt;
-Soluklaştırma;
-Kullanılmayan using deyimlerini soluklaştır;
-Erişilemeyen kodu soluklaştır;
-Blok Yapısı Kılavuzları;
-Bildirim düzeyinde yapılar için kılavuzları göster;
-Kod düzeyinde yapılar için kılavuzları göster;
-Düzenleyici Yardımı;
-/// için XML belge açıklamaları oluştur;
-/* */ açıklamaları yazılırken her yeni satırın başına * ekle;
-Yeniden adlandırma izlemesi için önizleme göster;
-Enter tuşuna basıldığında dize sabit değerlerini böl;
-string.Format çağrılarındaki geçersiz yer tutucuları bildir;
-Ayıklama Metodu;
-Özel yapıya ref veya out koyma;
-Arabirim veya Soyut Sınıfı uygula;
-Özellik, olay ve metot eklerken bunları;
-aynı türdeki başka üyelerle birlikte;
-sona yerleştir;
-Özellik oluştururken;
-özel durum oluşturan özellikleri tercih et;
-otomatik özellikleri tercih et;
-normal ifade;
-normal ifade;
-Gelişmiş renkleri kullan;
-Düzenleyici Renk Düzeni;
-İçe Aktarma Kenar Boşluğu;</target>
+        <target state="new">Underline reassigned variables;
+Display inline hints;
+Show diagnostics for closed files;
+Colorize regular expression; 
+Highlight related components under cursor; 
+Report invalid regular expressions;
+Enable full solution analysis;
+Perform editor feature analysis in external process;
+Enable navigation to decompiled sources;
+Using directives;
+Place system directives first when sorting usings;
+Separate using directive groups;
+Suggest usings for types in reference assemblies;
+Suggest usings for types in NuGet packages;
+Highlighting;
+Highlight references to symbol under cursor;
+Highlight related keywords under cursor;
+Outlining;
+Enter outlining mode when files open;
+Show procedure line separators;
+Show outlining for declaration level constructs;
+Show outlining for code level constructs;
+Show outlining for comments and preprocessor regions;
+Collapse regions when collapsing to definitions;
+Fading;
+Fade out unused usings;
+Fade out unreachable code;
+Block Structure Guides;
+Show guides for declaration level constructs;
+Show guides for code level constructs;
+Editor Help;
+Generate XML documentation comments for ///;
+Insert * at the start of new lines when writing /* */ comments;
+Show preview for rename tracking;
+Split string literals on Enter;
+Report invalid placeholders in string.Format calls;
+Extract Method;
+Don't put ref or out on custom struct;
+Implement Interface or Abstract Class;
+When inserting properties, events and methods, place them;
+with other members of the same kind;
+at the end;
+When generating property;
+prefer throwing properties;
+prefer auto properties;
+regex;
+regular expression;
+Use enhanced colors;
+Editor Color Scheme;
+Inheritance Margin;
+Stack Trace Explorer;</target>
         <note>C# Advanced options page keywords</note>
       </trans-unit>
       <trans-unit id="307">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hans.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hans.xlf
index fbb81954efc1d..eae7dfb6b3f7d 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hans.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hans.xlf
@@ -84,56 +84,57 @@ Use enhanced colors;
 Editor Color Scheme;
 Inheritance Margin;
 Stack Trace Explorer;</source>
-        <target state="needs-review-translation">为重新分配变量添加下划线;
-显示内联提示;
-显示对已关闭文件的诊断;
-对正则表达式着色;
-突出显示游标下的相关组件;
-报告无效的正则表达式;
-启用完整解决方案分析;
-在外部进程中执行编辑器功能分析;
-对反编译的源启用导航;
-Using 指令;
-对 using 进行排序时将系统指令放在开头;
-将 using 指令组分隔开来;
-建议对引用程序集中的类型使用 using;
-建议对 NuGet 包中的类型使用 using;
-突出显示;
-突出显示对游标下的符号的引用;
-突出显示游标下的相关关键字;
-大纲;
-在文件打开时输入大纲模式;
-显示流程行分隔符;
-显示声明级别构造的大纲;
-显示代码级别构造的大纲;
-显示注释和预处理器区域的大纲;
-在折叠到定义时折叠区域;
-淡出;
-未使用的 using 淡出;
-不可访问的代码淡出;
-块结构指南;
-显示声明级别构造的指南;
-显示代码级别构造的指南;
-编辑器帮助;
-为 /// 生成 XML 文档注释;
-在写入 /* */ 注释时在新行开头插入 *;
-显示重命名跟踪的预览;
-在按 Enter 时拆分字符串文本;
-报告 string.Format 调用中的无效占位符;
-提取方法;
-不要在自定义结构上放置 ref 或 out;
-实现接口或抽象类;
-插入属性、事件和方法时，放置它们;
-具有相同类型的其他成员;
-位于末尾;
-在生成属性时;
-首选引发属性;
-首选自动属性;
+        <target state="new">Underline reassigned variables;
+Display inline hints;
+Show diagnostics for closed files;
+Colorize regular expression; 
+Highlight related components under cursor; 
+Report invalid regular expressions;
+Enable full solution analysis;
+Perform editor feature analysis in external process;
+Enable navigation to decompiled sources;
+Using directives;
+Place system directives first when sorting usings;
+Separate using directive groups;
+Suggest usings for types in reference assemblies;
+Suggest usings for types in NuGet packages;
+Highlighting;
+Highlight references to symbol under cursor;
+Highlight related keywords under cursor;
+Outlining;
+Enter outlining mode when files open;
+Show procedure line separators;
+Show outlining for declaration level constructs;
+Show outlining for code level constructs;
+Show outlining for comments and preprocessor regions;
+Collapse regions when collapsing to definitions;
+Fading;
+Fade out unused usings;
+Fade out unreachable code;
+Block Structure Guides;
+Show guides for declaration level constructs;
+Show guides for code level constructs;
+Editor Help;
+Generate XML documentation comments for ///;
+Insert * at the start of new lines when writing /* */ comments;
+Show preview for rename tracking;
+Split string literals on Enter;
+Report invalid placeholders in string.Format calls;
+Extract Method;
+Don't put ref or out on custom struct;
+Implement Interface or Abstract Class;
+When inserting properties, events and methods, place them;
+with other members of the same kind;
+at the end;
+When generating property;
+prefer throwing properties;
+prefer auto properties;
 regex;
-正则表达式;
-使用增强色;
-编辑器配色方案;
-继承边距;</target>
+regular expression;
+Use enhanced colors;
+Editor Color Scheme;
+Inheritance Margin;
+Stack Trace Explorer;</target>
         <note>C# Advanced options page keywords</note>
       </trans-unit>
       <trans-unit id="307">
diff --git a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hant.xlf b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hant.xlf
index e3d46fde4415c..5302673a1260a 100644
--- a/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hant.xlf
+++ b/src/VisualStudio/CSharp/Impl/xlf/VSPackage.zh-Hant.xlf
@@ -84,56 +84,57 @@ Use enhanced colors;
 Editor Color Scheme;
 Inheritance Margin;
 Stack Trace Explorer;</source>
-        <target state="needs-review-translation">為重新指派的變數加上底線;
-顯示內嵌提示;
-顯示已關閉檔案的診斷;
-為規則運算式添加色彩; 
-醒目提示游標下的相關元件; 
-回報無效的規則運算式;
-啟用完整解決方案分析;
-在外部處理序中執行編輯器功能分析;
-啟用瀏覽至反向組譯的來源;
-using 指示詞;
-排序使 using 先放置系統指示詞;
-分隔 using 指示詞群組;
-為參考組件中的類型建議 using;
-為 NuGet 套件中的類型建議 using;
-醒目提示;
-醒目提示游標下的符號參考;
-醒目提示游標下的相關關鍵字;
-大綱;
-在檔案開啟時進入大綱模式;
-顯示程序行分隔符號;
-顯示宣告層級建構的大綱;
-顯示程式碼層級建構的大綱;
-顯示註解與前置處理器區域的大綱;
-在摺疊到定義時摺疊區域;
-漸層;
-淡出未使用的 using;
-淡出無法執行到的程式碼;
-區塊結構輔助線;
-顯示宣告層級建構的輔助線;
-顯示程式碼層級建構的輔助線;
-編輯器說明;
-產生 /// 的 XML 文件註解;
-在撰寫 /* */ 註解時，於新行開頭插入 *;
-顯示重新命名追蹤的預覽;
-在按 Enter 鍵時分割字串常值;
-回報 string.Format 呼叫中無效的預留位置;
-擷取方法;
-不要在自訂結構上放置 ref 或 out;
-實作介面或抽象類別;
-在插入屬性、事件和方法時，予以放置;
-隨同其他同種類的成員;
-結尾處;
-產生屬性時;
-建議使用擲回屬性;
-建議使用自動屬性;
+        <target state="new">Underline reassigned variables;
+Display inline hints;
+Show diagnostics for closed files;
+Colorize regular expression; 
+Highlight related components under cursor; 
+Report invalid regular expressions;
+Enable full solution analysis;
+Perform editor feature analysis in external process;
+Enable navigation to decompiled sources;
+Using directives;
+Place system directives first when sorting usings;
+Separate using directive groups;
+Suggest usings for types in reference assemblies;
+Suggest usings for types in NuGet packages;
+Highlighting;
+Highlight references to symbol under cursor;
+Highlight related keywords under cursor;
+Outlining;
+Enter outlining mode when files open;
+Show procedure line separators;
+Show outlining for declaration level constructs;
+Show outlining for code level constructs;
+Show outlining for comments and preprocessor regions;
+Collapse regions when collapsing to definitions;
+Fading;
+Fade out unused usings;
+Fade out unreachable code;
+Block Structure Guides;
+Show guides for declaration level constructs;
+Show guides for code level constructs;
+Editor Help;
+Generate XML documentation comments for ///;
+Insert * at the start of new lines when writing /* */ comments;
+Show preview for rename tracking;
+Split string literals on Enter;
+Report invalid placeholders in string.Format calls;
+Extract Method;
+Don't put ref or out on custom struct;
+Implement Interface or Abstract Class;
+When inserting properties, events and methods, place them;
+with other members of the same kind;
+at the end;
+When generating property;
+prefer throwing properties;
+prefer auto properties;
 regex;
-規則運算式;
-使用進階色彩;
-編輯器色彩配置;
-繼承頁面邊界</target>
+regular expression;
+Use enhanced colors;
+Editor Color Scheme;
+Inheritance Margin;
+Stack Trace Explorer;</target>
         <note>C# Advanced options page keywords</note>
       </trans-unit>
       <trans-unit id="307">
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ja.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ja.xlf
index 062a84fe657cb..ec10fb65756d8 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ja.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ja.xlf
@@ -529,7 +529,7 @@
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|ButtonText">
         <source>Track Value Source</source>
-        <target state="translated">トラック値のソース</target>
+        <target state="translated">値のソースの追跡</target>
         <note />
       </trans-unit>
       <trans-unit id="cmdidshowValueTracking|CommandName">

From 63113e037c4935bc7be852769a96669a557dc401 Mon Sep 17 00:00:00 2001
From: dotnet bot <dotnet-bot@dotnetfoundation.org>
Date: Mon, 17 Jan 2022 17:44:19 -0800
Subject: [PATCH 414/444] Localized file check-in by OneLocBuild Task: Build
 definition ID 327: Build ID 1557542


From 69ec20c5aafc956fb8c9da23b7ab56c85a21cb9b Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 17 Jan 2022 17:55:56 -0800
Subject: [PATCH 415/444] Move to analyzer project

---
 .../CSharp/Analyzers/CSharpAnalyzers.projitems         |  1 +
 .../CSharp/Analyzers/CSharpAnalyzersResources.resx     |  6 ++++++
 ...oveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs |  6 +++---
 .../Analyzers/xlf/CSharpAnalyzersResources.cs.xlf      | 10 ++++++++++
 .../Analyzers/xlf/CSharpAnalyzersResources.de.xlf      | 10 ++++++++++
 .../Analyzers/xlf/CSharpAnalyzersResources.es.xlf      | 10 ++++++++++
 .../Analyzers/xlf/CSharpAnalyzersResources.fr.xlf      | 10 ++++++++++
 .../Analyzers/xlf/CSharpAnalyzersResources.it.xlf      | 10 ++++++++++
 .../Analyzers/xlf/CSharpAnalyzersResources.ja.xlf      | 10 ++++++++++
 .../Analyzers/xlf/CSharpAnalyzersResources.ko.xlf      | 10 ++++++++++
 .../Analyzers/xlf/CSharpAnalyzersResources.pl.xlf      | 10 ++++++++++
 .../Analyzers/xlf/CSharpAnalyzersResources.pt-BR.xlf   | 10 ++++++++++
 .../Analyzers/xlf/CSharpAnalyzersResources.ru.xlf      | 10 ++++++++++
 .../Analyzers/xlf/CSharpAnalyzersResources.tr.xlf      | 10 ++++++++++
 .../Analyzers/xlf/CSharpAnalyzersResources.zh-Hans.xlf | 10 ++++++++++
 .../Analyzers/xlf/CSharpAnalyzersResources.zh-Hant.xlf | 10 ++++++++++
 .../CSharp/CodeFixes/CSharpCodeFixes.projitems         |  1 +
 ...RemoveUnnecessaryLambdaExpressionCodeFixProvider.cs |  4 ++--
 .../CSharp/Portable/CSharpFeaturesResources.resx       |  6 ------
 .../CSharp/Portable/xlf/CSharpFeaturesResources.cs.xlf | 10 ----------
 .../CSharp/Portable/xlf/CSharpFeaturesResources.de.xlf | 10 ----------
 .../CSharp/Portable/xlf/CSharpFeaturesResources.es.xlf | 10 ----------
 .../CSharp/Portable/xlf/CSharpFeaturesResources.fr.xlf | 10 ----------
 .../CSharp/Portable/xlf/CSharpFeaturesResources.it.xlf | 10 ----------
 .../CSharp/Portable/xlf/CSharpFeaturesResources.ja.xlf | 10 ----------
 .../CSharp/Portable/xlf/CSharpFeaturesResources.ko.xlf | 10 ----------
 .../CSharp/Portable/xlf/CSharpFeaturesResources.pl.xlf | 10 ----------
 .../Portable/xlf/CSharpFeaturesResources.pt-BR.xlf     | 10 ----------
 .../CSharp/Portable/xlf/CSharpFeaturesResources.ru.xlf | 10 ----------
 .../CSharp/Portable/xlf/CSharpFeaturesResources.tr.xlf | 10 ----------
 .../Portable/xlf/CSharpFeaturesResources.zh-Hans.xlf   | 10 ----------
 .../Portable/xlf/CSharpFeaturesResources.zh-Hant.xlf   | 10 ----------
 .../Services/SemanticFacts/CSharpSemanticFacts.cs      |  3 +++
 .../Core/Services/SemanticFacts/ISemanticFacts.cs      |  2 ++
 .../Services/SemanticFacts/VisualBasicSemanticFacts.vb |  4 ++++
 .../LanguageServices/CSharpSemanticFactsService.cs     |  3 ---
 .../AbstractSemanticFactsService.cs                    |  4 ++++
 .../SemanticsFactsService/ISemanticFactsService.cs     |  2 --
 .../VisualBasicSemanticFactsService.vb                 |  4 ----
 39 files changed, 156 insertions(+), 150 deletions(-)
 rename src/{Features/CSharp/Portable => Analyzers/CSharp/Analyzers}/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs (96%)
 rename src/{Features/CSharp/Portable => Analyzers/CSharp/CodeFixes}/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs (92%)

diff --git a/src/Analyzers/CSharp/Analyzers/CSharpAnalyzers.projitems b/src/Analyzers/CSharp/Analyzers/CSharpAnalyzers.projitems
index 64c484b1d0853..a4ddf64e88ce9 100644
--- a/src/Analyzers/CSharp/Analyzers/CSharpAnalyzers.projitems
+++ b/src/Analyzers/CSharp/Analyzers/CSharpAnalyzers.projitems
@@ -30,6 +30,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)MatchFolderAndNamespace\CSharpMatchFolderAndNamespaceDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)RemoveRedundantEquality\CSharpRemoveRedundantEqualityDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)RemoveUnnecessaryDiscardDesignation\CSharpRemoveUnnecessaryDiscardDesignationDiagnosticAnalyzer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)RemoveUnnecessaryLambdaExpression\CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)RemoveUnnecessarySuppressions\CSharpRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)RemoveUnnecessarySuppressions\CSharpRemoveUnnecessaryAttributeSuppressionsDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)RemoveUnnecessaryParentheses\CSharpRemoveUnnecessaryPatternParenthesesDiagnosticAnalyzer.cs" />
diff --git a/src/Analyzers/CSharp/Analyzers/CSharpAnalyzersResources.resx b/src/Analyzers/CSharp/Analyzers/CSharpAnalyzersResources.resx
index 466c18e00e098..782235465b2c1 100644
--- a/src/Analyzers/CSharp/Analyzers/CSharpAnalyzersResources.resx
+++ b/src/Analyzers/CSharp/Analyzers/CSharpAnalyzersResources.resx
@@ -343,4 +343,10 @@
   <data name="Use_parameter_null_checking" xml:space="preserve">
     <value>Use parameter null checking</value>
   </data>
+  <data name="Lambda_expression_can_be_removed" xml:space="preserve">
+    <value>Lambda expression can be removed</value>
+  </data>
+  <data name="Remove_unnecessary_lambda_expression" xml:space="preserve">
+    <value>Remove unnecessary lambda expression</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
similarity index 96%
rename from src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
rename to src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
index 4b6542357a33c..3b19a52d34580 100644
--- a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
@@ -33,8 +33,8 @@ public CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer()
                    EnforceOnBuildValues.RemoveUnnecessaryLambdaExpression,
                    CSharpCodeStyleOptions.PreferMethodGroupConversion,
                    LanguageNames.CSharp,
-                   new LocalizableResourceString(nameof(CSharpFeaturesResources.Remove_unnecessary_lambda_expression), CSharpFeaturesResources.ResourceManager, typeof(CSharpFeaturesResources)),
-                   new LocalizableResourceString(nameof(CSharpFeaturesResources.Lambda_expression_can_be_removed), CSharpFeaturesResources.ResourceManager, typeof(CSharpFeaturesResources)),
+                   new LocalizableResourceString(nameof(CSharpAnalyzersResources.Remove_unnecessary_lambda_expression), CSharpAnalyzersResources.ResourceManager, typeof(CSharpAnalyzersResources)),
+                   new LocalizableResourceString(nameof(CSharpAnalyzersResources.Lambda_expression_can_be_removed), CSharpAnalyzersResources.ResourceManager, typeof(CSharpAnalyzersResources)),
                    isUnnecessary: true)
         {
         }
@@ -115,7 +115,7 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol?
 
             // Looks like a reasonable candidate to simplify.  Now switch to semantics to check for sure.
 
-            if (CSharpSemanticFactsService.Instance.IsInExpressionTree(semanticModel, anonymousFunction, expressionType, cancellationToken))
+            if (CSharpSemanticFacts.Instance.IsInExpressionTree(semanticModel, anonymousFunction, expressionType, cancellationToken))
                 return;
 
             // If we have `object obj = x => Goo(x);` we don't want to simplify.  The compiler warns if you write
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.cs.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.cs.xlf
index 60ed538229495..4d8bb9ec8187a 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.cs.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.cs.xlf
@@ -67,6 +67,11 @@
         <target state="translated">Vložená deklarace proměnné</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Misplaced_using_directive">
         <source>Misplaced using directive</source>
         <target state="translated">Nesprávné umístění direktivy using</target>
@@ -122,6 +127,11 @@
         <target state="translated">Odebrat operátory potlačení</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_unnecessary_suppression_operator">
         <source>Remove unnecessary suppression operator</source>
         <target state="translated">Odebrat nepotřebný operátor potlačení</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.de.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.de.xlf
index 13a8c62f2c15b..4cc936f9ba175 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.de.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.de.xlf
@@ -67,6 +67,11 @@
         <target state="translated">Inlinevariablendeklaration</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Misplaced_using_directive">
         <source>Misplaced using directive</source>
         <target state="translated">Die using-Anweisung wurde falsch platziert.</target>
@@ -122,6 +127,11 @@
         <target state="translated">Unterdrückungsoperatoren entfernen</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_unnecessary_suppression_operator">
         <source>Remove unnecessary suppression operator</source>
         <target state="translated">Unnötigen Unterdrückungsoperator entfernen</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.es.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.es.xlf
index 4555025e70ad8..382ef105eac47 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.es.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.es.xlf
@@ -67,6 +67,11 @@
         <target state="translated">Declaración de variables alineada</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Misplaced_using_directive">
         <source>Misplaced using directive</source>
         <target state="translated">Directiva using mal colocada</target>
@@ -122,6 +127,11 @@
         <target state="translated">Quitar operadores de supresión</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_unnecessary_suppression_operator">
         <source>Remove unnecessary suppression operator</source>
         <target state="translated">Quitar operador de supresión innecesario</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.fr.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.fr.xlf
index a8a5ac05e3c33..2d1104f4cd7ef 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.fr.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.fr.xlf
@@ -67,6 +67,11 @@
         <target state="translated">Déclaration de variable inline</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Misplaced_using_directive">
         <source>Misplaced using directive</source>
         <target state="translated">Directive using mal placée</target>
@@ -122,6 +127,11 @@
         <target state="translated">Supprimer les opérateurs de suppression</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_unnecessary_suppression_operator">
         <source>Remove unnecessary suppression operator</source>
         <target state="translated">Supprimer l'opérateur de suppression inutile</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.it.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.it.xlf
index 0b436eb14578b..9fbaa5533fc67 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.it.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.it.xlf
@@ -67,6 +67,11 @@
         <target state="translated">Dichiarazione di variabile inline</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Misplaced_using_directive">
         <source>Misplaced using directive</source>
         <target state="translated">Direttiva using in posizione errata</target>
@@ -122,6 +127,11 @@
         <target state="translated">Rimuovi gli operatori di eliminazione</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_unnecessary_suppression_operator">
         <source>Remove unnecessary suppression operator</source>
         <target state="translated">Rimuovi l'operatore di eliminazione non necessario</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ja.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ja.xlf
index 364e8205812a2..7172a70422f65 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ja.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ja.xlf
@@ -67,6 +67,11 @@
         <target state="translated">インライン変数宣言</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Misplaced_using_directive">
         <source>Misplaced using directive</source>
         <target state="translated">using ディレクティブが正しく配置されていません</target>
@@ -122,6 +127,11 @@
         <target state="translated">抑制演算子の削除</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_unnecessary_suppression_operator">
         <source>Remove unnecessary suppression operator</source>
         <target state="translated">不要な抑制演算子を削除します</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ko.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ko.xlf
index bfb8d961fe9ab..b19b442b7667e 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ko.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ko.xlf
@@ -67,6 +67,11 @@
         <target state="translated">인라인 변수 선언</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Misplaced_using_directive">
         <source>Misplaced using directive</source>
         <target state="translated">위치가 잘못된 using 지시문</target>
@@ -122,6 +127,11 @@
         <target state="translated">비표시 오류(Suppression) 연산자 제거</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_unnecessary_suppression_operator">
         <source>Remove unnecessary suppression operator</source>
         <target state="translated">불필요한 비표시 오류(Suppression) 연산자 제거</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pl.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pl.xlf
index ecac3f0c4cb4f..f8db95470a852 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pl.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pl.xlf
@@ -67,6 +67,11 @@
         <target state="translated">Deklaracja zmiennej wbudowanej</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Misplaced_using_directive">
         <source>Misplaced using directive</source>
         <target state="translated">Nieprawidłowo umieszczona dyrektywa using</target>
@@ -122,6 +127,11 @@
         <target state="translated">Usuń operatory pomijania</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_unnecessary_suppression_operator">
         <source>Remove unnecessary suppression operator</source>
         <target state="translated">Usuń niepotrzebny operator pomijania</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pt-BR.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pt-BR.xlf
index a06f12ba0e9b9..9995149d5537c 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pt-BR.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.pt-BR.xlf
@@ -67,6 +67,11 @@
         <target state="translated">Declaração de variável embutida</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Misplaced_using_directive">
         <source>Misplaced using directive</source>
         <target state="translated">Diretiva using em local incorreto</target>
@@ -122,6 +127,11 @@
         <target state="translated">Remover operadores de supressão</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_unnecessary_suppression_operator">
         <source>Remove unnecessary suppression operator</source>
         <target state="translated">Remover operador de supressão desnecessário</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ru.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ru.xlf
index fa246d6762cec..b3bac6215c6fd 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ru.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.ru.xlf
@@ -67,6 +67,11 @@
         <target state="translated">Объявление встроенной переменной</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Misplaced_using_directive">
         <source>Misplaced using directive</source>
         <target state="translated">Неправильно расположенная директива using</target>
@@ -122,6 +127,11 @@
         <target state="translated">Удалить операторы подавления</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_unnecessary_suppression_operator">
         <source>Remove unnecessary suppression operator</source>
         <target state="translated">Удалить ненужный оператор подавления</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.tr.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.tr.xlf
index bd40af1e443e9..edb1e34ddf413 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.tr.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.tr.xlf
@@ -67,6 +67,11 @@
         <target state="translated">Satır içi değişken bildirimi</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Misplaced_using_directive">
         <source>Misplaced using directive</source>
         <target state="translated">Yanlış yerleştirilmiş using yönergesi</target>
@@ -122,6 +127,11 @@
         <target state="translated">Gizleme işleçlerini kaldır</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_unnecessary_suppression_operator">
         <source>Remove unnecessary suppression operator</source>
         <target state="translated">Gereksiz gizleme işlecini kaldır</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hans.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hans.xlf
index e6d71376160ef..09adb06f36210 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hans.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hans.xlf
@@ -67,6 +67,11 @@
         <target state="translated">内联变量声明</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Misplaced_using_directive">
         <source>Misplaced using directive</source>
         <target state="translated">错放了 using 指令</target>
@@ -122,6 +127,11 @@
         <target state="translated">请删除忽略运算符</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_unnecessary_suppression_operator">
         <source>Remove unnecessary suppression operator</source>
         <target state="translated">请删除不必要的忽略运算符</target>
diff --git a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hant.xlf b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hant.xlf
index eb0e3857ae079..06eaa74caeefb 100644
--- a/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hant.xlf
+++ b/src/Analyzers/CSharp/Analyzers/xlf/CSharpAnalyzersResources.zh-Hant.xlf
@@ -67,6 +67,11 @@
         <target state="translated">內嵌變數宣告</target>
         <note />
       </trans-unit>
+      <trans-unit id="Lambda_expression_can_be_removed">
+        <source>Lambda expression can be removed</source>
+        <target state="new">Lambda expression can be removed</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Misplaced_using_directive">
         <source>Misplaced using directive</source>
         <target state="translated">using 指示詞位置錯誤</target>
@@ -122,6 +127,11 @@
         <target state="translated">移除隱藏的運算子</target>
         <note />
       </trans-unit>
+      <trans-unit id="Remove_unnecessary_lambda_expression">
+        <source>Remove unnecessary lambda expression</source>
+        <target state="new">Remove unnecessary lambda expression</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Remove_unnecessary_suppression_operator">
         <source>Remove unnecessary suppression operator</source>
         <target state="translated">移除隱藏運算子中不需要的運算子</target>
diff --git a/src/Analyzers/CSharp/CodeFixes/CSharpCodeFixes.projitems b/src/Analyzers/CSharp/CodeFixes/CSharpCodeFixes.projitems
index d411389a4b28d..720560e502c03 100644
--- a/src/Analyzers/CSharp/CodeFixes/CSharpCodeFixes.projitems
+++ b/src/Analyzers/CSharp/CodeFixes/CSharpCodeFixes.projitems
@@ -36,6 +36,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)RemoveUnnecessaryDiscardDesignation\CSharpRemoveUnnecessaryDiscardDesignationCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)RemoveUnnecessaryImports\CSharpRemoveUnnecessaryImportsCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)RemoveConfusingSuppression\CSharpRemoveConfusingSuppressionCodeFixProvider.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)RemoveUnnecessaryLambdaExpression\CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)RemoveUnreachableCode\CSharpRemoveUnreachableCodeCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)RemoveUnnecessaryParentheses\CSharpRemoveUnnecessaryParenthesesCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)RemoveUnusedMembers\CSharpRemoveUnusedMembersCodeFixProvider.cs" />
diff --git a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs
similarity index 92%
rename from src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs
rename to src/Analyzers/CSharp/CodeFixes/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs
index 81ca5e3ead6b2..d5f32eb3fb2bc 100644
--- a/src/Features/CSharp/Portable/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider.cs
@@ -68,10 +68,10 @@ protected override Task FixAllAsync(
             return Task.CompletedTask;
         }
 
-        private class MyCodeAction : CodeAction.DocumentChangeAction
+        private class MyCodeAction : CustomCodeActions.DocumentChangeAction
         {
             public MyCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument)
-                : base(CSharpFeaturesResources.Remove_unnecessary_lambda_expression, createChangedDocument, nameof(CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider))
+                : base(CSharpAnalyzersResources.Remove_unnecessary_lambda_expression, createChangedDocument, nameof(CSharpRemoveUnnecessaryLambdaExpressionCodeFixProvider))
             {
             }
         }
diff --git a/src/Features/CSharp/Portable/CSharpFeaturesResources.resx b/src/Features/CSharp/Portable/CSharpFeaturesResources.resx
index 731bd2fd515a0..345282c97cc4e 100644
--- a/src/Features/CSharp/Portable/CSharpFeaturesResources.resx
+++ b/src/Features/CSharp/Portable/CSharpFeaturesResources.resx
@@ -630,10 +630,4 @@
   <data name="Selection_cannot_include_top_level_statements" xml:space="preserve">
     <value>Selection cannot include top-level statements</value>
   </data>
-  <data name="Lambda_expression_can_be_removed" xml:space="preserve">
-    <value>Lambda expression can be removed</value>
-  </data>
-  <data name="Remove_unnecessary_lambda_expression" xml:space="preserve">
-    <value>Remove unnecessary lambda expression</value>
-  </data>
 </root>
\ No newline at end of file
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.cs.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.cs.xlf
index d73332715ead1..0973c83d3f393 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.cs.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.cs.xlf
@@ -142,11 +142,6 @@
         <target state="translated">Zjistily se konflikty.</target>
         <note />
       </trans-unit>
-      <trans-unit id="Lambda_expression_can_be_removed">
-        <source>Lambda expression can be removed</source>
-        <target state="new">Lambda expression can be removed</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">Nastavit privátní pole jako jenom pro čtení, kde je to možné</target>
@@ -167,11 +162,6 @@
         <target state="translated">Odebrat modifikátor new</target>
         <note />
       </trans-unit>
-      <trans-unit id="Remove_unnecessary_lambda_expression">
-        <source>Remove unnecessary lambda expression</source>
-        <target state="new">Remove unnecessary lambda expression</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">Obrátit příkaz for</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.de.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.de.xlf
index b1863827841a7..1f32da3391bfe 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.de.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.de.xlf
@@ -142,11 +142,6 @@
         <target state="translated">Konflikt(e) erkannt.</target>
         <note />
       </trans-unit>
-      <trans-unit id="Lambda_expression_can_be_removed">
-        <source>Lambda expression can be removed</source>
-        <target state="new">Lambda expression can be removed</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">Private Felder nach Möglichkeit als schreibgeschützt festlegen</target>
@@ -167,11 +162,6 @@
         <target state="translated">new-Modifizierer entfernen</target>
         <note />
       </trans-unit>
-      <trans-unit id="Remove_unnecessary_lambda_expression">
-        <source>Remove unnecessary lambda expression</source>
-        <target state="new">Remove unnecessary lambda expression</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">for-Anweisung umkehren</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.es.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.es.xlf
index ea7f621b83069..4511fe240f950 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.es.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.es.xlf
@@ -142,11 +142,6 @@
         <target state="translated">Conflicto(s) detectado(s).</target>
         <note />
       </trans-unit>
-      <trans-unit id="Lambda_expression_can_be_removed">
-        <source>Lambda expression can be removed</source>
-        <target state="new">Lambda expression can be removed</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">Cuando sea posible, hacer que los cambios privados sean solo de lectura</target>
@@ -167,11 +162,6 @@
         <target state="translated">Quitar el modificador "new"</target>
         <note />
       </trans-unit>
-      <trans-unit id="Remove_unnecessary_lambda_expression">
-        <source>Remove unnecessary lambda expression</source>
-        <target state="new">Remove unnecessary lambda expression</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">Invertir la instrucción "for"</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.fr.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.fr.xlf
index 7af5f5690cbab..83c192c454017 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.fr.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.fr.xlf
@@ -142,11 +142,6 @@
         <target state="translated">Conflit(s) détecté(s).</target>
         <note />
       </trans-unit>
-      <trans-unit id="Lambda_expression_can_be_removed">
-        <source>Lambda expression can be removed</source>
-        <target state="new">Lambda expression can be removed</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">Configurer les champs privés en lecture seule quand cela est possible</target>
@@ -167,11 +162,6 @@
         <target state="translated">Supprimer le modificateur 'new'</target>
         <note />
       </trans-unit>
-      <trans-unit id="Remove_unnecessary_lambda_expression">
-        <source>Remove unnecessary lambda expression</source>
-        <target state="new">Remove unnecessary lambda expression</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">Inverser l'instruction 'for'</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.it.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.it.xlf
index 5a455b2964bce..059515829ba39 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.it.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.it.xlf
@@ -142,11 +142,6 @@
         <target state="translated">Sono stati rilevati conflitti.</target>
         <note />
       </trans-unit>
-      <trans-unit id="Lambda_expression_can_be_removed">
-        <source>Lambda expression can be removed</source>
-        <target state="new">Lambda expression can be removed</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">Imposta i campi privati come di sola lettura quando possibile</target>
@@ -167,11 +162,6 @@
         <target state="translated">Rimuovi il modificatore 'new'</target>
         <note />
       </trans-unit>
-      <trans-unit id="Remove_unnecessary_lambda_expression">
-        <source>Remove unnecessary lambda expression</source>
-        <target state="new">Remove unnecessary lambda expression</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">Inverti l'istruzione 'for'</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ja.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ja.xlf
index 6483adbde4a26..a730dfa534ff3 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ja.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ja.xlf
@@ -142,11 +142,6 @@
         <target state="translated">競合が検出されました。</target>
         <note />
       </trans-unit>
-      <trans-unit id="Lambda_expression_can_be_removed">
-        <source>Lambda expression can be removed</source>
-        <target state="new">Lambda expression can be removed</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">可能な場合、private フィールドを読み取り専用にする</target>
@@ -167,11 +162,6 @@
         <target state="translated">'new' 修飾子の削除</target>
         <note />
       </trans-unit>
-      <trans-unit id="Remove_unnecessary_lambda_expression">
-        <source>Remove unnecessary lambda expression</source>
-        <target state="new">Remove unnecessary lambda expression</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">'for' ステートメントの反転</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ko.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ko.xlf
index 63edf54b98f10..4091a3a7311f6 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ko.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ko.xlf
@@ -142,11 +142,6 @@
         <target state="translated">충돌이 감지되었습니다.</target>
         <note />
       </trans-unit>
-      <trans-unit id="Lambda_expression_can_be_removed">
-        <source>Lambda expression can be removed</source>
-        <target state="new">Lambda expression can be removed</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">가능한 경우 프라이빗 필드를 읽기 전용으로 만들기</target>
@@ -167,11 +162,6 @@
         <target state="translated">'new' 한정자 제거</target>
         <note />
       </trans-unit>
-      <trans-unit id="Remove_unnecessary_lambda_expression">
-        <source>Remove unnecessary lambda expression</source>
-        <target state="new">Remove unnecessary lambda expression</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">역 'for' 문</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pl.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pl.xlf
index 235276ff464c8..958bc8e9e885c 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pl.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pl.xlf
@@ -142,11 +142,6 @@
         <target state="translated">Wykryto konflikty.</target>
         <note />
       </trans-unit>
-      <trans-unit id="Lambda_expression_can_be_removed">
-        <source>Lambda expression can be removed</source>
-        <target state="new">Lambda expression can be removed</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">Ustawiaj pola prywatne jako tylko do odczytu, gdy to możliwe</target>
@@ -167,11 +162,6 @@
         <target state="translated">Usuń modyfikator „new”</target>
         <note />
       </trans-unit>
-      <trans-unit id="Remove_unnecessary_lambda_expression">
-        <source>Remove unnecessary lambda expression</source>
-        <target state="new">Remove unnecessary lambda expression</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">Odwróć instrukcję „for”</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pt-BR.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pt-BR.xlf
index cc5d415939c20..7de4bca5edbea 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pt-BR.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pt-BR.xlf
@@ -142,11 +142,6 @@
         <target state="translated">Conflito(s) detectado(s).</target>
         <note />
       </trans-unit>
-      <trans-unit id="Lambda_expression_can_be_removed">
-        <source>Lambda expression can be removed</source>
-        <target state="new">Lambda expression can be removed</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">Tornar os campos privados somente leitura quando possível</target>
@@ -167,11 +162,6 @@
         <target state="translated">Remover modificador 'novo'</target>
         <note />
       </trans-unit>
-      <trans-unit id="Remove_unnecessary_lambda_expression">
-        <source>Remove unnecessary lambda expression</source>
-        <target state="new">Remove unnecessary lambda expression</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">Reverter instrução 'for'</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ru.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ru.xlf
index 7a7461b0e8db0..b00ad6f2adc8b 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ru.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ru.xlf
@@ -142,11 +142,6 @@
         <target state="translated">Обнаружены конфликты.</target>
         <note />
       </trans-unit>
-      <trans-unit id="Lambda_expression_can_be_removed">
-        <source>Lambda expression can be removed</source>
-        <target state="new">Lambda expression can be removed</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">При возможности делать частные поля доступными только для чтения</target>
@@ -167,11 +162,6 @@
         <target state="translated">Удалить модификатор "new"</target>
         <note />
       </trans-unit>
-      <trans-unit id="Remove_unnecessary_lambda_expression">
-        <source>Remove unnecessary lambda expression</source>
-        <target state="new">Remove unnecessary lambda expression</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">Обратить оператор "for"</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.tr.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.tr.xlf
index c4d125db341e5..ac56005f5a0e8 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.tr.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.tr.xlf
@@ -142,11 +142,6 @@
         <target state="translated">Çakışmalar algılandı.</target>
         <note />
       </trans-unit>
-      <trans-unit id="Lambda_expression_can_be_removed">
-        <source>Lambda expression can be removed</source>
-        <target state="new">Lambda expression can be removed</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">Özel alanları mümkün olduğunda salt okunur yap</target>
@@ -167,11 +162,6 @@
         <target state="translated">'New' değiştiricisini kaldır</target>
         <note />
       </trans-unit>
-      <trans-unit id="Remove_unnecessary_lambda_expression">
-        <source>Remove unnecessary lambda expression</source>
-        <target state="new">Remove unnecessary lambda expression</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">'for' ifadesini tersine çevir</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hans.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hans.xlf
index f7f93db37aed6..5c8d1d8e66197 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hans.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hans.xlf
@@ -142,11 +142,6 @@
         <target state="translated">检测到冲突。</target>
         <note />
       </trans-unit>
-      <trans-unit id="Lambda_expression_can_be_removed">
-        <source>Lambda expression can be removed</source>
-        <target state="new">Lambda expression can be removed</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">尽可能将私有字段设置为“只读”</target>
@@ -167,11 +162,6 @@
         <target state="translated">删除 "new" 修饰符</target>
         <note />
       </trans-unit>
-      <trans-unit id="Remove_unnecessary_lambda_expression">
-        <source>Remove unnecessary lambda expression</source>
-        <target state="new">Remove unnecessary lambda expression</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">反向“for”语句</target>
diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hant.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hant.xlf
index 12fd5c6374acc..c563694b3a485 100644
--- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hant.xlf
+++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hant.xlf
@@ -142,11 +142,6 @@
         <target state="translated">偵測到衝突。</target>
         <note />
       </trans-unit>
-      <trans-unit id="Lambda_expression_can_be_removed">
-        <source>Lambda expression can be removed</source>
-        <target state="new">Lambda expression can be removed</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Make_private_field_readonly_when_possible">
         <source>Make private fields readonly when possible</source>
         <target state="translated">若可能的話，請將私用欄位設定為唯讀</target>
@@ -167,11 +162,6 @@
         <target state="translated">移除 'new' 修飾詞</target>
         <note />
       </trans-unit>
-      <trans-unit id="Remove_unnecessary_lambda_expression">
-        <source>Remove unnecessary lambda expression</source>
-        <target state="new">Remove unnecessary lambda expression</target>
-        <note />
-      </trans-unit>
       <trans-unit id="Reverse_for_statement">
         <source>Reverse 'for' statement</source>
         <target state="translated">反向 'for' 陳述式</target>
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SemanticFacts/CSharpSemanticFacts.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SemanticFacts/CSharpSemanticFacts.cs
index 3391a170fdc94..9c0544538f439 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SemanticFacts/CSharpSemanticFacts.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SemanticFacts/CSharpSemanticFacts.cs
@@ -355,5 +355,8 @@ public ImmutableArray<IMethodSymbol> GetLocalFunctionSymbols(Compilation compila
 
             return builder.ToImmutable();
         }
+
+        public bool IsInExpressionTree(SemanticModel semanticModel, SyntaxNode node, INamedTypeSymbol expressionTypeOpt, CancellationToken cancellationToken)
+            => node.IsInExpressionTree(semanticModel, expressionTypeOpt, cancellationToken);
     }
 }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SemanticFacts/ISemanticFacts.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SemanticFacts/ISemanticFacts.cs
index 68e7015031163..b02ce80d860fa 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SemanticFacts/ISemanticFacts.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SemanticFacts/ISemanticFacts.cs
@@ -99,5 +99,7 @@ internal partial interface ISemanticFacts
         /// Finds all local function definitions within the syntax references for a given <paramref name="symbol"/>
         /// </summary>
         ImmutableArray<IMethodSymbol> GetLocalFunctionSymbols(Compilation compilation, ISymbol symbol, CancellationToken cancellationToken);
+
+        bool IsInExpressionTree(SemanticModel semanticModel, SyntaxNode node, INamedTypeSymbol expressionTypeOpt, CancellationToken cancellationToken);
     }
 }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SemanticFacts/VisualBasicSemanticFacts.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SemanticFacts/VisualBasicSemanticFacts.vb
index ddc82bff9c78e..792810f70c4ea 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SemanticFacts/VisualBasicSemanticFacts.vb
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SemanticFacts/VisualBasicSemanticFacts.vb
@@ -242,5 +242,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         Public Function GetLocalFunctionSymbols(compilation As Compilation, symbol As ISymbol, cancellationToken As CancellationToken) As ImmutableArray(Of IMethodSymbol) Implements ISemanticFacts.GetLocalFunctionSymbols
             Return ImmutableArray(Of IMethodSymbol).Empty
         End Function
+
+        Public Function IsInExpressionTree(semanticModel As SemanticModel, node As SyntaxNode, expressionTypeOpt As INamedTypeSymbol, cancellationToken As CancellationToken) As Boolean Implements ISemanticFacts.IsInExpressionTree
+            Return node.IsInExpressionTree(semanticModel, expressionTypeOpt, cancellationToken)
+        End Function
     End Class
 End Namespace
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSemanticFactsService.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSemanticFactsService.cs
index 0665a2f2b99eb..9e0299091bcf9 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSemanticFactsService.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSemanticFactsService.cs
@@ -75,9 +75,6 @@ public bool IsExpressionContext(SemanticModel semanticModel, int position, Cance
                 attributes: true, cancellationToken: cancellationToken, semanticModelOpt: semanticModel);
         }
 
-        public bool IsInExpressionTree(SemanticModel semanticModel, SyntaxNode node, INamedTypeSymbol expressionTypeOpt, CancellationToken cancellationToken)
-            => node.IsInExpressionTree(semanticModel, expressionTypeOpt, cancellationToken);
-
         public bool IsStatementContext(SemanticModel semanticModel, int position, CancellationToken cancellationToken)
         {
             return semanticModel.SyntaxTree.IsStatementContext(
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SemanticsFactsService/AbstractSemanticFactsService.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SemanticsFactsService/AbstractSemanticFactsService.cs
index d827973246a5b..3a4125bd00b3e 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SemanticsFactsService/AbstractSemanticFactsService.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SemanticsFactsService/AbstractSemanticFactsService.cs
@@ -162,6 +162,10 @@ public bool IsInsideNameOfExpression(SemanticModel semanticModel, SyntaxNode nod
 
         public ImmutableArray<IMethodSymbol> GetLocalFunctionSymbols(Compilation compilation, ISymbol symbol, CancellationToken cancellationToken)
             => SemanticFacts.GetLocalFunctionSymbols(compilation, symbol, cancellationToken);
+
+        public bool IsInExpressionTree(SemanticModel semanticModel, SyntaxNode node, INamedTypeSymbol expressionTypeOpt, CancellationToken cancellationToken)
+            => SemanticFacts.IsInExpressionTree(semanticModel, node, expressionTypeOpt, cancellationToken);
+
         #endregion
     }
 }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SemanticsFactsService/ISemanticFactsService.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SemanticsFactsService/ISemanticFactsService.cs
index 04ec70a31cda9..97260b5d15584 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SemanticsFactsService/ISemanticFactsService.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SemanticsFactsService/ISemanticFactsService.cs
@@ -25,8 +25,6 @@ internal partial interface ISemanticFactsService : ISemanticFacts, ILanguageServ
         bool IsLabelContext(SemanticModel semanticModel, int position, CancellationToken cancellationToken);
         bool IsAttributeNameContext(SemanticModel semanticModel, int position, CancellationToken cancellationToken);
 
-        bool IsInExpressionTree(SemanticModel semanticModel, SyntaxNode node, INamedTypeSymbol expressionTypeOpt, CancellationToken cancellationToken);
-
         SyntaxToken GenerateUniqueName(
             SemanticModel semanticModel, SyntaxNode location,
             SyntaxNode containerOpt, string baseName, CancellationToken cancellationToken);
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/LanguageServices/VisualBasicSemanticFactsService.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/LanguageServices/VisualBasicSemanticFactsService.vb
index 467065ec27d6b..5bee2fee605dc 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/LanguageServices/VisualBasicSemanticFactsService.vb
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/LanguageServices/VisualBasicSemanticFactsService.vb
@@ -50,10 +50,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Return semanticModel.SyntaxTree.IsExpressionContext(position, token, cancellationToken, semanticModel)
         End Function
 
-        Public Function IsInExpressionTree(semanticModel As SemanticModel, node As SyntaxNode, expressionTypeOpt As INamedTypeSymbol, cancellationToken As CancellationToken) As Boolean Implements ISemanticFactsService.IsInExpressionTree
-            Return node.IsInExpressionTree(semanticModel, expressionTypeOpt, cancellationToken)
-        End Function
-
         Public Function IsMemberDeclarationContext(semanticModel As SemanticModel, position As Integer, cancellationToken As CancellationToken) As Boolean Implements ISemanticFactsService.IsMemberDeclarationContext
             Dim token = semanticModel.SyntaxTree.GetTargetToken(position, cancellationToken)
             Return semanticModel.SyntaxTree.IsInterfaceMemberDeclarationKeywordContext(position, token, cancellationToken) OrElse

From e41ad5b63859f33d4d675cc50e882b6d92faf918 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 17 Jan 2022 19:09:02 -0800
Subject: [PATCH 416/444] Show a specialized display for anonymous delegates in
 C#

---
 .../CSharpStructuralTypeDisplayService.cs     | 32 ++++++++++++-
 ...DisplayService.SymbolDescriptionBuilder.cs | 10 ++--
 ...yService.StructuralTypeCollectorVisitor.cs |  1 +
 .../AbstractStructuralTypeDisplayService.cs   | 21 ++++++---
 ...IStructuralTypeDisplayServiceExtensions.cs | 34 +++++++-------
 ...ractSymbolDisplayService.AnonymousTypes.cs |  6 +--
 .../AbstractSignatureHelpProvider.cs          | 46 +++++++++----------
 ...VisualBasicStructuralTypeDisplayService.vb | 12 +----
 ...DisplayService.SymbolDescriptionBuilder.vb | 24 +++++-----
 9 files changed, 108 insertions(+), 78 deletions(-)

diff --git a/src/Features/CSharp/Portable/LanguageServices/CSharpStructuralTypeDisplayService.cs b/src/Features/CSharp/Portable/LanguageServices/CSharpStructuralTypeDisplayService.cs
index 0a414ce2768af..d3c12b1e4be46 100644
--- a/src/Features/CSharp/Portable/LanguageServices/CSharpStructuralTypeDisplayService.cs
+++ b/src/Features/CSharp/Portable/LanguageServices/CSharpStructuralTypeDisplayService.cs
@@ -14,20 +14,26 @@
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.LanguageServices
 {
     [ExportLanguageService(typeof(IStructuralTypeDisplayService), LanguageNames.CSharp), Shared]
     internal class CSharpStructuralTypeDisplayService : AbstractStructuralTypeDisplayService
     {
+        private static readonly SymbolDisplayFormat s_minimalWithoutContainingType =
+            s_minimalWithoutExpandedTuples.WithMemberOptions(s_minimalWithoutExpandedTuples.MemberOptions & ~SymbolDisplayMemberOptions.IncludeContainingType);
+
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
         public CSharpStructuralTypeDisplayService()
         {
         }
 
-        public override ImmutableArray<SymbolDisplayPart> GetAnonymousTypeParts(
-            INamedTypeSymbol anonymousType, SemanticModel semanticModel, int position)
+        protected override ImmutableArray<SymbolDisplayPart> GetNormalAnonymousTypeParts(
+            INamedTypeSymbol anonymousType,
+            SemanticModel semanticModel,
+            int position)
         {
             using var _ = ArrayBuilder<SymbolDisplayPart>.GetInstance(out var members);
 
@@ -56,5 +62,27 @@ public override ImmutableArray<SymbolDisplayPart> GetAnonymousTypeParts(
 
             return members.ToImmutable();
         }
+
+        protected override ImmutableArray<SymbolDisplayPart> GetDelegateAnonymousTypeParts(
+            INamedTypeSymbol anonymousType,
+            SemanticModel semanticModel,
+            int position)
+        {
+            using var _ = ArrayBuilder<SymbolDisplayPart>.GetInstance(out var parts);
+
+            parts.AddRange(anonymousType.DelegateInvokeMethod.ToMinimalDisplayParts(semanticModel, position, s_minimalWithoutContainingType));
+
+            // change the display from `bool Invoke(int x, string y)` to `bool delegate(int x, string y)`. `delegate`
+            // helps make it clear what sort of signature we're showing, and the lack of the name is appropriate as this
+            // is an anonymous delegate.
+            var namePart = parts.FirstOrNull(p => p.Kind == SymbolDisplayPartKind.MethodName && p.ToString() == anonymousType.DelegateInvokeMethod.Name);
+            if (namePart != null)
+            {
+                var index = parts.IndexOf(namePart.Value);
+                parts[index] = new SymbolDisplayPart(SymbolDisplayPartKind.Keyword, null, "delegate");
+            }
+
+            return parts.ToImmutable();
+        }
     }
 }
diff --git a/src/Features/CSharp/Portable/LanguageServices/CSharpSymbolDisplayService.SymbolDescriptionBuilder.cs b/src/Features/CSharp/Portable/LanguageServices/CSharpSymbolDisplayService.SymbolDescriptionBuilder.cs
index 62fe451699e51..cbfa1fbdcaab2 100644
--- a/src/Features/CSharp/Portable/LanguageServices/CSharpSymbolDisplayService.SymbolDescriptionBuilder.cs
+++ b/src/Features/CSharp/Portable/LanguageServices/CSharpSymbolDisplayService.SymbolDescriptionBuilder.cs
@@ -214,11 +214,11 @@ protected override void AddCaptures(ISymbol symbol)
                 }
             }
 
-            protected override void InlineAllDelegateAnonymousTypes(SemanticModel semanticModel, int position, IStructuralTypeDisplayService structuralTypeDisplayService, Dictionary<SymbolDescriptionGroups, IList<SymbolDisplayPart>> groupMap)
-            {
-                // In C#, anonymous delegates are typically represented with System.Action<> or System.Func<>,
-                // and we prefer to display those types rather than a structural delegate type.
-            }
+            //protected override void InlineAllDelegateAnonymousTypes(SemanticModel semanticModel, int position, IStructuralTypeDisplayService structuralTypeDisplayService, Dictionary<SymbolDescriptionGroups, IList<SymbolDisplayPart>> groupMap)
+            //{
+            //    // In C#, anonymous delegates are typically represented with System.Action<> or System.Func<>,
+            //    // and we prefer to display those types rather than a structural delegate type.
+            //}
 
             protected override SymbolDisplayFormat MinimallyQualifiedFormat => s_minimallyQualifiedFormat;
 
diff --git a/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.StructuralTypeCollectorVisitor.cs b/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.StructuralTypeCollectorVisitor.cs
index 54e833204b764..51fc6e3f90926 100644
--- a/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.StructuralTypeCollectorVisitor.cs
+++ b/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.StructuralTypeCollectorVisitor.cs
@@ -96,6 +96,7 @@ public override void VisitNamedType(INamedTypeSymbol symbol)
                     }
                     else if (symbol.IsAnonymousDelegateType())
                     {
+                        _namedTypes.Add(symbol, (order: _namedTypes.Count, count: 1));
                         symbol.DelegateInvokeMethod?.Accept(this);
                     }
                     else
diff --git a/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs b/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs
index 00ded8aab1dba..760d43ba8f41b 100644
--- a/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs
+++ b/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs
@@ -6,6 +6,7 @@
 using System.Collections.Immutable;
 using System.Linq;
 using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.LanguageServices
@@ -15,8 +16,13 @@ internal abstract partial class AbstractStructuralTypeDisplayService : IStructur
         protected static readonly SymbolDisplayFormat s_minimalWithoutExpandedTuples = SymbolDisplayFormat.MinimallyQualifiedFormat.AddMiscellaneousOptions(
             SymbolDisplayMiscellaneousOptions.CollapseTupleTypes);
 
-        public abstract ImmutableArray<SymbolDisplayPart> GetAnonymousTypeParts(
-            INamedTypeSymbol anonymousType, SemanticModel semanticModel, int position);
+        protected abstract ImmutableArray<SymbolDisplayPart> GetNormalAnonymousTypeParts(INamedTypeSymbol anonymousType, SemanticModel semanticModel, int position);
+        protected abstract ImmutableArray<SymbolDisplayPart> GetDelegateAnonymousTypeParts(INamedTypeSymbol anonymousType, SemanticModel semanticModel, int position);
+
+        public ImmutableArray<SymbolDisplayPart> GetAnonymousTypeParts(INamedTypeSymbol anonymousType, SemanticModel semanticModel, int position)
+            => anonymousType.IsAnonymousDelegateType()
+                ? GetDelegateAnonymousTypeParts(anonymousType, semanticModel, position)
+                : GetNormalAnonymousTypeParts(anonymousType, semanticModel, position);
 
         public StructuralTypeDisplayInfo GetTypeDisplayInfo(
             ISymbol orderSymbol,
@@ -47,9 +53,12 @@ public StructuralTypeDisplayInfo GetTypeDisplayInfo(
 
                 var structuralType = transitiveStructuralTypeReferences[i];
                 typeParts.AddRange(Space(count: 4));
-                typeParts.Add(Part(
-                    structuralType.IsValueType ? SymbolDisplayPartKind.StructName : SymbolDisplayPartKind.ClassName,
-                    structuralType, structuralType.Name));
+
+                var kind =
+                    structuralType.IsValueType ? SymbolDisplayPartKind.StructName :
+                    structuralType.IsDelegateType() ? SymbolDisplayPartKind.DelegateName : SymbolDisplayPartKind.ClassName;
+
+                typeParts.Add(Part(kind, structuralType, structuralType.Name));
                 typeParts.AddRange(Space());
                 typeParts.Add(PlainText(FeaturesResources.is_));
                 typeParts.AddRange(Space());
@@ -65,7 +74,7 @@ public StructuralTypeDisplayInfo GetTypeDisplayInfo(
             }
 
             // Now, inline any delegate anonymous types we've got.
-            typeParts = this.InlineDelegateAnonymousTypes(typeParts, semanticModel, position);
+            // typeParts = this.InlineDelegateAnonymousTypes(typeParts, semanticModel, position);
 
             // Finally, assign a name to all the anonymous types.
             var structuralTypeToName = GenerateStructuralTypeNames(transitiveStructuralTypeReferences);
diff --git a/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/IStructuralTypeDisplayServiceExtensions.cs b/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/IStructuralTypeDisplayServiceExtensions.cs
index 8f41b1b3c83df..8ef74b2897422 100644
--- a/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/IStructuralTypeDisplayServiceExtensions.cs
+++ b/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/IStructuralTypeDisplayServiceExtensions.cs
@@ -12,25 +12,25 @@ namespace Microsoft.CodeAnalysis.LanguageServices
 {
     internal static class IStructuralTypeDisplayServiceExtensions
     {
-        public static IList<SymbolDisplayPart> InlineDelegateAnonymousTypes(
-            this IStructuralTypeDisplayService service, IList<SymbolDisplayPart> parts, SemanticModel semanticModel, int position)
-        {
-            var result = parts;
-            while (true)
-            {
-                var delegateAnonymousType = result.Select(p => p.Symbol).OfType<INamedTypeSymbol>().FirstOrDefault(s => s.IsAnonymousDelegateType());
-                if (delegateAnonymousType == null)
-                {
-                    break;
-                }
+        //public static IList<SymbolDisplayPart> InlineDelegateAnonymousTypes(
+        //    this IStructuralTypeDisplayService service, IList<SymbolDisplayPart> parts, SemanticModel semanticModel, int position)
+        //{
+        //    var result = parts;
+        //    while (true)
+        //    {
+        //        var delegateAnonymousType = result.Select(p => p.Symbol).OfType<INamedTypeSymbol>().FirstOrDefault(s => s.IsAnonymousDelegateType());
+        //        if (delegateAnonymousType == null)
+        //        {
+        //            break;
+        //        }
 
-                result = result == parts ? new List<SymbolDisplayPart>(parts) : result;
-                ReplaceAnonymousType(result, delegateAnonymousType,
-                    service.GetAnonymousTypeParts(delegateAnonymousType, semanticModel, position));
-            }
+        //        result = result == parts ? new List<SymbolDisplayPart>(parts) : result;
+        //        ReplaceAnonymousType(result, delegateAnonymousType,
+        //            service.GetAnonymousTypeParts(delegateAnonymousType, semanticModel, position));
+        //    }
 
-            return result;
-        }
+        //    return result;
+        //}
 
         private static void ReplaceAnonymousType(
             IList<SymbolDisplayPart> list,
diff --git a/src/Features/Core/Portable/LanguageServices/SymbolDisplayService/AbstractSymbolDisplayService.AnonymousTypes.cs b/src/Features/Core/Portable/LanguageServices/SymbolDisplayService/AbstractSymbolDisplayService.AnonymousTypes.cs
index 7575bf0b5726b..ad80f976eba17 100644
--- a/src/Features/Core/Portable/LanguageServices/SymbolDisplayService/AbstractSymbolDisplayService.AnonymousTypes.cs
+++ b/src/Features/Core/Portable/LanguageServices/SymbolDisplayService/AbstractSymbolDisplayService.AnonymousTypes.cs
@@ -19,21 +19,21 @@ private void FixAllStructuralTypes(ISymbol firstSymbol)
             {
                 // First, inline all the delegate anonymous types.  This is how VB prefers to display
                 // things.
-                InlineAllDelegateAnonymousTypes(_semanticModel, _position, _structuralTypeDisplayService, _groupMap);
+                // InlineAllDelegateAnonymousTypes(_semanticModel, _position, _structuralTypeDisplayService, _groupMap);
 
                 // Now, replace all normal anonymous types and tuples with 'a, 'b, etc. and create a
                 // Structural Types: section to display their info.
                 FixStructuralTypes(firstSymbol);
             }
 
-            protected abstract void InlineAllDelegateAnonymousTypes(SemanticModel semanticModel, int position, IStructuralTypeDisplayService structuralTypeDisplayService, Dictionary<SymbolDescriptionGroups, IList<SymbolDisplayPart>> groupMap);
+            // protected abstract void InlineAllDelegateAnonymousTypes(SemanticModel semanticModel, int position, IStructuralTypeDisplayService structuralTypeDisplayService, Dictionary<SymbolDescriptionGroups, IList<SymbolDisplayPart>> groupMap);
 
             private void FixStructuralTypes(ISymbol firstSymbol)
             {
                 var directStructuralTypes =
                     from parts in _groupMap.Values
                     from part in parts
-                    where part.Symbol.IsNormalAnonymousType() || part.Symbol.IsTupleType()
+                    where part.Symbol.IsAnonymousType() || part.Symbol.IsTupleType()
                     select (INamedTypeSymbol)part.Symbol;
 
                 var info = _structuralTypeDisplayService.GetTypeDisplayInfo(
diff --git a/src/Features/Core/Portable/SignatureHelp/AbstractSignatureHelpProvider.cs b/src/Features/Core/Portable/SignatureHelp/AbstractSignatureHelpProvider.cs
index e2681691d5f3c..b77a10e094ec5 100644
--- a/src/Features/Core/Portable/SignatureHelp/AbstractSignatureHelpProvider.cs
+++ b/src/Features/Core/Portable/SignatureHelp/AbstractSignatureHelpProvider.cs
@@ -172,10 +172,10 @@ protected static SignatureHelpItem CreateItemImpl(
             IList<SignatureHelpSymbolParameter> parameters,
             IList<SymbolDisplayPart>? descriptionParts)
         {
-            prefixParts = structuralTypeDisplayService.InlineDelegateAnonymousTypes(prefixParts, semanticModel, position);
-            separatorParts = structuralTypeDisplayService.InlineDelegateAnonymousTypes(separatorParts, semanticModel, position);
-            suffixParts = structuralTypeDisplayService.InlineDelegateAnonymousTypes(suffixParts, semanticModel, position);
-            parameters = parameters.Select(p => InlineDelegateAnonymousTypes(p, semanticModel, position, structuralTypeDisplayService)).ToList();
+            //prefixParts = structuralTypeDisplayService.InlineDelegateAnonymousTypes(prefixParts, semanticModel, position);
+            //separatorParts = structuralTypeDisplayService.InlineDelegateAnonymousTypes(separatorParts, semanticModel, position);
+            //suffixParts = structuralTypeDisplayService.InlineDelegateAnonymousTypes(suffixParts, semanticModel, position);
+            //parameters = parameters.Select(p => InlineDelegateAnonymousTypes(p, semanticModel, position, structuralTypeDisplayService)).ToList();
             descriptionParts = descriptionParts == null
                 ? SpecializedCollections.EmptyList<SymbolDisplayPart>()
                 : descriptionParts;
@@ -187,7 +187,7 @@ protected static SignatureHelpItem CreateItemImpl(
 
             var structuralTypes =
                 from part in allParts
-                where part.Symbol.IsNormalAnonymousType() || part.Symbol.IsTupleType()
+                where part.Symbol.IsAnonymousType() || part.Symbol.IsTupleType()
                 select (INamedTypeSymbol)part.Symbol!;
 
             var info = structuralTypeDisplayService.GetTypeDisplayInfo(
@@ -195,12 +195,12 @@ where part.Symbol.IsNormalAnonymousType() || part.Symbol.IsTupleType()
 
             if (info.TypesParts.Count > 0)
             {
-                var anonymousTypeParts = new List<SymbolDisplayPart>
+                var structuralTypeParts = new List<SymbolDisplayPart>
                 {
                     new SymbolDisplayPart(SymbolDisplayPartKind.Space, null, "\r\n\r\n")
                 };
 
-                anonymousTypeParts.AddRange(info.TypesParts);
+                structuralTypeParts.AddRange(info.TypesParts);
 
                 return new SymbolKeySignatureHelpItem(
                     orderSymbol,
@@ -210,7 +210,7 @@ where part.Symbol.IsNormalAnonymousType() || part.Symbol.IsTupleType()
                     info.ReplaceStructuralTypes(separatorParts, semanticModel, position).ToTaggedText(),
                     info.ReplaceStructuralTypes(suffixParts, semanticModel, position).ToTaggedText(),
                     parameters.Select(p => ReplaceStructuralTypes(p, info, semanticModel, position)).Select(p => (SignatureHelpParameter)p),
-                    anonymousTypeParts.ToTaggedText());
+                    structuralTypeParts.ToTaggedText());
             }
 
             return new SymbolKeySignatureHelpItem(
@@ -238,21 +238,21 @@ private static SignatureHelpSymbolParameter ReplaceStructuralTypes(
                 info.ReplaceStructuralTypes(parameter.SelectedDisplayParts, semanticModel, position));
         }
 
-        private static SignatureHelpSymbolParameter InlineDelegateAnonymousTypes(
-            SignatureHelpSymbolParameter parameter,
-            SemanticModel semanticModel,
-            int position,
-            IStructuralTypeDisplayService structuralTypeDisplayService)
-        {
-            return new SignatureHelpSymbolParameter(
-                parameter.Name,
-                parameter.IsOptional,
-                parameter.DocumentationFactory,
-                structuralTypeDisplayService.InlineDelegateAnonymousTypes(parameter.DisplayParts, semanticModel, position),
-                structuralTypeDisplayService.InlineDelegateAnonymousTypes(parameter.PrefixDisplayParts, semanticModel, position),
-                structuralTypeDisplayService.InlineDelegateAnonymousTypes(parameter.SuffixDisplayParts, semanticModel, position),
-                structuralTypeDisplayService.InlineDelegateAnonymousTypes(parameter.SelectedDisplayParts, semanticModel, position));
-        }
+        //private static SignatureHelpSymbolParameter InlineDelegateAnonymousTypes(
+        //    SignatureHelpSymbolParameter parameter,
+        //    SemanticModel semanticModel,
+        //    int position,
+        //    IStructuralTypeDisplayService structuralTypeDisplayService)
+        //{
+        //    return new SignatureHelpSymbolParameter(
+        //        parameter.Name,
+        //        parameter.IsOptional,
+        //        parameter.DocumentationFactory,
+        //        structuralTypeDisplayService.InlineDelegateAnonymousTypes(parameter.DisplayParts, semanticModel, position),
+        //        structuralTypeDisplayService.InlineDelegateAnonymousTypes(parameter.PrefixDisplayParts, semanticModel, position),
+        //        structuralTypeDisplayService.InlineDelegateAnonymousTypes(parameter.SuffixDisplayParts, semanticModel, position),
+        //        structuralTypeDisplayService.InlineDelegateAnonymousTypes(parameter.SelectedDisplayParts, semanticModel, position));
+        //}
 
         public async Task<SignatureHelpItems?> GetItemsAsync(
             Document document, int position, SignatureHelpTriggerInfo triggerInfo, SignatureHelpOptions options, CancellationToken cancellationToken)
diff --git a/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicStructuralTypeDisplayService.vb b/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicStructuralTypeDisplayService.vb
index eb15819db5410..7dc6d68253671 100644
--- a/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicStructuralTypeDisplayService.vb
+++ b/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicStructuralTypeDisplayService.vb
@@ -37,15 +37,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.LanguageServices
         Public Sub New()
         End Sub
 
-        Public Overrides Function GetAnonymousTypeParts(anonymousType As INamedTypeSymbol, semanticModel As SemanticModel, position As Integer) As ImmutableArray(Of SymbolDisplayPart)
-            If anonymousType.IsAnonymousDelegateType() Then
-                Return GetDelegateAnonymousType(anonymousType, semanticModel, position)
-            Else
-                Return GetNormalAnonymousType(anonymousType, semanticModel, position)
-            End If
-        End Function
-
-        Private Shared Function GetDelegateAnonymousType(
+        Protected Overrides Function GetDelegateAnonymousTypeParts(
                 anonymousType As INamedTypeSymbol,
                 semanticModel As SemanticModel,
                 position As Integer) As ImmutableArray(Of SymbolDisplayPart)
@@ -80,7 +72,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.LanguageServices
             Return result
         End Function
 
-        Private Shared Function GetNormalAnonymousType(
+        Protected Overrides Function GetNormalAnonymousTypeParts(
                 anonymousType As INamedTypeSymbol,
                 semanticModel As SemanticModel,
                 position As Integer) As ImmutableArray(Of SymbolDisplayPart)
diff --git a/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicSymbolDisplayService.SymbolDescriptionBuilder.vb b/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicSymbolDisplayService.SymbolDescriptionBuilder.vb
index b4c88cdd5cb0d..a0478b7b143fc 100644
--- a/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicSymbolDisplayService.SymbolDescriptionBuilder.vb
+++ b/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicSymbolDisplayService.SymbolDescriptionBuilder.vb
@@ -175,18 +175,18 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.LanguageServices
                 End If
             End Sub
 
-            Protected Overrides Sub InlineAllDelegateAnonymousTypes(semanticModel As SemanticModel, position As Integer, structuralTypeDisplayService As IStructuralTypeDisplayService, groupMap As Dictionary(Of SymbolDescriptionGroups, IList(Of SymbolDisplayPart)))
-Restart:
-                For Each pair In groupMap
-                    Dim group = pair.Key
-                    Dim parts = pair.Value
-                    Dim updatedParts = structuralTypeDisplayService.InlineDelegateAnonymousTypes(parts, semanticModel, position)
-                    If parts IsNot updatedParts Then
-                        groupMap(group) = updatedParts
-                        GoTo Restart
-                    End If
-                Next
-            End Sub
+            '            Protected Overrides Sub InlineAllDelegateAnonymousTypes(semanticModel As SemanticModel, position As Integer, structuralTypeDisplayService As IStructuralTypeDisplayService, groupMap As Dictionary(Of SymbolDescriptionGroups, IList(Of SymbolDisplayPart)))
+            'Restart:
+            '                For Each pair In groupMap
+            '                    Dim group = pair.Key
+            '                    Dim parts = pair.Value
+            '                    Dim updatedParts = structuralTypeDisplayService.InlineDelegateAnonymousTypes(parts, semanticModel, position)
+            '                    If parts IsNot updatedParts Then
+            '                        groupMap(group) = updatedParts
+            '                        GoTo Restart
+            '                    End If
+            '                Next
+            '            End Sub
 
             Protected Overrides ReadOnly Property MinimallyQualifiedFormat As SymbolDisplayFormat
                 Get

From 011285612f6c7cdc02cb204732a87d750be02c62 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 17 Jan 2022 19:12:07 -0800
Subject: [PATCH 417/444] Remove dead code

---
 ...DisplayService.SymbolDescriptionBuilder.cs |  6 ---
 .../AbstractStructuralTypeDisplayService.cs   |  3 --
 ...IStructuralTypeDisplayServiceExtensions.cs | 49 -------------------
 .../AbstractSignatureHelpProvider.cs          | 20 --------
 ...DisplayService.SymbolDescriptionBuilder.vb | 36 ++------------
 5 files changed, 5 insertions(+), 109 deletions(-)
 delete mode 100644 src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/IStructuralTypeDisplayServiceExtensions.cs

diff --git a/src/Features/CSharp/Portable/LanguageServices/CSharpSymbolDisplayService.SymbolDescriptionBuilder.cs b/src/Features/CSharp/Portable/LanguageServices/CSharpSymbolDisplayService.SymbolDescriptionBuilder.cs
index cbfa1fbdcaab2..31f2839c0402d 100644
--- a/src/Features/CSharp/Portable/LanguageServices/CSharpSymbolDisplayService.SymbolDescriptionBuilder.cs
+++ b/src/Features/CSharp/Portable/LanguageServices/CSharpSymbolDisplayService.SymbolDescriptionBuilder.cs
@@ -214,12 +214,6 @@ protected override void AddCaptures(ISymbol symbol)
                 }
             }
 
-            //protected override void InlineAllDelegateAnonymousTypes(SemanticModel semanticModel, int position, IStructuralTypeDisplayService structuralTypeDisplayService, Dictionary<SymbolDescriptionGroups, IList<SymbolDisplayPart>> groupMap)
-            //{
-            //    // In C#, anonymous delegates are typically represented with System.Action<> or System.Func<>,
-            //    // and we prefer to display those types rather than a structural delegate type.
-            //}
-
             protected override SymbolDisplayFormat MinimallyQualifiedFormat => s_minimallyQualifiedFormat;
 
             protected override SymbolDisplayFormat MinimallyQualifiedFormatWithConstants => s_minimallyQualifiedFormatWithConstants;
diff --git a/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs b/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs
index 760d43ba8f41b..bbfd0adbb3d02 100644
--- a/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs
+++ b/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs
@@ -73,9 +73,6 @@ public StructuralTypeDisplayInfo GetTypeDisplayInfo(
                 }
             }
 
-            // Now, inline any delegate anonymous types we've got.
-            // typeParts = this.InlineDelegateAnonymousTypes(typeParts, semanticModel, position);
-
             // Finally, assign a name to all the anonymous types.
             var structuralTypeToName = GenerateStructuralTypeNames(transitiveStructuralTypeReferences);
             typeParts = StructuralTypeDisplayInfo.ReplaceStructuralTypes(
diff --git a/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/IStructuralTypeDisplayServiceExtensions.cs b/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/IStructuralTypeDisplayServiceExtensions.cs
deleted file mode 100644
index 8ef74b2897422..0000000000000
--- a/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/IStructuralTypeDisplayServiceExtensions.cs
+++ /dev/null
@@ -1,49 +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.Generic;
-using System.Linq;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Shared.Extensions;
-using Roslyn.Utilities;
-
-namespace Microsoft.CodeAnalysis.LanguageServices
-{
-    internal static class IStructuralTypeDisplayServiceExtensions
-    {
-        //public static IList<SymbolDisplayPart> InlineDelegateAnonymousTypes(
-        //    this IStructuralTypeDisplayService service, IList<SymbolDisplayPart> parts, SemanticModel semanticModel, int position)
-        //{
-        //    var result = parts;
-        //    while (true)
-        //    {
-        //        var delegateAnonymousType = result.Select(p => p.Symbol).OfType<INamedTypeSymbol>().FirstOrDefault(s => s.IsAnonymousDelegateType());
-        //        if (delegateAnonymousType == null)
-        //        {
-        //            break;
-        //        }
-
-        //        result = result == parts ? new List<SymbolDisplayPart>(parts) : result;
-        //        ReplaceAnonymousType(result, delegateAnonymousType,
-        //            service.GetAnonymousTypeParts(delegateAnonymousType, semanticModel, position));
-        //    }
-
-        //    return result;
-        //}
-
-        private static void ReplaceAnonymousType(
-            IList<SymbolDisplayPart> list,
-            INamedTypeSymbol anonymousType,
-            IEnumerable<SymbolDisplayPart> parts)
-        {
-            var index = list.IndexOf(p => anonymousType.Equals(p.Symbol));
-            if (index >= 0)
-            {
-                var result = list.Take(index).Concat(parts).Concat(list.Skip(index + 1)).ToList();
-                list.Clear();
-                list.AddRange(result);
-            }
-        }
-    }
-}
diff --git a/src/Features/Core/Portable/SignatureHelp/AbstractSignatureHelpProvider.cs b/src/Features/Core/Portable/SignatureHelp/AbstractSignatureHelpProvider.cs
index b77a10e094ec5..67fccd78477b6 100644
--- a/src/Features/Core/Portable/SignatureHelp/AbstractSignatureHelpProvider.cs
+++ b/src/Features/Core/Portable/SignatureHelp/AbstractSignatureHelpProvider.cs
@@ -172,10 +172,6 @@ protected static SignatureHelpItem CreateItemImpl(
             IList<SignatureHelpSymbolParameter> parameters,
             IList<SymbolDisplayPart>? descriptionParts)
         {
-            //prefixParts = structuralTypeDisplayService.InlineDelegateAnonymousTypes(prefixParts, semanticModel, position);
-            //separatorParts = structuralTypeDisplayService.InlineDelegateAnonymousTypes(separatorParts, semanticModel, position);
-            //suffixParts = structuralTypeDisplayService.InlineDelegateAnonymousTypes(suffixParts, semanticModel, position);
-            //parameters = parameters.Select(p => InlineDelegateAnonymousTypes(p, semanticModel, position, structuralTypeDisplayService)).ToList();
             descriptionParts = descriptionParts == null
                 ? SpecializedCollections.EmptyList<SymbolDisplayPart>()
                 : descriptionParts;
@@ -238,22 +234,6 @@ private static SignatureHelpSymbolParameter ReplaceStructuralTypes(
                 info.ReplaceStructuralTypes(parameter.SelectedDisplayParts, semanticModel, position));
         }
 
-        //private static SignatureHelpSymbolParameter InlineDelegateAnonymousTypes(
-        //    SignatureHelpSymbolParameter parameter,
-        //    SemanticModel semanticModel,
-        //    int position,
-        //    IStructuralTypeDisplayService structuralTypeDisplayService)
-        //{
-        //    return new SignatureHelpSymbolParameter(
-        //        parameter.Name,
-        //        parameter.IsOptional,
-        //        parameter.DocumentationFactory,
-        //        structuralTypeDisplayService.InlineDelegateAnonymousTypes(parameter.DisplayParts, semanticModel, position),
-        //        structuralTypeDisplayService.InlineDelegateAnonymousTypes(parameter.PrefixDisplayParts, semanticModel, position),
-        //        structuralTypeDisplayService.InlineDelegateAnonymousTypes(parameter.SuffixDisplayParts, semanticModel, position),
-        //        structuralTypeDisplayService.InlineDelegateAnonymousTypes(parameter.SelectedDisplayParts, semanticModel, position));
-        //}
-
         public async Task<SignatureHelpItems?> GetItemsAsync(
             Document document, int position, SignatureHelpTriggerInfo triggerInfo, SignatureHelpOptions options, CancellationToken cancellationToken)
         {
diff --git a/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicSymbolDisplayService.SymbolDescriptionBuilder.vb b/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicSymbolDisplayService.SymbolDescriptionBuilder.vb
index a0478b7b143fc..5c101ab3b6497 100644
--- a/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicSymbolDisplayService.SymbolDescriptionBuilder.vb
+++ b/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicSymbolDisplayService.SymbolDescriptionBuilder.vb
@@ -5,7 +5,6 @@
 Imports System.Collections.Immutable
 Imports System.Threading
 Imports Microsoft.CodeAnalysis.Classification
-Imports Microsoft.CodeAnalysis.Classification.Classifiers
 Imports Microsoft.CodeAnalysis.Host
 Imports Microsoft.CodeAnalysis.LanguageServices
 Imports Microsoft.CodeAnalysis.VisualBasic
@@ -175,36 +174,11 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.LanguageServices
                 End If
             End Sub
 
-            '            Protected Overrides Sub InlineAllDelegateAnonymousTypes(semanticModel As SemanticModel, position As Integer, structuralTypeDisplayService As IStructuralTypeDisplayService, groupMap As Dictionary(Of SymbolDescriptionGroups, IList(Of SymbolDisplayPart)))
-            'Restart:
-            '                For Each pair In groupMap
-            '                    Dim group = pair.Key
-            '                    Dim parts = pair.Value
-            '                    Dim updatedParts = structuralTypeDisplayService.InlineDelegateAnonymousTypes(parts, semanticModel, position)
-            '                    If parts IsNot updatedParts Then
-            '                        groupMap(group) = updatedParts
-            '                        GoTo Restart
-            '                    End If
-            '                Next
-            '            End Sub
-
-            Protected Overrides ReadOnly Property MinimallyQualifiedFormat As SymbolDisplayFormat
-                Get
-                    Return s_minimallyQualifiedFormat
-                End Get
-            End Property
-
-            Protected Overrides ReadOnly Property MinimallyQualifiedFormatWithConstants As SymbolDisplayFormat
-                Get
-                    Return s_minimallyQualifiedFormatWithConstants
-                End Get
-            End Property
-
-            Protected Overrides ReadOnly Property MinimallyQualifiedFormatWithConstantsAndModifiers As SymbolDisplayFormat
-                Get
-                    Return s_minimallyQualifiedFormatWithConstantsAndModifiers
-                End Get
-            End Property
+            Protected Overrides ReadOnly Property MinimallyQualifiedFormat As SymbolDisplayFormat = s_minimallyQualifiedFormat
+
+            Protected Overrides ReadOnly Property MinimallyQualifiedFormatWithConstants As SymbolDisplayFormat = s_minimallyQualifiedFormatWithConstants
+
+            Protected Overrides ReadOnly Property MinimallyQualifiedFormatWithConstantsAndModifiers As SymbolDisplayFormat = s_minimallyQualifiedFormatWithConstantsAndModifiers
         End Class
     End Class
 End Namespace

From d03854fe3377feea96928f10528472e26ec88716 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 17 Jan 2022 19:13:04 -0800
Subject: [PATCH 418/444] Remove dead code

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

diff --git a/src/Features/Core/Portable/LanguageServices/SymbolDisplayService/AbstractSymbolDisplayService.AnonymousTypes.cs b/src/Features/Core/Portable/LanguageServices/SymbolDisplayService/AbstractSymbolDisplayService.AnonymousTypes.cs
index ad80f976eba17..d0446e7427378 100644
--- a/src/Features/Core/Portable/LanguageServices/SymbolDisplayService/AbstractSymbolDisplayService.AnonymousTypes.cs
+++ b/src/Features/Core/Portable/LanguageServices/SymbolDisplayService/AbstractSymbolDisplayService.AnonymousTypes.cs
@@ -17,19 +17,9 @@ protected abstract partial class AbstractSymbolDescriptionBuilder
         {
             private void FixAllStructuralTypes(ISymbol firstSymbol)
             {
-                // First, inline all the delegate anonymous types.  This is how VB prefers to display
-                // things.
-                // InlineAllDelegateAnonymousTypes(_semanticModel, _position, _structuralTypeDisplayService, _groupMap);
-
                 // Now, replace all normal anonymous types and tuples with 'a, 'b, etc. and create a
                 // Structural Types: section to display their info.
-                FixStructuralTypes(firstSymbol);
-            }
 
-            // protected abstract void InlineAllDelegateAnonymousTypes(SemanticModel semanticModel, int position, IStructuralTypeDisplayService structuralTypeDisplayService, Dictionary<SymbolDescriptionGroups, IList<SymbolDisplayPart>> groupMap);
-
-            private void FixStructuralTypes(ISymbol firstSymbol)
-            {
                 var directStructuralTypes =
                     from parts in _groupMap.Values
                     from part in parts

From 98683647f9cf1775de46e2e7ea2e6a1a29488a2e Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 17 Jan 2022 19:15:34 -0800
Subject: [PATCH 419/444] NRT

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

diff --git a/src/Features/Core/Portable/LanguageServices/SymbolDisplayService/AbstractSymbolDisplayService.AnonymousTypes.cs b/src/Features/Core/Portable/LanguageServices/SymbolDisplayService/AbstractSymbolDisplayService.AnonymousTypes.cs
index d0446e7427378..7ff36ea309276 100644
--- a/src/Features/Core/Portable/LanguageServices/SymbolDisplayService/AbstractSymbolDisplayService.AnonymousTypes.cs
+++ b/src/Features/Core/Portable/LanguageServices/SymbolDisplayService/AbstractSymbolDisplayService.AnonymousTypes.cs
@@ -2,9 +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.
 
-#nullable disable
-
-using System.Collections.Generic;
 using System.Linq;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;
@@ -24,7 +21,7 @@ private void FixAllStructuralTypes(ISymbol firstSymbol)
                     from parts in _groupMap.Values
                     from part in parts
                     where part.Symbol.IsAnonymousType() || part.Symbol.IsTupleType()
-                    select (INamedTypeSymbol)part.Symbol;
+                    select (INamedTypeSymbol)part.Symbol!;
 
                 var info = _structuralTypeDisplayService.GetTypeDisplayInfo(
                     firstSymbol, directStructuralTypes.ToImmutableArrayOrEmpty(), _semanticModel, _position);

From 984978dbfeeb5c9fffa925dc6b59df66b9bf9b6c Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 17 Jan 2022 19:45:17 -0800
Subject: [PATCH 420/444] Only show display for child symbol

---
 .../QuickInfo/SemanticQuickInfoSourceTests.cs | 45 ++++++++++++++++++-
 ...ractSymbolDisplayService.AnonymousTypes.cs |  6 +++
 2 files changed, 50 insertions(+), 1 deletion(-)

diff --git a/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs b/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs
index bd6fa8efe567f..99923ae81bfdb 100644
--- a/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs
+++ b/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs
@@ -7914,6 +7914,7 @@ void M()
 TResult {FeaturesResources.is_} string"));
         }
 
+        [WorkItem(58871, "https://github.com/dotnet/roslyn/issues/58871")]
         [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
         public async Task TestAnonymousSynthesizedLambdaType()
         {
@@ -7925,7 +7926,49 @@ void M()
         $$var v = (ref int i) => i.ToString();
     }
 }",
-                MainDescription("delegate string <anonymous delegate>(ref int)"));
+                MainDescription("delegate string <anonymous delegate>(ref int)"),
+                AnonymousTypes(""));
+        }
+
+        [WorkItem(58871, "https://github.com/dotnet/roslyn/issues/58871")]
+        [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
+        public async Task TestAnonymousSynthesizedLambdaType2()
+        {
+            await TestAsync(
+@"class C
+{
+    void M()
+    {
+        var $$v = (ref int i) => i.ToString();
+    }
+}",
+                MainDescription("(local variable) 'a v"),
+                AnonymousTypes(
+$@"
+{FeaturesResources.Types_colon}
+    'a {FeaturesResources.is_} string delegate(ref int)"));
+        }
+
+        [WorkItem(58871, "https://github.com/dotnet/roslyn/issues/58871")]
+        [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
+        public async Task TestAnonymousSynthesizedLambdaType3()
+        {
+            await TestAsync(
+@"class C
+{
+    void M()
+    {
+        var v = (ref int i) => i.ToString();
+        $$Goo(v);
+    }
+
+    T Goo<T>(T t) => default;
+}",
+                MainDescription("'a C.Goo<'a>('a t)"),
+                AnonymousTypes(
+$@"
+{FeaturesResources.Types_colon}
+    'a {FeaturesResources.is_} string delegate(ref int)"));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
diff --git a/src/Features/Core/Portable/LanguageServices/SymbolDisplayService/AbstractSymbolDisplayService.AnonymousTypes.cs b/src/Features/Core/Portable/LanguageServices/SymbolDisplayService/AbstractSymbolDisplayService.AnonymousTypes.cs
index 7ff36ea309276..4a9243b65f3b1 100644
--- a/src/Features/Core/Portable/LanguageServices/SymbolDisplayService/AbstractSymbolDisplayService.AnonymousTypes.cs
+++ b/src/Features/Core/Portable/LanguageServices/SymbolDisplayService/AbstractSymbolDisplayService.AnonymousTypes.cs
@@ -23,6 +23,12 @@ from part in parts
                     where part.Symbol.IsAnonymousType() || part.Symbol.IsTupleType()
                     select (INamedTypeSymbol)part.Symbol!;
 
+                // If the first symbol is an anonymous delegate, just show it's full sig in-line in the main
+                // description.  Otherwise, replace it with 'a, 'b etc. and show its sig in the 'Types:' section.
+
+                if (firstSymbol.IsAnonymousDelegateType())
+                    directStructuralTypes = directStructuralTypes.Except(new[] { (INamedTypeSymbol)firstSymbol });
+
                 var info = _structuralTypeDisplayService.GetTypeDisplayInfo(
                     firstSymbol, directStructuralTypes.ToImmutableArrayOrEmpty(), _semanticModel, _position);
 

From 6610b467bc1af2f5bef4d35ebbad6f602f913894 Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrus.najmabadi@gmail.com>
Date: Mon, 17 Jan 2022 18:03:15 -1000
Subject: [PATCH 421/444] Update
 src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs

Co-authored-by: David Wengier <david.wengier@microsoft.com>
---
 ...CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
index 3b19a52d34580..0aa0d83da8f83 100644
--- a/src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
@@ -235,7 +235,7 @@ private static bool OverloadsChanged(
         private static bool IsIdentityOrImplicitConversion(Compilation compilation, ITypeSymbol type1, ITypeSymbol type2)
         {
             // Dynamic can have an identity conversion between types.  But it can have a very different effect on the
-            // generated code.  Do not allow the change if these are nto in agreement.
+            // generated code.  Do not allow the change if these are not in agreement.
             if (type1 is IDynamicTypeSymbol != type2 is IDynamicTypeSymbol)
                 return false;
 

From 6e8abca7f0ee2a26cae107d7752f7f2af3c478fc Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 17 Jan 2022 20:24:11 -0800
Subject: [PATCH 422/444] Update tests

---
 .../QuickInfo/SemanticQuickInfoSourceTests.vb   | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/src/EditorFeatures/VisualBasicTest/QuickInfo/SemanticQuickInfoSourceTests.vb b/src/EditorFeatures/VisualBasicTest/QuickInfo/SemanticQuickInfoSourceTests.vb
index 18a360f2ec676..965eec47feb6f 100644
--- a/src/EditorFeatures/VisualBasicTest/QuickInfo/SemanticQuickInfoSourceTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/QuickInfo/SemanticQuickInfoSourceTests.vb
@@ -950,7 +950,8 @@ Module Program
     End Sub
 End Module
 ]]></Text>.NormalizedValue,
-            MainDescription($"({FeaturesResources.local_variable}) a As <Sub()>"))
+            MainDescription($"({FeaturesResources.local_variable}) a As 'a"),
+            AnonymousTypes(vbCrLf & FeaturesResources.Types_colon & vbCrLf & $"    'a {FeaturesResources.is_} <Sub()>"))
         End Function
 
         <WorkItem(543624, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543624")>
@@ -966,7 +967,8 @@ Module Program
     End Sub
 End Module
 ]]></Text>.NormalizedValue,
-            MainDescription($"({FeaturesResources.local_variable}) a As <Function() As Integer>"))
+            MainDescription($"({FeaturesResources.local_variable}) a As 'a"),
+            AnonymousTypes(vbCrLf & FeaturesResources.Types_colon & vbCrLf & $"    'a {FeaturesResources.is_} <Function() As Integer>"))
         End Function
 
         <WorkItem(543624, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543624")>
@@ -981,9 +983,10 @@ Module Program
     End Sub
 End Module
 ]]></Text>.NormalizedValue,
-            MainDescription($"({FeaturesResources.local_variable}) a As <Function() As 'a>"),
+            MainDescription($"({FeaturesResources.local_variable}) a As 'a"),
             AnonymousTypes(vbCrLf & FeaturesResources.Types_colon & vbCrLf &
-                           $"    'a {FeaturesResources.is_} New With {{ .Goo As String }}"))
+                           $"    'a {FeaturesResources.is_} <Function() As 'b>" & vbCrLf &
+                           $"    'b {FeaturesResources.is_} New With {{ .Goo As String }}"))
         End Function
 
         <WorkItem(543624, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543624")>
@@ -999,9 +1002,11 @@ Module Program
     End Sub
 End Module
 ]]></Text>.NormalizedValue,
-            MainDescription($"({FeaturesResources.local_variable}) a As <Function(i As Integer) As 'a>"),
+            MainDescription($"({FeaturesResources.local_variable}) a As 'a"),
             AnonymousTypes(vbCrLf & FeaturesResources.Types_colon & vbCrLf &
-                           $"    'a {FeaturesResources.is_} New With {{ .Sq As Integer, .M As <Function(j As Integer) As Integer> }}"))
+                           $"    'a {FeaturesResources.is_} <Function(i As Integer) As 'b>" & vbCrLf &
+                           $"    'b {FeaturesResources.is_} New With {{ .Sq As Integer, .M As 'c }}" & vbCrLf &
+                           $"    'c {FeaturesResources.is_} <Function(j As Integer) As Integer>"))
         End Function
 
         <WorkItem(543389, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543389")>

From db59d5d7bd0bdc991b6ef6639b1d22dd89089001 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 17 Jan 2022 20:30:03 -0800
Subject: [PATCH 423/444] Fix comment

---
 ...arpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
index 3b19a52d34580..df7fab913f219 100644
--- a/src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/RemoveUnnecessaryLambdaExpression/CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs
@@ -73,8 +73,9 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, INamedTypeSymbol?
 
             // Syntax checks first.
 
-            // Don't simplify static lambdas.  The user made them explicitly static to make it clear it doesn't capture
-            // anything.  If we get rid of the lambda it won't be clear anymore if capturing/allocs are happening or not.
+            // Don't simplify static lambdas.  The user made them explicitly static to make it clear it must only cause
+            // a single allocation for the cached delegate. If we get rid of the lambda (and thus the static-keyword) it
+            // won't be clear anymore if the member-group-conversion allocation is cached or not.
             if (anonymousFunction.Modifiers.Any(SyntaxKind.StaticKeyword))
                 return;
 

From 5fbe868b4b2e538095d212ecca1e6be9eafa25da Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 17 Jan 2022 20:33:45 -0800
Subject: [PATCH 424/444] Add trivia case

---
 .../RemoveUnnecessaryLambdaExpressionTests.cs | 32 ++++++++++++++++++-
 1 file changed, 31 insertions(+), 1 deletion(-)

diff --git a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
index 60095aaba59fe..f51e59af519b1 100644
--- a/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
+++ b/src/EditorFeatures/CSharpTest/RemoveUnnecessaryLambdaExpression/RemoveUnnecessaryLambdaExpressionTests.cs
@@ -52,7 +52,7 @@ void Bar(Func<int, string> f) { }
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
-        public async Task Test1()
+        public async Task TestBasicCase()
         {
             await TestInRegularAndScriptAsync(
 @"using System;
@@ -1460,5 +1460,35 @@ public NotNullIfNotNullAttribute(string parameterName)
 }
 ");
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryLambdaExpression)]
+        public async Task TestTrivia1()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void Goo()
+    {
+        Bar(/*before*/[|s => |]Quux(s)/*after*/);
+    }
+
+    void Bar(Func<int, string> f) { }
+    string Quux(int i) => default;
+}",
+@"using System;
+
+class C
+{
+    void Goo()
+    {
+        Bar(/*before*/Quux/*after*/);
+    }
+
+    void Bar(Func<int, string> f) { }
+    string Quux(int i) => default;
+}");
+        }
     }
 }

From 640b0565efb5c95c7a06e75cc1cb1bfdf4273ab0 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 17 Jan 2022 20:38:18 -0800
Subject: [PATCH 425/444] Format

---
 .../VisualBasicStructuralTypeDisplayService.vb               | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicStructuralTypeDisplayService.vb b/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicStructuralTypeDisplayService.vb
index eb15819db5410..b852e1217b408 100644
--- a/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicStructuralTypeDisplayService.vb
+++ b/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicStructuralTypeDisplayService.vb
@@ -61,8 +61,9 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.LanguageServices
             Return members.ToImmutableAndFree()
         End Function
 
-        Private Shared Function MassageDelegateParts(delegateInvoke As IMethodSymbol,
-                                              parts As IEnumerable(Of SymbolDisplayPart)) As IEnumerable(Of SymbolDisplayPart)
+        Private Shared Function MassageDelegateParts(
+                delegateInvoke As IMethodSymbol,
+                parts As IEnumerable(Of SymbolDisplayPart)) As IEnumerable(Of SymbolDisplayPart)
             ' So ugly.  We remove the 'Invoke' name that was added by the symbol display service.
             Dim result = New List(Of SymbolDisplayPart)
             For Each part In parts

From 54f3d613e1084d3679d587a8964b6d548b4c54bc Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 17 Jan 2022 20:51:20 -0800
Subject: [PATCH 426/444] Unify C# and VB signatures

---
 .../QuickInfo/SemanticQuickInfoSourceTests.cs |  4 +-
 .../CSharpStructuralTypeDisplayService.cs     | 25 ---------
 .../AbstractStructuralTypeDisplayService.cs   | 46 +++++++++++++++-
 ...VisualBasicStructuralTypeDisplayService.vb | 52 -------------------
 4 files changed, 47 insertions(+), 80 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs b/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs
index 99923ae81bfdb..2c9111e54300a 100644
--- a/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs
+++ b/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs
@@ -7946,7 +7946,7 @@ void M()
                 AnonymousTypes(
 $@"
 {FeaturesResources.Types_colon}
-    'a {FeaturesResources.is_} string delegate(ref int)"));
+    'a {FeaturesResources.is_} <string(ref int)>"));
         }
 
         [WorkItem(58871, "https://github.com/dotnet/roslyn/issues/58871")]
@@ -7968,7 +7968,7 @@ void M()
                 AnonymousTypes(
 $@"
 {FeaturesResources.Types_colon}
-    'a {FeaturesResources.is_} string delegate(ref int)"));
+    'a {FeaturesResources.is_} <string(ref int)>"));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
diff --git a/src/Features/CSharp/Portable/LanguageServices/CSharpStructuralTypeDisplayService.cs b/src/Features/CSharp/Portable/LanguageServices/CSharpStructuralTypeDisplayService.cs
index d3c12b1e4be46..005357a5a2f97 100644
--- a/src/Features/CSharp/Portable/LanguageServices/CSharpStructuralTypeDisplayService.cs
+++ b/src/Features/CSharp/Portable/LanguageServices/CSharpStructuralTypeDisplayService.cs
@@ -21,9 +21,6 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.LanguageServices
     [ExportLanguageService(typeof(IStructuralTypeDisplayService), LanguageNames.CSharp), Shared]
     internal class CSharpStructuralTypeDisplayService : AbstractStructuralTypeDisplayService
     {
-        private static readonly SymbolDisplayFormat s_minimalWithoutContainingType =
-            s_minimalWithoutExpandedTuples.WithMemberOptions(s_minimalWithoutExpandedTuples.MemberOptions & ~SymbolDisplayMemberOptions.IncludeContainingType);
-
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
         public CSharpStructuralTypeDisplayService()
@@ -62,27 +59,5 @@ protected override ImmutableArray<SymbolDisplayPart> GetNormalAnonymousTypeParts
 
             return members.ToImmutable();
         }
-
-        protected override ImmutableArray<SymbolDisplayPart> GetDelegateAnonymousTypeParts(
-            INamedTypeSymbol anonymousType,
-            SemanticModel semanticModel,
-            int position)
-        {
-            using var _ = ArrayBuilder<SymbolDisplayPart>.GetInstance(out var parts);
-
-            parts.AddRange(anonymousType.DelegateInvokeMethod.ToMinimalDisplayParts(semanticModel, position, s_minimalWithoutContainingType));
-
-            // change the display from `bool Invoke(int x, string y)` to `bool delegate(int x, string y)`. `delegate`
-            // helps make it clear what sort of signature we're showing, and the lack of the name is appropriate as this
-            // is an anonymous delegate.
-            var namePart = parts.FirstOrNull(p => p.Kind == SymbolDisplayPartKind.MethodName && p.ToString() == anonymousType.DelegateInvokeMethod.Name);
-            if (namePart != null)
-            {
-                var index = parts.IndexOf(namePart.Value);
-                parts[index] = new SymbolDisplayPart(SymbolDisplayPartKind.Keyword, null, "delegate");
-            }
-
-            return parts.ToImmutable();
-        }
     }
 }
diff --git a/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs b/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs
index bbfd0adbb3d02..d4da8b62f3e23 100644
--- a/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs
+++ b/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs
@@ -16,14 +16,58 @@ internal abstract partial class AbstractStructuralTypeDisplayService : IStructur
         protected static readonly SymbolDisplayFormat s_minimalWithoutExpandedTuples = SymbolDisplayFormat.MinimallyQualifiedFormat.AddMiscellaneousOptions(
             SymbolDisplayMiscellaneousOptions.CollapseTupleTypes);
 
+        private static readonly SymbolDisplayFormat s_delegateDisplay =
+            s_minimalWithoutExpandedTuples.WithMemberOptions(s_minimalWithoutExpandedTuples.MemberOptions & ~SymbolDisplayMemberOptions.IncludeContainingType);
+
         protected abstract ImmutableArray<SymbolDisplayPart> GetNormalAnonymousTypeParts(INamedTypeSymbol anonymousType, SemanticModel semanticModel, int position);
-        protected abstract ImmutableArray<SymbolDisplayPart> GetDelegateAnonymousTypeParts(INamedTypeSymbol anonymousType, SemanticModel semanticModel, int position);
 
         public ImmutableArray<SymbolDisplayPart> GetAnonymousTypeParts(INamedTypeSymbol anonymousType, SemanticModel semanticModel, int position)
             => anonymousType.IsAnonymousDelegateType()
                 ? GetDelegateAnonymousTypeParts(anonymousType, semanticModel, position)
                 : GetNormalAnonymousTypeParts(anonymousType, semanticModel, position);
 
+        private ImmutableArray<SymbolDisplayPart> GetDelegateAnonymousTypeParts(
+            INamedTypeSymbol anonymousType,
+            SemanticModel semanticModel,
+            int position)
+        {
+            using var _ = ArrayBuilder<SymbolDisplayPart>.GetInstance(out var parts);
+
+            var invokeMethod = anonymousType.DelegateInvokeMethod ?? throw ExceptionUtilities.Unreachable;
+
+            parts.Add(Punctuation("<"));
+            parts.AddRange(AbstractStructuralTypeDisplayService.MassageDelegateParts(invokeMethod, invokeMethod.ToMinimalDisplayParts(
+                semanticModel, position, s_delegateDisplay)));
+            parts.Add(Punctuation(">"));
+
+            return parts.ToImmutable();
+        }
+
+        private static ImmutableArray<SymbolDisplayPart> MassageDelegateParts(
+            IMethodSymbol invokeMethod,
+            ImmutableArray<SymbolDisplayPart> parts)
+        {
+            using var _ = ArrayBuilder<SymbolDisplayPart>.GetInstance(out var result);
+
+            // Ugly hack.  Remove the "Invoke" name the compiler layer adds to the parts.
+            for (var i = 0; i < parts.Length;)
+            {
+                if (i + 1 < parts.Length &&
+                    parts[i].Kind == SymbolDisplayPartKind.Space &&
+                    Equals(invokeMethod, parts[i + 1].Symbol))
+                {
+                    i += 2;
+                }
+                else
+                {
+                    result.Add(parts[i]);
+                    i++;
+                }
+            }
+
+            return result.ToImmutable();
+        }
+
         public StructuralTypeDisplayInfo GetTypeDisplayInfo(
             ISymbol orderSymbol,
             ImmutableArray<INamedTypeSymbol> directStructuralTypeReferences,
diff --git a/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicStructuralTypeDisplayService.vb b/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicStructuralTypeDisplayService.vb
index 7dc6d68253671..1eb57da231331 100644
--- a/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicStructuralTypeDisplayService.vb
+++ b/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicStructuralTypeDisplayService.vb
@@ -10,68 +10,16 @@ Imports Microsoft.CodeAnalysis.PooledObjects
 Imports Microsoft.CodeAnalysis.VisualBasic
 
 Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.LanguageServices
-
     <Export, [Shared]>
     <ExportLanguageService(GetType(IStructuralTypeDisplayService), LanguageNames.VisualBasic)>
     Friend Class VisualBasicStructuralTypeDisplayService
         Inherits AbstractStructuralTypeDisplayService
 
-        Private Shared ReadOnly s_anonymousDelegateFormat As SymbolDisplayFormat = New SymbolDisplayFormat(
-            globalNamespaceStyle:=SymbolDisplayGlobalNamespaceStyle.Omitted,
-            genericsOptions:=SymbolDisplayGenericsOptions.IncludeTypeParameters,
-            memberOptions:=
-                SymbolDisplayMemberOptions.IncludeParameters Or
-                SymbolDisplayMemberOptions.IncludeType,
-            parameterOptions:=
-                SymbolDisplayParameterOptions.IncludeName Or
-                SymbolDisplayParameterOptions.IncludeType Or
-                SymbolDisplayParameterOptions.IncludeParamsRefOut Or
-                SymbolDisplayParameterOptions.IncludeDefaultValue,
-            miscellaneousOptions:=
-                SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers Or
-                SymbolDisplayMiscellaneousOptions.UseSpecialTypes,
-            kindOptions:=SymbolDisplayKindOptions.IncludeNamespaceKeyword Or SymbolDisplayKindOptions.IncludeTypeKeyword Or SymbolDisplayKindOptions.IncludeMemberKeyword)
-
         <ImportingConstructor>
         <Obsolete(MefConstruction.ImportingConstructorMessage, True)>
         Public Sub New()
         End Sub
 
-        Protected Overrides Function GetDelegateAnonymousTypeParts(
-                anonymousType As INamedTypeSymbol,
-                semanticModel As SemanticModel,
-                position As Integer) As ImmutableArray(Of SymbolDisplayPart)
-            Dim method = anonymousType.DelegateInvokeMethod
-
-            Dim members = ArrayBuilder(Of SymbolDisplayPart).GetInstance()
-            members.Add(Punctuation("<"))
-            members.AddRange(MassageDelegateParts(
-                method,
-                method.ToMinimalDisplayParts(semanticModel, position, s_anonymousDelegateFormat)))
-            members.Add(Punctuation(">"))
-
-            Return members.ToImmutableAndFree()
-        End Function
-
-        Private Shared Function MassageDelegateParts(delegateInvoke As IMethodSymbol,
-                                              parts As IEnumerable(Of SymbolDisplayPart)) As IEnumerable(Of SymbolDisplayPart)
-            ' So ugly.  We remove the 'Invoke' name that was added by the symbol display service.
-            Dim result = New List(Of SymbolDisplayPart)
-            For Each part In parts
-                If Equals(part.Symbol, delegateInvoke) Then
-                    Continue For
-                End If
-
-                result.Add(part)
-            Next
-
-            If result.Count >= 2 AndAlso result(1).Kind = SymbolDisplayPartKind.Space Then
-                result.RemoveAt(1)
-            End If
-
-            Return result
-        End Function
-
         Protected Overrides Function GetNormalAnonymousTypeParts(
                 anonymousType As INamedTypeSymbol,
                 semanticModel As SemanticModel,

From 985bcf612bbeabecd66a83b86c6835c82aa0f574 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 17 Jan 2022 21:22:01 -0800
Subject: [PATCH 427/444] Display using normal lang syntax.

---
 .../QuickInfo/SemanticQuickInfoSourceTests.cs          |  4 ++--
 .../QuickInfo/SemanticQuickInfoSourceTests.vb          | 10 +++++-----
 .../CSharpStructuralTypeDisplayService.cs              |  2 ++
 .../AbstractStructuralTypeDisplayService.cs            |  7 ++++---
 .../VisualBasicStructuralTypeDisplayService.vb         |  2 ++
 5 files changed, 15 insertions(+), 10 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs b/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs
index 2c9111e54300a..86fe3d08294e1 100644
--- a/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs
+++ b/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs
@@ -7946,7 +7946,7 @@ void M()
                 AnonymousTypes(
 $@"
 {FeaturesResources.Types_colon}
-    'a {FeaturesResources.is_} <string(ref int)>"));
+    'a {FeaturesResources.is_} delegate string(ref int)"));
         }
 
         [WorkItem(58871, "https://github.com/dotnet/roslyn/issues/58871")]
@@ -7968,7 +7968,7 @@ void M()
                 AnonymousTypes(
 $@"
 {FeaturesResources.Types_colon}
-    'a {FeaturesResources.is_} <string(ref int)>"));
+    'a {FeaturesResources.is_} delegate string(ref int)"));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
diff --git a/src/EditorFeatures/VisualBasicTest/QuickInfo/SemanticQuickInfoSourceTests.vb b/src/EditorFeatures/VisualBasicTest/QuickInfo/SemanticQuickInfoSourceTests.vb
index 965eec47feb6f..c3ab6331e8d64 100644
--- a/src/EditorFeatures/VisualBasicTest/QuickInfo/SemanticQuickInfoSourceTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/QuickInfo/SemanticQuickInfoSourceTests.vb
@@ -951,7 +951,7 @@ Module Program
 End Module
 ]]></Text>.NormalizedValue,
             MainDescription($"({FeaturesResources.local_variable}) a As 'a"),
-            AnonymousTypes(vbCrLf & FeaturesResources.Types_colon & vbCrLf & $"    'a {FeaturesResources.is_} <Sub()>"))
+            AnonymousTypes(vbCrLf & FeaturesResources.Types_colon & vbCrLf & $"    'a {FeaturesResources.is_} Delegate Sub()"))
         End Function
 
         <WorkItem(543624, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543624")>
@@ -968,7 +968,7 @@ Module Program
 End Module
 ]]></Text>.NormalizedValue,
             MainDescription($"({FeaturesResources.local_variable}) a As 'a"),
-            AnonymousTypes(vbCrLf & FeaturesResources.Types_colon & vbCrLf & $"    'a {FeaturesResources.is_} <Function() As Integer>"))
+            AnonymousTypes(vbCrLf & FeaturesResources.Types_colon & vbCrLf & $"    'a {FeaturesResources.is_} Delegate Function() As Integer"))
         End Function
 
         <WorkItem(543624, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543624")>
@@ -985,7 +985,7 @@ End Module
 ]]></Text>.NormalizedValue,
             MainDescription($"({FeaturesResources.local_variable}) a As 'a"),
             AnonymousTypes(vbCrLf & FeaturesResources.Types_colon & vbCrLf &
-                           $"    'a {FeaturesResources.is_} <Function() As 'b>" & vbCrLf &
+                           $"    'a {FeaturesResources.is_} Delegate Function() As 'b" & vbCrLf &
                            $"    'b {FeaturesResources.is_} New With {{ .Goo As String }}"))
         End Function
 
@@ -1004,9 +1004,9 @@ End Module
 ]]></Text>.NormalizedValue,
             MainDescription($"({FeaturesResources.local_variable}) a As 'a"),
             AnonymousTypes(vbCrLf & FeaturesResources.Types_colon & vbCrLf &
-                           $"    'a {FeaturesResources.is_} <Function(i As Integer) As 'b>" & vbCrLf &
+                           $"    'a {FeaturesResources.is_} Delegate Function(i As Integer) As 'b" & vbCrLf &
                            $"    'b {FeaturesResources.is_} New With {{ .Sq As Integer, .M As 'c }}" & vbCrLf &
-                           $"    'c {FeaturesResources.is_} <Function(j As Integer) As Integer>"))
+                           $"    'c {FeaturesResources.is_} Delegate Function(j As Integer) As Integer"))
         End Function
 
         <WorkItem(543389, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543389")>
diff --git a/src/Features/CSharp/Portable/LanguageServices/CSharpStructuralTypeDisplayService.cs b/src/Features/CSharp/Portable/LanguageServices/CSharpStructuralTypeDisplayService.cs
index 005357a5a2f97..a7713c74a4ebd 100644
--- a/src/Features/CSharp/Portable/LanguageServices/CSharpStructuralTypeDisplayService.cs
+++ b/src/Features/CSharp/Portable/LanguageServices/CSharpStructuralTypeDisplayService.cs
@@ -27,6 +27,8 @@ public CSharpStructuralTypeDisplayService()
         {
         }
 
+        protected override string DelegateKeyword => SyntaxFacts.GetText(SyntaxKind.DelegateKeyword);
+
         protected override ImmutableArray<SymbolDisplayPart> GetNormalAnonymousTypeParts(
             INamedTypeSymbol anonymousType,
             SemanticModel semanticModel,
diff --git a/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs b/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs
index d4da8b62f3e23..17f33c5d17bc4 100644
--- a/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs
+++ b/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs
@@ -19,6 +19,7 @@ internal abstract partial class AbstractStructuralTypeDisplayService : IStructur
         private static readonly SymbolDisplayFormat s_delegateDisplay =
             s_minimalWithoutExpandedTuples.WithMemberOptions(s_minimalWithoutExpandedTuples.MemberOptions & ~SymbolDisplayMemberOptions.IncludeContainingType);
 
+        protected abstract string DelegateKeyword { get; }
         protected abstract ImmutableArray<SymbolDisplayPart> GetNormalAnonymousTypeParts(INamedTypeSymbol anonymousType, SemanticModel semanticModel, int position);
 
         public ImmutableArray<SymbolDisplayPart> GetAnonymousTypeParts(INamedTypeSymbol anonymousType, SemanticModel semanticModel, int position)
@@ -35,10 +36,10 @@ private ImmutableArray<SymbolDisplayPart> GetDelegateAnonymousTypeParts(
 
             var invokeMethod = anonymousType.DelegateInvokeMethod ?? throw ExceptionUtilities.Unreachable;
 
-            parts.Add(Punctuation("<"));
-            parts.AddRange(AbstractStructuralTypeDisplayService.MassageDelegateParts(invokeMethod, invokeMethod.ToMinimalDisplayParts(
+            parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.Keyword, symbol: null, DelegateKeyword));
+            parts.AddRange(Space());
+            parts.AddRange(MassageDelegateParts(invokeMethod, invokeMethod.ToMinimalDisplayParts(
                 semanticModel, position, s_delegateDisplay)));
-            parts.Add(Punctuation(">"));
 
             return parts.ToImmutable();
         }
diff --git a/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicStructuralTypeDisplayService.vb b/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicStructuralTypeDisplayService.vb
index 1eb57da231331..b4db764218c97 100644
--- a/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicStructuralTypeDisplayService.vb
+++ b/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicStructuralTypeDisplayService.vb
@@ -20,6 +20,8 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.LanguageServices
         Public Sub New()
         End Sub
 
+        Protected Overrides ReadOnly Property DelegateKeyword As String = SyntaxFacts.GetText(SyntaxKind.DelegateKeyword)
+
         Protected Overrides Function GetNormalAnonymousTypeParts(
                 anonymousType As INamedTypeSymbol,
                 semanticModel As SemanticModel,

From c832b9ff1291d214c05ab6362d78a3c7abda9cdd Mon Sep 17 00:00:00 2001
From: CyrusNajmabadi <cyrus.najmabadi@gmail.com>
Date: Mon, 17 Jan 2022 19:24:01 -1000
Subject: [PATCH 428/444] Update
 src/Features/CSharp/Portable/LanguageServices/CSharpStructuralTypeDisplayService.cs

---
 .../LanguageServices/CSharpStructuralTypeDisplayService.cs    | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/Features/CSharp/Portable/LanguageServices/CSharpStructuralTypeDisplayService.cs b/src/Features/CSharp/Portable/LanguageServices/CSharpStructuralTypeDisplayService.cs
index a7713c74a4ebd..7e5ce3e210d33 100644
--- a/src/Features/CSharp/Portable/LanguageServices/CSharpStructuralTypeDisplayService.cs
+++ b/src/Features/CSharp/Portable/LanguageServices/CSharpStructuralTypeDisplayService.cs
@@ -30,9 +30,7 @@ public CSharpStructuralTypeDisplayService()
         protected override string DelegateKeyword => SyntaxFacts.GetText(SyntaxKind.DelegateKeyword);
 
         protected override ImmutableArray<SymbolDisplayPart> GetNormalAnonymousTypeParts(
-            INamedTypeSymbol anonymousType,
-            SemanticModel semanticModel,
-            int position)
+            INamedTypeSymbol anonymousType, SemanticModel semanticModel, int position)
         {
             using var _ = ArrayBuilder<SymbolDisplayPart>.GetInstance(out var members);
 

From c5cbf2a0b26995ecec99177f03c314353841fc75 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 17 Jan 2022 21:29:33 -0800
Subject: [PATCH 429/444] Use service

---
 .../LanguageServices/CSharpStructuralTypeDisplayService.cs   | 4 ++--
 .../AbstractStructuralTypeDisplayService.cs                  | 5 +++--
 .../VisualBasicStructuralTypeDisplayService.vb               | 3 ++-
 .../CSharp/Services/SyntaxFacts/CSharpSyntaxKinds.cs         | 1 +
 .../Compiler/Core/Services/SyntaxFacts/ISyntaxKinds.cs       | 1 +
 .../Services/SyntaxFacts/VisualBasicSyntaxKinds.vb           | 1 +
 6 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/Features/CSharp/Portable/LanguageServices/CSharpStructuralTypeDisplayService.cs b/src/Features/CSharp/Portable/LanguageServices/CSharpStructuralTypeDisplayService.cs
index a7713c74a4ebd..5d0b17f4c902e 100644
--- a/src/Features/CSharp/Portable/LanguageServices/CSharpStructuralTypeDisplayService.cs
+++ b/src/Features/CSharp/Portable/LanguageServices/CSharpStructuralTypeDisplayService.cs
@@ -10,11 +10,11 @@
 using System.Linq;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
+using Microsoft.CodeAnalysis.CSharp.LanguageServices;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.LanguageServices
 {
@@ -27,7 +27,7 @@ public CSharpStructuralTypeDisplayService()
         {
         }
 
-        protected override string DelegateKeyword => SyntaxFacts.GetText(SyntaxKind.DelegateKeyword);
+        protected override ISyntaxFacts SyntaxFactsService => CSharpSyntaxFacts.Instance;
 
         protected override ImmutableArray<SymbolDisplayPart> GetNormalAnonymousTypeParts(
             INamedTypeSymbol anonymousType,
diff --git a/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs b/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs
index 17f33c5d17bc4..0d1fe15289861 100644
--- a/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs
+++ b/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs
@@ -19,7 +19,7 @@ internal abstract partial class AbstractStructuralTypeDisplayService : IStructur
         private static readonly SymbolDisplayFormat s_delegateDisplay =
             s_minimalWithoutExpandedTuples.WithMemberOptions(s_minimalWithoutExpandedTuples.MemberOptions & ~SymbolDisplayMemberOptions.IncludeContainingType);
 
-        protected abstract string DelegateKeyword { get; }
+        protected abstract ISyntaxFacts SyntaxFactsService { get; }
         protected abstract ImmutableArray<SymbolDisplayPart> GetNormalAnonymousTypeParts(INamedTypeSymbol anonymousType, SemanticModel semanticModel, int position);
 
         public ImmutableArray<SymbolDisplayPart> GetAnonymousTypeParts(INamedTypeSymbol anonymousType, SemanticModel semanticModel, int position)
@@ -36,7 +36,8 @@ private ImmutableArray<SymbolDisplayPart> GetDelegateAnonymousTypeParts(
 
             var invokeMethod = anonymousType.DelegateInvokeMethod ?? throw ExceptionUtilities.Unreachable;
 
-            parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.Keyword, symbol: null, DelegateKeyword));
+            parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.Keyword, symbol: null,
+                SyntaxFactsService.GetText(SyntaxFactsService.SyntaxKinds.DelegateKeyword)));
             parts.AddRange(Space());
             parts.AddRange(MassageDelegateParts(invokeMethod, invokeMethod.ToMinimalDisplayParts(
                 semanticModel, position, s_delegateDisplay)));
diff --git a/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicStructuralTypeDisplayService.vb b/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicStructuralTypeDisplayService.vb
index b4db764218c97..924174b5cc078 100644
--- a/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicStructuralTypeDisplayService.vb
+++ b/src/Features/VisualBasic/Portable/LanguageServices/VisualBasicStructuralTypeDisplayService.vb
@@ -8,6 +8,7 @@ Imports Microsoft.CodeAnalysis.Host.Mef
 Imports Microsoft.CodeAnalysis.LanguageServices
 Imports Microsoft.CodeAnalysis.PooledObjects
 Imports Microsoft.CodeAnalysis.VisualBasic
+Imports Microsoft.CodeAnalysis.VisualBasic.LanguageServices
 
 Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.LanguageServices
     <Export, [Shared]>
@@ -20,7 +21,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.LanguageServices
         Public Sub New()
         End Sub
 
-        Protected Overrides ReadOnly Property DelegateKeyword As String = SyntaxFacts.GetText(SyntaxKind.DelegateKeyword)
+        Protected Overrides ReadOnly Property SyntaxFactsService As ISyntaxFacts = VisualBasicSyntaxFacts.Instance
 
         Protected Overrides Function GetNormalAnonymousTypeParts(
                 anonymousType As INamedTypeSymbol,
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxKinds.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxKinds.cs
index 66bab6009ff2d..0ffb9d80de669 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxKinds.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxKinds.cs
@@ -37,6 +37,7 @@ public TSyntaxKind Convert<TSyntaxKind>(int kind) where TSyntaxKind : struct
         public int QuestionToken => (int)SyntaxKind.QuestionToken;
         public int StringLiteralToken => (int)SyntaxKind.StringLiteralToken;
 
+        public int DelegateKeyword => (int)SyntaxKind.DelegateKeyword;
         public int IfKeyword => (int)SyntaxKind.IfKeyword;
         public int TrueKeyword => (int)SyntaxKind.TrueKeyword;
         public int FalseKeyword => (int)SyntaxKind.FalseKeyword;
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxKinds.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxKinds.cs
index b66e46deda84d..c4c612e7e7633 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxKinds.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxKinds.cs
@@ -40,6 +40,7 @@ internal interface ISyntaxKinds
 
         int AwaitKeyword { get; }
         int AsyncKeyword { get; }
+        int DelegateKeyword { get; }
         int GlobalKeyword { get; }
         int IfKeyword { get; }
         int? GlobalStatement { get; }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxKinds.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxKinds.vb
index 94ab0cd2a79dd..586bae4f9ac44 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxKinds.vb
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxKinds.vb
@@ -38,6 +38,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.LanguageServices
         Public ReadOnly Property QuestionToken As Integer = SyntaxKind.QuestionToken Implements ISyntaxKinds.QuestionToken
         Public ReadOnly Property StringLiteralToken As Integer = SyntaxKind.StringLiteralToken Implements ISyntaxKinds.StringLiteralToken
 
+        Public ReadOnly Property DelegateKeyword As Integer = SyntaxKind.DelegateKeyword Implements ISyntaxKinds.DelegateKeyword
         Public ReadOnly Property IfKeyword As Integer = SyntaxKind.IfKeyword Implements ISyntaxKinds.IfKeyword
         Public ReadOnly Property TrueKeyword As Integer = SyntaxKind.TrueKeyword Implements ISyntaxKinds.TrueKeyword
         Public ReadOnly Property FalseKeyword As Integer = SyntaxKind.FalseKeyword Implements ISyntaxKinds.FalseKeyword

From 8c36793397420d162e8f02adeb346f35ce9e2e84 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 17 Jan 2022 21:35:31 -0800
Subject: [PATCH 430/444] Simplify

---
 ...ayService.StructuralTypeCollectorVisitor.cs | 18 ++++++++++--------
 ...ypeSymbolExtensions.AnonymousTypeRemover.cs |  7 +------
 2 files changed, 11 insertions(+), 14 deletions(-)

diff --git a/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.StructuralTypeCollectorVisitor.cs b/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.StructuralTypeCollectorVisitor.cs
index 51fc6e3f90926..8d1660ba3edfd 100644
--- a/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.StructuralTypeCollectorVisitor.cs
+++ b/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.StructuralTypeCollectorVisitor.cs
@@ -80,12 +80,19 @@ public override void VisitNamedType(INamedTypeSymbol symbol)
 
                 if (_seenTypes.Add(symbol))
                 {
-                    if (symbol.IsNormalAnonymousType())
+                    if (symbol.IsAnonymousType())
                     {
                         _namedTypes.Add(symbol, (order: _namedTypes.Count, count: 1));
 
-                        foreach (var property in symbol.GetValidAnonymousTypeProperties())
-                            property.Accept(this);
+                        if (symbol.IsDelegateType())
+                        {
+                            symbol.DelegateInvokeMethod?.Accept(this);
+                        }
+                        else
+                        {
+                            foreach (var property in symbol.GetValidAnonymousTypeProperties())
+                                property.Accept(this);
+                        }
                     }
                     else if (symbol.IsTupleType)
                     {
@@ -94,11 +101,6 @@ public override void VisitNamedType(INamedTypeSymbol symbol)
                         foreach (var field in symbol.TupleElements)
                             field.Accept(this);
                     }
-                    else if (symbol.IsAnonymousDelegateType())
-                    {
-                        _namedTypes.Add(symbol, (order: _namedTypes.Count, count: 1));
-                        symbol.DelegateInvokeMethod?.Accept(this);
-                    }
                     else
                     {
                         foreach (var typeArgument in symbol.GetAllTypeArguments())
diff --git a/src/Workspaces/Core/Portable/Shared/Extensions/ITypeSymbolExtensions.AnonymousTypeRemover.cs b/src/Workspaces/Core/Portable/Shared/Extensions/ITypeSymbolExtensions.AnonymousTypeRemover.cs
index 7c2e0ef31ad4d..ced1df3aff99d 100644
--- a/src/Workspaces/Core/Portable/Shared/Extensions/ITypeSymbolExtensions.AnonymousTypeRemover.cs
+++ b/src/Workspaces/Core/Portable/Shared/Extensions/ITypeSymbolExtensions.AnonymousTypeRemover.cs
@@ -45,17 +45,12 @@ public override ITypeSymbol VisitFunctionPointerType(IFunctionPointerTypeSymbol
 
             public override ITypeSymbol VisitNamedType(INamedTypeSymbol symbol)
             {
-                if (symbol.IsNormalAnonymousType() ||
-                    symbol.IsAnonymousDelegateType())
-                {
+                if (symbol.IsAnonymousType())
                     return _compilation.ObjectType;
-                }
 
                 var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray();
                 if (arguments.SequenceEqual(symbol.TypeArguments))
-                {
                     return symbol;
-                }
 
                 return symbol.ConstructedFrom.Construct(arguments.ToArray());
             }

From fc8894e40bd4b6bdbe06f5942962d55b54690777 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 17 Jan 2022 21:41:53 -0800
Subject: [PATCH 431/444] Add test

---
 .../QuickInfo/SemanticQuickInfoSourceTests.cs    | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs b/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs
index 86fe3d08294e1..4cbbf800a5964 100644
--- a/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs
+++ b/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs
@@ -7914,6 +7914,22 @@ void M()
 TResult {FeaturesResources.is_} string"));
         }
 
+        [WorkItem(58871, "https://github.com/dotnet/roslyn/issues/58871")]
+        [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
+        public async Task TestInferredNonAnonymousDelegateType1()
+        {
+            await TestAsync(
+@"class C
+{
+    void M()
+    {
+        $$var v = (int i) => i.ToString();
+    }
+}",
+                MainDescription("delegate TResult System.Func<in T, out TResult>(T arg)"),
+                AnonymousTypes(""));
+        }
+
         [WorkItem(58871, "https://github.com/dotnet/roslyn/issues/58871")]
         [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
         public async Task TestAnonymousSynthesizedLambdaType()

From ddefca48d7c45c8763dad4cf680d67131cf5c8c2 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 17 Jan 2022 22:49:22 -0800
Subject: [PATCH 432/444] Simplify

---
 .../QuickInfo/SemanticQuickInfoSourceTests.cs     |  4 ++--
 .../QuickInfo/SemanticQuickInfoSourceTests.vb     | 10 +++++-----
 .../AbstractStructuralTypeDisplayService.cs       | 15 +++------------
 3 files changed, 10 insertions(+), 19 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs b/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs
index 4cbbf800a5964..2acc8dfd07a22 100644
--- a/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs
+++ b/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs
@@ -7962,7 +7962,7 @@ void M()
                 AnonymousTypes(
 $@"
 {FeaturesResources.Types_colon}
-    'a {FeaturesResources.is_} delegate string(ref int)"));
+    'a {FeaturesResources.is_} delegate string (ref int)"));
         }
 
         [WorkItem(58871, "https://github.com/dotnet/roslyn/issues/58871")]
@@ -7984,7 +7984,7 @@ void M()
                 AnonymousTypes(
 $@"
 {FeaturesResources.Types_colon}
-    'a {FeaturesResources.is_} delegate string(ref int)"));
+    'a {FeaturesResources.is_} delegate string (ref int)"));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.QuickInfo)]
diff --git a/src/EditorFeatures/VisualBasicTest/QuickInfo/SemanticQuickInfoSourceTests.vb b/src/EditorFeatures/VisualBasicTest/QuickInfo/SemanticQuickInfoSourceTests.vb
index c3ab6331e8d64..e6612439fb373 100644
--- a/src/EditorFeatures/VisualBasicTest/QuickInfo/SemanticQuickInfoSourceTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/QuickInfo/SemanticQuickInfoSourceTests.vb
@@ -951,7 +951,7 @@ Module Program
 End Module
 ]]></Text>.NormalizedValue,
             MainDescription($"({FeaturesResources.local_variable}) a As 'a"),
-            AnonymousTypes(vbCrLf & FeaturesResources.Types_colon & vbCrLf & $"    'a {FeaturesResources.is_} Delegate Sub()"))
+            AnonymousTypes(vbCrLf & FeaturesResources.Types_colon & vbCrLf & $"    'a {FeaturesResources.is_} Delegate Sub ()"))
         End Function
 
         <WorkItem(543624, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543624")>
@@ -968,7 +968,7 @@ Module Program
 End Module
 ]]></Text>.NormalizedValue,
             MainDescription($"({FeaturesResources.local_variable}) a As 'a"),
-            AnonymousTypes(vbCrLf & FeaturesResources.Types_colon & vbCrLf & $"    'a {FeaturesResources.is_} Delegate Function() As Integer"))
+            AnonymousTypes(vbCrLf & FeaturesResources.Types_colon & vbCrLf & $"    'a {FeaturesResources.is_} Delegate Function () As Integer"))
         End Function
 
         <WorkItem(543624, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543624")>
@@ -985,7 +985,7 @@ End Module
 ]]></Text>.NormalizedValue,
             MainDescription($"({FeaturesResources.local_variable}) a As 'a"),
             AnonymousTypes(vbCrLf & FeaturesResources.Types_colon & vbCrLf &
-                           $"    'a {FeaturesResources.is_} Delegate Function() As 'b" & vbCrLf &
+                           $"    'a {FeaturesResources.is_} Delegate Function () As 'b" & vbCrLf &
                            $"    'b {FeaturesResources.is_} New With {{ .Goo As String }}"))
         End Function
 
@@ -1004,9 +1004,9 @@ End Module
 ]]></Text>.NormalizedValue,
             MainDescription($"({FeaturesResources.local_variable}) a As 'a"),
             AnonymousTypes(vbCrLf & FeaturesResources.Types_colon & vbCrLf &
-                           $"    'a {FeaturesResources.is_} Delegate Function(i As Integer) As 'b" & vbCrLf &
+                           $"    'a {FeaturesResources.is_} Delegate Function (i As Integer) As 'b" & vbCrLf &
                            $"    'b {FeaturesResources.is_} New With {{ .Sq As Integer, .M As 'c }}" & vbCrLf &
-                           $"    'c {FeaturesResources.is_} Delegate Function(j As Integer) As Integer"))
+                           $"    'c {FeaturesResources.is_} Delegate Function (j As Integer) As Integer"))
         End Function
 
         <WorkItem(543389, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543389")>
diff --git a/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs b/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs
index 0d1fe15289861..40c5f5ea28062 100644
--- a/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs
+++ b/src/Features/Core/Portable/LanguageServices/AnonymousTypeDisplayService/AbstractStructuralTypeDisplayService.cs
@@ -52,19 +52,10 @@ private static ImmutableArray<SymbolDisplayPart> MassageDelegateParts(
             using var _ = ArrayBuilder<SymbolDisplayPart>.GetInstance(out var result);
 
             // Ugly hack.  Remove the "Invoke" name the compiler layer adds to the parts.
-            for (var i = 0; i < parts.Length;)
+            foreach (var part in parts)
             {
-                if (i + 1 < parts.Length &&
-                    parts[i].Kind == SymbolDisplayPartKind.Space &&
-                    Equals(invokeMethod, parts[i + 1].Symbol))
-                {
-                    i += 2;
-                }
-                else
-                {
-                    result.Add(parts[i]);
-                    i++;
-                }
+                if (!Equals(invokeMethod, part.Symbol))
+                    result.Add(part);
             }
 
             return result.ToImmutable();

From b74aff486ef07ee9ad2cace3c66e02dc7cb5ddb8 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Tue, 18 Jan 2022 01:34:30 -0800
Subject: [PATCH 433/444] Fix test

---
 .../CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs        | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs b/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs
index 2acc8dfd07a22..2cd00a5147754 100644
--- a/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs
+++ b/src/EditorFeatures/CSharpTest/QuickInfo/SemanticQuickInfoSourceTests.cs
@@ -7958,7 +7958,7 @@ void M()
         var $$v = (ref int i) => i.ToString();
     }
 }",
-                MainDescription("(local variable) 'a v"),
+                MainDescription($"({FeaturesResources.local_variable}) 'a v"),
                 AnonymousTypes(
 $@"
 {FeaturesResources.Types_colon}

From 50d9f8a1def6c6acb6036f804bc3665177b0e951 Mon Sep 17 00:00:00 2001
From: "dotnet-maestro[bot]"
 <42748379+dotnet-maestro[bot]@users.noreply.github.com>
Date: Tue, 18 Jan 2022 14:53:49 +0000
Subject: [PATCH 434/444] [main] Update dependencies from dotnet/arcade
 (#58879)

[main] Update dependencies from dotnet/arcade
---
 eng/Version.Details.xml | 8 ++++----
 global.json             | 4 ++--
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index 8c1126c436718..8ca96d14c6cc9 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -13,18 +13,18 @@
     </Dependency>
   </ProductDependencies>
   <ToolsetDependencies>
-    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="7.0.0-beta.22063.6">
+    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="7.0.0-beta.22067.1">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>ecf92bbdc4354adc1960fa53808e87d91624f9b5</Sha>
+      <Sha>3fb1f4bbc1f2cdd26071764132a3592eceab63fe</Sha>
       <SourceBuild RepoName="arcade" ManagedOnly="true" />
     </Dependency>
     <Dependency Name="Microsoft.Net.Compilers.Toolset" Version="4.1.0-3.22062.11">
       <Uri>https://github.com/dotnet/roslyn</Uri>
       <Sha>cc0d213b15fdda217ad888d269d19754fa556eb4</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="7.0.0-beta.22063.6">
+    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="7.0.0-beta.22067.1">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>ecf92bbdc4354adc1960fa53808e87d91624f9b5</Sha>
+      <Sha>3fb1f4bbc1f2cdd26071764132a3592eceab63fe</Sha>
     </Dependency>
   </ToolsetDependencies>
 </Dependencies>
diff --git a/global.json b/global.json
index 9464a838e0edc..84e7dcb8c1b80 100644
--- a/global.json
+++ b/global.json
@@ -12,7 +12,7 @@
     "xcopy-msbuild": "16.10.0-preview2"
   },
   "msbuild-sdks": {
-    "Microsoft.DotNet.Arcade.Sdk": "7.0.0-beta.22063.6",
-    "Microsoft.DotNet.Helix.Sdk": "7.0.0-beta.22063.6"
+    "Microsoft.DotNet.Arcade.Sdk": "7.0.0-beta.22067.1",
+    "Microsoft.DotNet.Helix.Sdk": "7.0.0-beta.22067.1"
   }
 }

From 7df7a3b54218bd6857dd553c6c0446fa2082e96a 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: Tue, 18 Jan 2022 09:44:11 -0800
Subject: [PATCH 435/444] Formatting options refactoring - step 2 (#58891)

* Propagate SyntaxFormattingOptions

* IndentationOptions

* Rename to AutoFormattingOptions

* AutoFormattingOptions.Metadata

* Move PreferredWrappingColumn option

* Move FormatOnPaste option

* AutoFormattingOptions follow-ups

* FormatOnCloseBrace

* SupportsFormattingOnTypedCharacter

* Fix test
---
 .../AutomaticBraceCompletionTests.cs          | 10 +--
 .../Formatting/FormattingEngineTests.cs       | 18 ++---
 .../Indentation/CSharpFormatterTestsBase.cs   |  3 +-
 .../SmartIndenterEnterOnTokenTests.cs         | 12 +--
 .../Indentation/SmartIndenterTests.cs         |  6 +-
 .../SmartTokenFormatterFormatRangeTests.cs    |  3 +-
 .../SplitStringLiteralCommandHandlerTests.cs  |  2 +-
 .../Wrapping/AbstractWrappingTests.cs         |  2 +-
 ...STypeScriptFormattingInteractionService.cs |  2 +-
 ...nSessionProvider.BraceCompletionSession.cs |  8 +-
 .../Formatting/FormatCommandHandler.Paste.cs  |  6 +-
 .../Formatting/FormatCommandHandler.cs        |  9 ++-
 .../Formatting/FormattingOptionsMetadata.cs   | 32 ++++++++
 .../LineCommit/CommitCommandHandler.vb        |  3 +-
 .../VisualBasic/LineCommit/CommitFormatter.vb | 33 ++++-----
 .../SmartTokenFormatter_FormatTokenTests.vb   | 13 +---
 .../AbstractParameterWrappingTests.vb         |  2 +-
 .../CurlyBraceCompletionService.cs            | 59 +++++++--------
 .../CSharpFormattingInteractionService.cs     | 43 +++++------
 .../AbstractBraceCompletionService.cs         |  6 +-
 .../BraceCompletion/BraceCompletionOptions.cs | 33 ---------
 .../IBraceCompletionService.cs                |  5 +-
 .../IFormattingInteractionService.cs          |  2 +-
 .../Wrapping/AbstractCodeActionComputer.cs    |  8 +-
 .../OnAutoInsert/OnAutoInsertHandler.cs       | 15 ++--
 .../Editor/FSharpEditorFormattingService.cs   |  2 +-
 ...RazorCSharpFormattingInteractionService.cs |  3 +-
 .../AutomationObject.BraceCompletion.cs       |  6 +-
 .../AutomationObject.Formatting.cs            | 13 ++--
 .../FormattingOptionPageControl.xaml.cs       | 12 +--
 .../Implementation/AbstractEditorFactory.cs   |  2 +-
 .../AutomationObject.Formatting.vb            |  6 +-
 .../CSharpIndentationService.Indenter.cs      |  8 +-
 .../Indentation/CSharpIndentationService.cs   |  9 +--
 .../Indentation/CSharpSmartTokenFormatter.cs  | 14 ++--
 .../Formatting/AutoFormattingOptions.cs       | 74 +++++++++++++++++++
 .../Formatting/FormattingBehaviorOptions.cs   | 72 ------------------
 .../Portable/Formatting/FormattingOptions.cs  |  4 +-
 .../AbstractIndentationService.Indenter.cs    | 15 ++--
 .../Indentation/AbstractIndentationService.cs |  7 +-
 .../Indentation/IndentationOptions.cs         | 28 +++++++
 .../CSharpSyntaxFormattingService.cs          |  4 +-
 .../Formatting/Engine/CSharpFormatEngine.cs   | 10 +--
 .../CSharpStructuredTriviaFormatEngine.cs     | 12 +--
 ...mentationCommentExteriorCommentRewriter.cs |  4 +-
 .../TriviaDataFactory.CodeShapeAnalyzer.cs    |  2 +-
 .../Trivia/TriviaDataFactory.ComplexTrivia.cs |  2 +-
 ...TriviaDataFactory.ModifiedComplexTrivia.cs |  2 +-
 .../Engine/Trivia/TriviaDataFactory.cs        |  2 +-
 .../Rules/IndentBlockFormattingRule.cs        |  5 +-
 .../Rules/IndentUserSettingsFormattingRule.cs |  5 +-
 .../Rules/NewLineUserSettingFormattingRule.cs |  5 +-
 .../Rules/QueryExpressionFormattingRule.cs    |  5 +-
 .../Formatting/Rules/SpacingFormattingRule.cs |  5 +-
 .../Rules/TokenBasedFormattingRule.cs         |  5 +-
 .../Rules/WrappingFormattingRule.cs           |  5 +-
 .../AbstractSyntaxFormattingService.cs        |  4 +-
 .../Formatting/Context/FormattingContext.cs   |  2 +-
 .../Formatting/Engine/AbstractFormatEngine.cs | 46 ++++++------
 ...TriviaDataFactory.AbstractComplexTrivia.cs |  2 +-
 ...ctTriviaDataFactory.FormattedWhitespace.cs |  2 +-
 ...actTriviaDataFactory.ModifiedWhitespace.cs |  4 +-
 .../AbstractTriviaDataFactory.Whitespace.cs   |  4 +-
 .../Engine/AbstractTriviaDataFactory.cs       |  5 +-
 .../Engine/ChainedFormattingRules.cs          |  5 +-
 .../Core/Formatting/Engine/TokenStream.cs     |  4 +-
 .../Core/Formatting/Engine/TriviaData.cs      |  5 +-
 .../Formatting/Engine/TriviaDataWithList.cs   |  2 +-
 .../Core/Formatting/FormattingOptions2.cs     | 13 ++++
 .../Formatting/ISyntaxFormattingService.cs    |  8 +-
 .../Rules/AbstractFormattingRule.cs           |  2 +-
 .../Rules/Operations/FormattingOperations.cs  | 12 +--
 .../TriviaEngine/AbstractTriviaFormatter.cs   |  2 +-
 .../Formatting/DefaultOperationProvider.vb    |  5 +-
 ...iviaDataFactory.AbstractLineBreakTrivia.vb |  2 +-
 .../TriviaDataFactory.CodeShapeAnalyzer.vb    |  2 +-
 .../Trivia/TriviaDataFactory.ComplexTrivia.vb |  2 +-
 ...riviaDataFactory.LineContinuationTrivia.vb |  2 +-
 ...TriviaDataFactory.ModifiedComplexTrivia.vb |  2 +-
 .../Engine/Trivia/TriviaDataFactory.vb        |  2 +-
 .../Engine/VisualBasicFormatEngine.vb         | 10 +--
 ...VisualBasicStructuredTriviaFormatEngine.vb |  4 +-
 .../VisualBasicSyntaxFormattingService.vb     |  4 +-
 .../VisualBasicIndentationService.Indenter.vb | 13 ++--
 .../VisualBasicIndentationService.vb          |  5 +-
 85 files changed, 447 insertions(+), 411 deletions(-)
 create mode 100644 src/EditorFeatures/Core/Implementation/Formatting/FormattingOptionsMetadata.cs
 delete mode 100644 src/Features/Core/Portable/BraceCompletion/BraceCompletionOptions.cs
 create mode 100644 src/Workspaces/Core/Portable/Formatting/AutoFormattingOptions.cs
 delete mode 100644 src/Workspaces/Core/Portable/Formatting/FormattingBehaviorOptions.cs
 create mode 100644 src/Workspaces/Core/Portable/Indentation/IndentationOptions.cs

diff --git a/src/EditorFeatures/CSharpTest/AutomaticCompletion/AutomaticBraceCompletionTests.cs b/src/EditorFeatures/CSharpTest/AutomaticCompletion/AutomaticBraceCompletionTests.cs
index 09bc5ce37966a..af3732105fdef 100644
--- a/src/EditorFeatures/CSharpTest/AutomaticCompletion/AutomaticBraceCompletionTests.cs
+++ b/src/EditorFeatures/CSharpTest/AutomaticCompletion/AutomaticBraceCompletionTests.cs
@@ -1125,8 +1125,8 @@ public void X()
 
             var optionSet = new Dictionary<OptionKey2, object>
                             {
-                                { new OptionKey2(BraceCompletionOptions.AutoFormattingOnCloseBrace, LanguageNames.CSharp), false },
-                                { new OptionKey2(FormattingBehaviorOptions.SmartIndent, LanguageNames.CSharp), FormattingOptions.IndentStyle.Block }
+                                { new OptionKey2(AutoFormattingOptions.Metadata.AutoFormattingOnCloseBrace, LanguageNames.CSharp), false },
+                                { new OptionKey2(AutoFormattingOptions.Metadata.SmartIndent, LanguageNames.CSharp), FormattingOptions.IndentStyle.Block }
                             };
             using var session = CreateSession(code, optionSet);
             Assert.NotNull(session);
@@ -1155,7 +1155,7 @@ public class C1
 
             var optionSet = new Dictionary<OptionKey2, object>
                             {
-                                { new OptionKey2(FormattingBehaviorOptions.SmartIndent, LanguageNames.CSharp), FormattingOptions.IndentStyle.None }
+                                { new OptionKey2(AutoFormattingOptions.Metadata.SmartIndent, LanguageNames.CSharp), FormattingOptions.IndentStyle.None }
                             };
             using var session = CreateSession(code, optionSet);
             Assert.NotNull(session);
@@ -1190,7 +1190,7 @@ public class C1
 
             var optionSet = new Dictionary<OptionKey2, object>
                             {
-                                { new OptionKey2(FormattingBehaviorOptions.SmartIndent, LanguageNames.CSharp), FormattingOptions.IndentStyle.Block }
+                                { new OptionKey2(AutoFormattingOptions.Metadata.SmartIndent, LanguageNames.CSharp), FormattingOptions.IndentStyle.Block }
                             };
             using var session = CreateSession(code, optionSet);
             Assert.NotNull(session);
@@ -1233,7 +1233,7 @@ public class C1
 
             var optionSet = new Dictionary<OptionKey2, object>
                             {
-                                { new OptionKey2(FormattingBehaviorOptions.SmartIndent, LanguageNames.CSharp), FormattingOptions.IndentStyle.Block }
+                                { new OptionKey2(AutoFormattingOptions.Metadata.SmartIndent, LanguageNames.CSharp), FormattingOptions.IndentStyle.Block }
                             };
             using var session = CreateSession(code, optionSet);
             Assert.NotNull(session);
diff --git a/src/EditorFeatures/CSharpTest/Formatting/FormattingEngineTests.cs b/src/EditorFeatures/CSharpTest/Formatting/FormattingEngineTests.cs
index 9405a023ae8af..f13b856096bac 100644
--- a/src/EditorFeatures/CSharpTest/Formatting/FormattingEngineTests.cs
+++ b/src/EditorFeatures/CSharpTest/Formatting/FormattingEngineTests.cs
@@ -34,9 +34,9 @@ private static Dictionary<OptionKey2, object> SmartIndentButDoNotFormatWhileTypi
         {
             return new Dictionary<OptionKey2, object>
             {
-                { new OptionKey2(FormattingBehaviorOptions.SmartIndent, LanguageNames.CSharp), FormattingOptions.IndentStyle.Smart },
-                { new OptionKey2(FormattingBehaviorOptions.AutoFormattingOnTyping, LanguageNames.CSharp),  false },
-                { new OptionKey2(BraceCompletionOptions.AutoFormattingOnCloseBrace, LanguageNames.CSharp),  false },
+                { new OptionKey2(AutoFormattingOptions.Metadata.SmartIndent, LanguageNames.CSharp), FormattingOptions.IndentStyle.Smart },
+                { new OptionKey2(AutoFormattingOptions.Metadata.AutoFormattingOnTyping, LanguageNames.CSharp),  false },
+                { new OptionKey2(AutoFormattingOptions.Metadata.AutoFormattingOnCloseBrace, LanguageNames.CSharp),  false },
             };
         }
 
@@ -1078,7 +1078,7 @@ class C1<U>
 }";
             var optionSet = new Dictionary<OptionKey2, object>
                             {
-                                { new OptionKey2(FormattingBehaviorOptions.SmartIndent, LanguageNames.CSharp), FormattingOptions.IndentStyle.None }
+                                { new OptionKey2(AutoFormattingOptions.Metadata.SmartIndent, LanguageNames.CSharp), FormattingOptions.IndentStyle.None }
                             };
             AssertFormatAfterTypeChar(code, expected, optionSet);
         }
@@ -1109,7 +1109,7 @@ class C
 
             var optionSet = new Dictionary<OptionKey2, object>
             {
-                    { new OptionKey2(BraceCompletionOptions.AutoFormattingOnCloseBrace, LanguageNames.CSharp), false }
+                    { new OptionKey2(AutoFormattingOptions.Metadata.AutoFormattingOnCloseBrace, LanguageNames.CSharp), false }
             };
 
             AssertFormatAfterTypeChar(code, expected, optionSet);
@@ -1141,7 +1141,7 @@ class C
 
             var optionSet = new Dictionary<OptionKey2, object>
             {
-                { new OptionKey2(FormattingBehaviorOptions.AutoFormattingOnTyping, LanguageNames.CSharp), false }
+                { new OptionKey2(AutoFormattingOptions.Metadata.AutoFormattingOnTyping, LanguageNames.CSharp), false }
             };
 
             AssertFormatAfterTypeChar(code, expected, optionSet);
@@ -1173,7 +1173,7 @@ static void Main()
 
             var optionSet = new Dictionary<OptionKey2, object>
             {
-                { new OptionKey2(FormattingBehaviorOptions.AutoFormattingOnTyping, LanguageNames.CSharp), false }
+                { new OptionKey2(AutoFormattingOptions.Metadata.AutoFormattingOnTyping, LanguageNames.CSharp), false }
             };
 
             AssertFormatAfterTypeChar(code, expected, optionSet);
@@ -1231,7 +1231,7 @@ class C
 
             var optionSet = new Dictionary<OptionKey2, object>
             {
-                    { new OptionKey2(FormattingBehaviorOptions.AutoFormattingOnSemicolon, LanguageNames.CSharp), false }
+                    { new OptionKey2(AutoFormattingOptions.Metadata.AutoFormattingOnSemicolon, LanguageNames.CSharp), false }
             };
 
             AssertFormatAfterTypeChar(code, expected, optionSet);
@@ -1263,7 +1263,7 @@ class C
 
             var optionSet = new Dictionary<OptionKey2, object>
             {
-                    { new OptionKey2(FormattingBehaviorOptions.AutoFormattingOnTyping, LanguageNames.CSharp), false }
+                    { new OptionKey2(AutoFormattingOptions.Metadata.AutoFormattingOnTyping, LanguageNames.CSharp), false }
             };
 
             AssertFormatAfterTypeChar(code, expected, optionSet);
diff --git a/src/EditorFeatures/CSharpTest/Formatting/Indentation/CSharpFormatterTestsBase.cs b/src/EditorFeatures/CSharpTest/Formatting/Indentation/CSharpFormatterTestsBase.cs
index a69d3d6ab615d..ab19697d14108 100644
--- a/src/EditorFeatures/CSharpTest/Formatting/Indentation/CSharpFormatterTestsBase.cs
+++ b/src/EditorFeatures/CSharpTest/Formatting/Indentation/CSharpFormatterTestsBase.cs
@@ -17,6 +17,7 @@
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Formatting.Rules;
+using Microsoft.CodeAnalysis.Indentation;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Text;
@@ -81,7 +82,7 @@ private static async Task TokenFormatWorkerAsync(TestWorkspace workspace, ITextB
 
             var rules = formattingRuleProvider.CreateRule(document, position).Concat(Formatter.GetDefaultFormattingRules(document));
 
-            var options = await document.GetOptionsAsync();
+            var options = await IndentationOptions.FromDocumentAsync(document, CancellationToken.None);
             var formatter = new CSharpSmartTokenFormatter(options, rules, root);
             var changes = await formatter.FormatTokenAsync(workspace.Services, token, CancellationToken.None);
 
diff --git a/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartIndenterEnterOnTokenTests.cs b/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartIndenterEnterOnTokenTests.cs
index 0607bbaa86c1a..c2479a5ff807f 100644
--- a/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartIndenterEnterOnTokenTests.cs
+++ b/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartIndenterEnterOnTokenTests.cs
@@ -5,11 +5,13 @@
 #nullable disable
 
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CSharp.Indentation;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Formatting;
+using Microsoft.CodeAnalysis.Indentation;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Text;
@@ -1515,12 +1517,12 @@ private static async Task AssertIndentUsingSmartTokenFormatterAsync(
 
             var root = (await document.GetSyntaxRootAsync()) as CompilationUnitSyntax;
 
-            var optionService = workspace.Services.GetRequiredService<IOptionService>();
+            var options = await IndentationOptions.FromDocumentAsync(document, CancellationToken.None);
 
             Assert.True(
                 CSharpIndentationService.ShouldUseSmartTokenFormatterInsteadOfIndenter(
                     Formatter.GetDefaultFormattingRules(document),
-                    root, line.AsTextLine(), optionService, await document.GetOptionsAsync(), out _));
+                    root, line.AsTextLine(), options, out _));
 
             var actualIndentation = await GetSmartTokenFormatterIndentationWorkerAsync(workspace, buffer, indentationLine, ch);
             Assert.Equal(expectedIndentation.Value, actualIndentation);
@@ -1546,7 +1548,7 @@ private static async Task AssertIndentNotUsingSmartTokenFormatterButUsingIndente
             // create tree service
             using var workspace = TestWorkspace.CreateCSharp(code);
             workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options
-                .WithChangedOption(FormattingBehaviorOptions.SmartIndent, LanguageNames.CSharp, indentStyle)
+                .WithChangedOption(AutoFormattingOptions.Metadata.SmartIndent, LanguageNames.CSharp, indentStyle)
                 .WithChangedOption(UseTabs, LanguageNames.CSharp, useTabs)));
             var hostdoc = workspace.Documents.First();
             var buffer = hostdoc.GetTextBuffer();
@@ -1558,12 +1560,12 @@ private static async Task AssertIndentNotUsingSmartTokenFormatterButUsingIndente
 
             var root = (await document.GetSyntaxRootAsync()) as CompilationUnitSyntax;
 
-            var optionService = workspace.Services.GetRequiredService<IOptionService>();
+            var options = await IndentationOptions.FromDocumentAsync(document, CancellationToken.None);
 
             Assert.False(
                 CSharpIndentationService.ShouldUseSmartTokenFormatterInsteadOfIndenter(
                     Formatter.GetDefaultFormattingRules(document),
-                    root, line.AsTextLine(), optionService, await document.GetOptionsAsync(), out _));
+                    root, line.AsTextLine(), options, out _));
 
             TestIndentation(workspace, indentationLine, expectedIndentation);
         }
diff --git a/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartIndenterTests.cs b/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartIndenterTests.cs
index 92cb204305c25..eaac1999653f6 100644
--- a/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartIndenterTests.cs
+++ b/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartIndenterTests.cs
@@ -3013,7 +3013,7 @@ private static void AssertSmartIndentInProjection(
                 using var workspace = TestWorkspace.CreateCSharp(markup, parseOptions: option, composition: s_compositionWithTestFormattingRules);
 
                 workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options
-                    .WithChangedOption(FormattingBehaviorOptions.SmartIndent, LanguageNames.CSharp, indentStyle)
+                    .WithChangedOption(AutoFormattingOptions.Metadata.SmartIndent, LanguageNames.CSharp, indentStyle)
                     .WithChangedOption(UseTabs, LanguageNames.CSharp, useTabs)));
                 var subjectDocument = workspace.Documents.Single();
 
@@ -3061,7 +3061,7 @@ private static void AssertSmartIndent(
                 using var workspace = TestWorkspace.CreateCSharp(code, parseOptions: option);
 
                 workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options
-                    .WithChangedOption(FormattingBehaviorOptions.SmartIndent, LanguageNames.CSharp, indentStyle)
+                    .WithChangedOption(AutoFormattingOptions.Metadata.SmartIndent, LanguageNames.CSharp, indentStyle)
                     .WithChangedOption(UseTabs, LanguageNames.CSharp, useTabs)));
                 TestIndentation(workspace, indentationLine, expectedIndentation);
             }
@@ -3093,7 +3093,7 @@ private static void AssertSmartIndent(
                 using var workspace = TestWorkspace.CreateCSharp(code, parseOptions: option);
 
                 workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options
-                    .WithChangedOption(FormattingBehaviorOptions.SmartIndent, LanguageNames.CSharp, indentStyle)
+                    .WithChangedOption(AutoFormattingOptions.Metadata.SmartIndent, LanguageNames.CSharp, indentStyle)
                     .WithChangedOption(UseTabs, LanguageNames.CSharp, useTabs)));
                 var wpfTextView = workspace.Documents.First().GetTextView();
                 var line = wpfTextView.TextBuffer.CurrentSnapshot.GetLineFromPosition(wpfTextView.Caret.Position.BufferPosition).LineNumber;
diff --git a/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartTokenFormatterFormatRangeTests.cs b/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartTokenFormatterFormatRangeTests.cs
index 335d635ebff08..06aaee0c2cf8d 100644
--- a/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartTokenFormatterFormatRangeTests.cs
+++ b/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartTokenFormatterFormatRangeTests.cs
@@ -18,6 +18,7 @@
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Formatting.Rules;
+using Microsoft.CodeAnalysis.Indentation;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Text;
@@ -3588,7 +3589,7 @@ private static async Task AutoFormatOnMarkerAsync(string initialMarkup, string e
             }
 
             Assert.Equal(tokenKind, endToken.Kind());
-            var options = await document.GetOptionsAsync();
+            var options = await IndentationOptions.FromDocumentAsync(document, CancellationToken.None);
             var formatter = new CSharpSmartTokenFormatter(options, rules, root);
 
             var tokenRange = FormattingRangeHelper.FindAppropriateRange(endToken);
diff --git a/src/EditorFeatures/CSharpTest/SplitStringLiteral/SplitStringLiteralCommandHandlerTests.cs b/src/EditorFeatures/CSharpTest/SplitStringLiteral/SplitStringLiteralCommandHandlerTests.cs
index d384a56e89863..b0bd2e9644e56 100644
--- a/src/EditorFeatures/CSharpTest/SplitStringLiteral/SplitStringLiteralCommandHandlerTests.cs
+++ b/src/EditorFeatures/CSharpTest/SplitStringLiteral/SplitStringLiteralCommandHandlerTests.cs
@@ -49,7 +49,7 @@ private static void TestWorker(
 
             // TODO: set SmartIndent to textView.Options (https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1412138)
             workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options
-                .WithChangedOption(FormattingBehaviorOptions.SmartIndent, LanguageNames.CSharp, indentStyle)));
+                .WithChangedOption(AutoFormattingOptions.Metadata.SmartIndent, LanguageNames.CSharp, indentStyle)));
 
             if (useTabs && expectedOutputMarkup != null)
             {
diff --git a/src/EditorFeatures/CSharpTest/Wrapping/AbstractWrappingTests.cs b/src/EditorFeatures/CSharpTest/Wrapping/AbstractWrappingTests.cs
index 1e80695915cf5..99210d479517f 100644
--- a/src/EditorFeatures/CSharpTest/Wrapping/AbstractWrappingTests.cs
+++ b/src/EditorFeatures/CSharpTest/Wrapping/AbstractWrappingTests.cs
@@ -21,7 +21,7 @@ protected sealed override ImmutableArray<CodeAction> MassageActions(ImmutableArr
         private protected OptionsCollection GetIndentionColumn(int column)
             => new OptionsCollection(GetLanguage())
                {
-                   { FormattingBehaviorOptions.PreferredWrappingColumn, column }
+                   { FormattingOptions2.PreferredWrappingColumn, column }
                };
 
         protected Task TestAllWrappingCasesAsync(
diff --git a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/VSTypeScriptFormattingInteractionService.cs b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/VSTypeScriptFormattingInteractionService.cs
index 6a6bb7990ca23..6326622d89390 100644
--- a/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/VSTypeScriptFormattingInteractionService.cs
+++ b/src/EditorFeatures/Core/ExternalAccess/VSTypeScript/VSTypeScriptFormattingInteractionService.cs
@@ -31,7 +31,7 @@ public VSTypeScriptFormattingInteractionService(IVSTypeScriptFormattingInteracti
         public bool SupportsFormatOnPaste => _implementation.SupportsFormatOnPaste;
         public bool SupportsFormatOnReturn => _implementation.SupportsFormatOnReturn;
 
-        public bool SupportsFormattingOnTypedCharacter(Document document, char ch)
+        public bool SupportsFormattingOnTypedCharacter(Document document, AutoFormattingOptions options, char ch)
             => _implementation.SupportsFormattingOnTypedCharacter(document, ch);
 
         public Task<ImmutableArray<TextChange>> GetFormattingChangesAsync(Document document, TextSpan? textSpan, DocumentOptionSet? documentOptions, CancellationToken cancellationToken)
diff --git a/src/EditorFeatures/Core/Implementation/AutomaticCompletion/BraceCompletionSessionProvider.BraceCompletionSession.cs b/src/EditorFeatures/Core/Implementation/AutomaticCompletion/BraceCompletionSessionProvider.BraceCompletionSession.cs
index 91cef36c28403..c9306b562bd4b 100644
--- a/src/EditorFeatures/Core/Implementation/AutomaticCompletion/BraceCompletionSessionProvider.BraceCompletionSession.cs
+++ b/src/EditorFeatures/Core/Implementation/AutomaticCompletion/BraceCompletionSessionProvider.BraceCompletionSession.cs
@@ -11,6 +11,7 @@
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.ErrorReporting;
+using Microsoft.CodeAnalysis.Indentation;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.CodeAnalysis.Text.Shared.Extensions;
 using Microsoft.VisualStudio.Text;
@@ -125,7 +126,8 @@ private bool TryStart(CancellationToken cancellationToken)
                 var contextAfterStart = GetBraceCompletionContext();
                 if (contextAfterStart != null)
                 {
-                    var changesAfterStart = _service.GetTextChangesAfterCompletionAsync(contextAfterStart.Value, cancellationToken).WaitAndGetResult(cancellationToken);
+                    var options = IndentationOptions.FromDocumentAsync(contextAfterStart.Value.Document, cancellationToken).WaitAndGetResult(cancellationToken);
+                    var changesAfterStart = _service.GetTextChangesAfterCompletionAsync(contextAfterStart.Value, options, cancellationToken).WaitAndGetResult(cancellationToken);
                     if (changesAfterStart != null)
                     {
                         ApplyBraceCompletionResult(changesAfterStart.Value);
@@ -283,8 +285,8 @@ public void PostReturn()
                             return;
                         }
 
-                        var documentOptions = context.Value.Document.GetOptionsAsync().WaitAndGetResult(CancellationToken.None);
-                        var changesAfterReturn = _service.GetTextChangeAfterReturnAsync(context.Value, documentOptions, CancellationToken.None).WaitAndGetResult(CancellationToken.None);
+                        var options = IndentationOptions.FromDocumentAsync(context.Value.Document, CancellationToken.None).WaitAndGetResult(CancellationToken.None);
+                        var changesAfterReturn = _service.GetTextChangeAfterReturnAsync(context.Value, options, CancellationToken.None).WaitAndGetResult(CancellationToken.None);
                         if (changesAfterReturn != null)
                         {
                             using var caretPreservingTransaction = new CaretPreservingEditTransaction(EditorFeaturesResources.Brace_Completion, _undoHistory, _editorOperations);
diff --git a/src/EditorFeatures/Core/Implementation/Formatting/FormatCommandHandler.Paste.cs b/src/EditorFeatures/Core/Implementation/Formatting/FormatCommandHandler.Paste.cs
index 8eacc8339465f..298369acb353b 100644
--- a/src/EditorFeatures/Core/Implementation/Formatting/FormatCommandHandler.Paste.cs
+++ b/src/EditorFeatures/Core/Implementation/Formatting/FormatCommandHandler.Paste.cs
@@ -47,7 +47,7 @@ public void ExecuteCommand(PasteCommandArgs args, Action nextHandler, CommandExe
             }
         }
 
-        private static void ExecuteCommandWorker(PasteCommandArgs args, SnapshotPoint? caretPosition, CancellationToken cancellationToken)
+        private void ExecuteCommandWorker(PasteCommandArgs args, SnapshotPoint? caretPosition, CancellationToken cancellationToken)
         {
             if (!caretPosition.HasValue)
             {
@@ -60,12 +60,12 @@ private static void ExecuteCommandWorker(PasteCommandArgs args, SnapshotPoint? c
                 return;
             }
 
-            var solution = document.Project.Solution;
-            if (!solution.Options.GetOption(FormattingBehaviorOptions.FormatOnPaste, document.Project.Language))
+            if (!_globalOptions.GetOption(FormattingOptionsMetadata.FormatOnPaste, document.Project.Language))
             {
                 return;
             }
 
+            var solution = document.Project.Solution;
             if (!solution.Workspace.CanApplyChange(ApplyChangesKind.ChangeDocument))
             {
                 return;
diff --git a/src/EditorFeatures/Core/Implementation/Formatting/FormatCommandHandler.cs b/src/EditorFeatures/Core/Implementation/Formatting/FormatCommandHandler.cs
index f1ccde5c64205..923c9468fba8c 100644
--- a/src/EditorFeatures/Core/Implementation/Formatting/FormatCommandHandler.cs
+++ b/src/EditorFeatures/Core/Implementation/Formatting/FormatCommandHandler.cs
@@ -13,6 +13,7 @@
 using Microsoft.CodeAnalysis.Formatting.Rules;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Internal.Log;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.Commanding;
@@ -42,6 +43,7 @@ internal partial class FormatCommandHandler :
     {
         private readonly ITextUndoHistoryRegistry _undoHistoryRegistry;
         private readonly IEditorOperationsFactoryService _editorOperationsFactoryService;
+        private readonly IGlobalOptionService _globalOptions;
 
         public string DisplayName => EditorFeaturesResources.Automatic_Formatting;
 
@@ -49,10 +51,12 @@ internal partial class FormatCommandHandler :
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
         public FormatCommandHandler(
             ITextUndoHistoryRegistry undoHistoryRegistry,
-            IEditorOperationsFactoryService editorOperationsFactoryService)
+            IEditorOperationsFactoryService editorOperationsFactoryService,
+            IGlobalOptionService globalOptions)
         {
             _undoHistoryRegistry = undoHistoryRegistry;
             _editorOperationsFactoryService = editorOperationsFactoryService;
+            _globalOptions = globalOptions;
         }
 
         private void Format(ITextView textView, Document document, TextSpan? selectionOpt, CancellationToken cancellationToken)
@@ -162,7 +166,8 @@ private void ExecuteReturnOrTypeCommandWorker(EditorCommandArgs args, Cancellati
             }
             else if (args is TypeCharCommandArgs typeCharArgs)
             {
-                if (!service.SupportsFormattingOnTypedCharacter(document, typeCharArgs.TypedChar))
+                var options = AutoFormattingOptions.From(document.Project);
+                if (!service.SupportsFormattingOnTypedCharacter(document, options, typeCharArgs.TypedChar))
                 {
                     return;
                 }
diff --git a/src/EditorFeatures/Core/Implementation/Formatting/FormattingOptionsMetadata.cs b/src/EditorFeatures/Core/Implementation/Formatting/FormattingOptionsMetadata.cs
new file mode 100644
index 0000000000000..9c607691ff476
--- /dev/null
+++ b/src/EditorFeatures/Core/Implementation/Formatting/FormattingOptionsMetadata.cs
@@ -0,0 +1,32 @@
+// 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.Immutable;
+using System.Composition;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Options.Providers;
+
+namespace Microsoft.CodeAnalysis.Editor.Implementation.Formatting
+{
+    [ExportSolutionOptionProvider, Shared]
+    internal sealed class FormattingOptionsMetadata : IOptionProvider
+    {
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public FormattingOptionsMetadata()
+        {
+        }
+
+        public ImmutableArray<IOption> Options { get; } = ImmutableArray.Create<IOption>(
+            FormatOnPaste);
+
+        private const string FeatureName = "FormattingOptions";
+
+        public static readonly PerLanguageOption2<bool> FormatOnPaste =
+            new(FeatureName, OptionGroup.Default, "FormatOnPaste", defaultValue: true,
+            storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.FormatOnPaste"));
+    }
+}
diff --git a/src/EditorFeatures/VisualBasic/LineCommit/CommitCommandHandler.vb b/src/EditorFeatures/VisualBasic/LineCommit/CommitCommandHandler.vb
index fbb111d29a3ff..b60982ca421d0 100644
--- a/src/EditorFeatures/VisualBasic/LineCommit/CommitCommandHandler.vb
+++ b/src/EditorFeatures/VisualBasic/LineCommit/CommitCommandHandler.vb
@@ -7,6 +7,7 @@ Imports System.Diagnostics.CodeAnalysis
 Imports System.Threading
 Imports Microsoft.CodeAnalysis
 Imports Microsoft.CodeAnalysis.Editor.Shared.Utilities
+Imports Microsoft.CodeAnalysis.Editor.Implementation.Formatting
 Imports Microsoft.CodeAnalysis.Formatting
 Imports Microsoft.CodeAnalysis.Formatting.Rules
 Imports Microsoft.CodeAnalysis.Options
@@ -233,7 +234,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.LineCommit
                 ' Do the paste in the same transaction as the commit/format
                 nextHandler()
 
-                If Not _globalOptions.GetOption(FormattingBehaviorOptions.FormatOnPaste, LanguageNames.VisualBasic) Then
+                If Not _globalOptions.GetOption(FormattingOptionsMetadata.FormatOnPaste, LanguageNames.VisualBasic) Then
                     transaction.Complete()
                     Return
                 End If
diff --git a/src/EditorFeatures/VisualBasic/LineCommit/CommitFormatter.vb b/src/EditorFeatures/VisualBasic/LineCommit/CommitFormatter.vb
index 33467f212507f..66d92f0a3fde4 100644
--- a/src/EditorFeatures/VisualBasic/LineCommit/CommitFormatter.vb
+++ b/src/EditorFeatures/VisualBasic/LineCommit/CommitFormatter.vb
@@ -71,9 +71,10 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.LineCommit
                 ' create commit formatting cleanup provider that has line commit specific behavior
                 Dim inferredIndentationService = document.Project.Solution.Workspace.Services.GetRequiredService(Of IInferredIndentationService)()
                 Dim documentOptions = inferredIndentationService.GetDocumentOptionsWithInferredIndentationAsync(document, isExplicitFormat, cancellationToken).WaitAndGetResult(cancellationToken)
+                Dim formattingOptions = SyntaxFormattingOptions.Create(documentOptions, document.Project.Solution.Workspace.Services, document.Project.Language)
                 Dim commitFormattingCleanup = GetCommitFormattingCleanupProvider(
                                                 document,
-                                                documentOptions,
+                                                formattingOptions,
                                                 spanToFormat,
                                                 baseSnapshot, baseTree,
                                                 dirtyRegion,
@@ -130,7 +131,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.LineCommit
 
         Private Shared Function GetCommitFormattingCleanupProvider(
             document As Document,
-            documentOptions As DocumentOptionSet,
+            options As SyntaxFormattingOptions,
             spanToFormat As SnapshotSpan,
             oldSnapshot As ITextSnapshot,
             oldTree As SyntaxTree,
@@ -141,14 +142,14 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.LineCommit
             Dim oldDirtySpan = newDirtySpan.TranslateTo(oldSnapshot, SpanTrackingMode.EdgeInclusive)
 
             ' based on changes made to dirty spans, get right formatting rules to apply
-            Dim rules = GetFormattingRules(document, documentOptions, spanToFormat, oldDirtySpan, oldTree, newDirtySpan, newTree, cancellationToken)
+            Dim rules = GetFormattingRules(document, options, spanToFormat, oldDirtySpan, oldTree, newDirtySpan, newTree, cancellationToken)
 
             Return New FormatCodeCleanupProvider(rules)
         End Function
 
         Private Shared Function GetFormattingRules(
             document As Document,
-            documentOptions As DocumentOptionSet,
+            options As SyntaxFormattingOptions,
             spanToFormat As SnapshotSpan,
             oldDirtySpan As SnapshotSpan,
             oldTree As SyntaxTree,
@@ -200,32 +201,30 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.LineCommit
             ' for now, do very simple checking. basically, we see whether we get same number of indent operation for the give span. alternative, but little bit
             ' more expensive and complex, we can actually calculate indentation right after the span, and see whether that is changed. not sure whether that much granularity
             ' is needed.
-            If GetNumberOfIndentOperations(document, documentOptions, oldTree, oldDirtySpan, cancellationToken) =
-               GetNumberOfIndentOperations(document, documentOptions, newTree, newDirtySpan, cancellationToken) Then
+            If GetNumberOfIndentOperations(document, options, oldTree, oldDirtySpan, cancellationToken) =
+               GetNumberOfIndentOperations(document, options, newTree, newDirtySpan, cancellationToken) Then
                 Return (New NoAnchorFormatterRule()).Concat(Formatter.GetDefaultFormattingRules(document))
             End If
 
             Return Formatter.GetDefaultFormattingRules(document)
         End Function
 
-        Private Shared Function GetNumberOfIndentOperations(document As Document,
-                                                     documentOptions As DocumentOptionSet,
-                                                     SyntaxTree As SyntaxTree,
-                                                     Span As SnapshotSpan,
-                                                     CancellationToken As CancellationToken) As Integer
+        Private Shared Function GetNumberOfIndentOperations(
+            document As Document,
+            options As SyntaxFormattingOptions,
+            syntaxTree As SyntaxTree,
+            span As SnapshotSpan,
+            cancellationToken As CancellationToken) As Integer
 
             ' find containing statement of the end point, and use its end point as position to get indent operation
-            Dim containingStatement = ContainingStatementInfo.GetInfo(Span.End, SyntaxTree, CancellationToken)
-            Dim endPosition = If(containingStatement Is Nothing, Span.End.Position + 1, containingStatement.TextSpan.End + 1)
+            Dim containingStatement = ContainingStatementInfo.GetInfo(span.End, syntaxTree, cancellationToken)
+            Dim endPosition = If(containingStatement Is Nothing, span.End.Position + 1, containingStatement.TextSpan.End + 1)
 
             ' get token right after given span
-            Dim token = SyntaxTree.GetRoot(CancellationToken).FindToken(Math.Min(endPosition, SyntaxTree.GetRoot(CancellationToken).FullSpan.End))
+            Dim token = syntaxTree.GetRoot(cancellationToken).FindToken(Math.Min(endPosition, syntaxTree.GetRoot(cancellationToken).FullSpan.End))
 
             Dim node = token.Parent
 
-            Dim optionService = document.Project.Solution.Workspace.Services.GetRequiredService(Of IOptionService)()
-            Dim options = documentOptions.AsAnalyzerConfigOptions(optionService, node?.Language)
-
             ' collect all indent operation
             Dim operations = New List(Of IndentBlockOperation)()
             While node IsNot Nothing
diff --git a/src/EditorFeatures/VisualBasicTest/Formatting/Indentation/SmartTokenFormatter_FormatTokenTests.vb b/src/EditorFeatures/VisualBasicTest/Formatting/Indentation/SmartTokenFormatter_FormatTokenTests.vb
index e2502f5158345..82ed93b5b91c6 100644
--- a/src/EditorFeatures/VisualBasicTest/Formatting/Indentation/SmartTokenFormatter_FormatTokenTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/Formatting/Indentation/SmartTokenFormatter_FormatTokenTests.vb
@@ -179,9 +179,6 @@ End Class
             MarkupTestFile.GetPosition(codeWithMarkup, code, position)
 
             Using workspace = TestWorkspace.CreateVisualBasic(code)
-                workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options _
-                    .WithChangedOption(FormattingOptions.SmartIndent, LanguageNames.VisualBasic, indentStyle)))
-
                 Dim hostdoc = workspace.Documents.First()
                 Dim buffer = hostdoc.GetTextBuffer()
 
@@ -190,10 +187,9 @@ End Class
 
                 Dim document = workspace.CurrentSolution.GetDocument(hostdoc.Id)
                 Dim root = DirectCast(Await document.GetSyntaxRootAsync(), CompilationUnitSyntax)
-                Dim options = Await document.GetOptionsAsync()
-                Dim documentIndentStyle = options.GetOption(FormattingOptions.SmartIndent, root.Language)
+                Dim options = Await SyntaxFormattingOptions.FromDocumentAsync(document, CancellationToken.None)
 
-                Dim formattingRules = New SpecialFormattingRule(documentIndentStyle).Concat(Formatter.GetDefaultFormattingRules(document))
+                Dim formattingRules = New SpecialFormattingRule(indentStyle).Concat(Formatter.GetDefaultFormattingRules(document))
 
                 ' get token
                 Dim token = root.FindToken(position)
@@ -201,11 +197,8 @@ End Class
                 Dim previousToken = token.GetPreviousToken(includeZeroWidth:=True)
                 Dim ignoreMissingToken = previousToken.IsMissing AndAlso line.Start.Position = position
 
-                Dim optionService = workspace.Services.GetRequiredService(Of IOptionService)()
-
                 Assert.True(VisualBasicIndentationService.ShouldUseSmartTokenFormatterInsteadOfIndenter(
-                            formattingRules, root, line.AsTextLine, optionService, workspace.Options,
-                            Nothing, ignoreMissingToken))
+                            formattingRules, root, line.AsTextLine, options, Nothing, ignoreMissingToken))
 
                 Dim formatOptions = Await SyntaxFormattingOptions.FromDocumentAsync(document, CancellationToken.None)
                 Dim smartFormatter = New VisualBasicSmartTokenFormatter(formatOptions, formattingRules, root)
diff --git a/src/EditorFeatures/VisualBasicTest/Wrapping/AbstractParameterWrappingTests.vb b/src/EditorFeatures/VisualBasicTest/Wrapping/AbstractParameterWrappingTests.vb
index 82ff01038ae49..71869c016604f 100644
--- a/src/EditorFeatures/VisualBasicTest/Wrapping/AbstractParameterWrappingTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/Wrapping/AbstractParameterWrappingTests.vb
@@ -18,7 +18,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Wrapping
 
         Private Protected Function GetIndentionColumn(column As Integer) As OptionsCollection
             Return New OptionsCollection(GetLanguage()) From {
-                   {FormattingBehaviorOptions.PreferredWrappingColumn, column}
+                   {FormattingOptions2.PreferredWrappingColumn, column}
                }
         End Function
 
diff --git a/src/Features/CSharp/Portable/BraceCompletion/CurlyBraceCompletionService.cs b/src/Features/CSharp/Portable/BraceCompletion/CurlyBraceCompletionService.cs
index c6f03c8f89987..9386280a44803 100644
--- a/src/Features/CSharp/Portable/BraceCompletion/CurlyBraceCompletionService.cs
+++ b/src/Features/CSharp/Portable/BraceCompletion/CurlyBraceCompletionService.cs
@@ -49,23 +49,26 @@ public CurlyBraceCompletionService()
         public override Task<bool> AllowOverTypeAsync(BraceCompletionContext context, CancellationToken cancellationToken)
             => AllowOverTypeInUserCodeWithValidClosingTokenAsync(context, cancellationToken);
 
-        public override async Task<BraceCompletionResult?> GetTextChangesAfterCompletionAsync(BraceCompletionContext braceCompletionContext, CancellationToken cancellationToken)
+        public override async Task<BraceCompletionResult?> GetTextChangesAfterCompletionAsync(BraceCompletionContext context, IndentationOptions options, CancellationToken cancellationToken)
         {
-            var documentOptions = await braceCompletionContext.Document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
-
             // After the closing brace is completed we need to format the span from the opening point to the closing point.
             // E.g. when the user triggers completion for an if statement ($$ is the caret location) we insert braces to get
             // if (true){$$}
             // We then need to format this to
             // if (true) { $$}
+
+            if (!options.AutoFormattingOptions.FormatOnCloseBrace)
+            {
+                return null;
+            }
+
             var (formattingChanges, finalCurlyBraceEnd) = await FormatTrackingSpanAsync(
-                braceCompletionContext.Document,
-                braceCompletionContext.OpeningPoint,
-                braceCompletionContext.ClosingPoint,
-                shouldHonorAutoFormattingOnCloseBraceOption: true,
+                context.Document,
+                context.OpeningPoint,
+                context.ClosingPoint,
                 // We're not trying to format the indented block here, so no need to pass in additional rules.
                 braceFormattingIndentationRules: ImmutableArray<AbstractFormattingRule>.Empty,
-                documentOptions,
+                options,
                 cancellationToken).ConfigureAwait(false);
 
             if (formattingChanges.IsEmpty)
@@ -74,7 +77,7 @@ public override Task<bool> AllowOverTypeAsync(BraceCompletionContext context, Ca
             }
 
             // The caret location should be at the start of the closing brace character.
-            var originalText = await braceCompletionContext.Document.GetTextAsync(cancellationToken).ConfigureAwait(false);
+            var originalText = await context.Document.GetTextAsync(cancellationToken).ConfigureAwait(false);
             var formattedText = originalText.WithChanges(formattingChanges);
             var caretLocation = formattedText.Lines.GetLinePosition(finalCurlyBraceEnd - 1);
 
@@ -83,7 +86,7 @@ public override Task<bool> AllowOverTypeAsync(BraceCompletionContext context, Ca
 
         public override async Task<BraceCompletionResult?> GetTextChangeAfterReturnAsync(
             BraceCompletionContext context,
-            DocumentOptionSet documentOptions,
+            IndentationOptions options,
             CancellationToken cancellationToken)
         {
             var document = context.Document;
@@ -113,7 +116,7 @@ public override Task<bool> AllowOverTypeAsync(BraceCompletionContext context, Ca
             var textToFormat = originalDocumentText;
             if (closingPointLine - openingPointLine == 1)
             {
-                var newLineString = documentOptions.GetOption(FormattingOptions2.NewLine);
+                var newLineString = options.FormattingOptions.GetOption(FormattingOptions2.NewLine);
                 newLineEdit = new TextChange(new TextSpan(closingPoint - 1, 0), newLineString);
                 textToFormat = originalDocumentText.WithChanges(newLineEdit.Value);
 
@@ -121,15 +124,18 @@ public override Task<bool> AllowOverTypeAsync(BraceCompletionContext context, Ca
                 closingPoint += newLineString.Length;
             }
 
+            var braceFormattingIndentationRules = ImmutableArray.Create(
+                BraceCompletionFormattingRule.ForIndentStyle(options.AutoFormattingOptions.IndentStyle));
+
             // Format the text that contains the newly inserted line.
             var (formattingChanges, newClosingPoint) = await FormatTrackingSpanAsync(
                 document.WithText(textToFormat),
                 openingPoint,
                 closingPoint,
-                shouldHonorAutoFormattingOnCloseBraceOption: false,
-                braceFormattingIndentationRules: GetBraceIndentationFormattingRules(documentOptions),
-                documentOptions,
+                braceFormattingIndentationRules,
+                options,
                 cancellationToken).ConfigureAwait(false);
+
             closingPoint = newClosingPoint;
             var formattedText = textToFormat.WithChanges(formattingChanges);
 
@@ -237,17 +243,10 @@ private static bool ContainsOnlyWhitespace(SourceText text, int openingPosition,
             Document document,
             int openingPoint,
             int closingPoint,
-            bool shouldHonorAutoFormattingOnCloseBraceOption,
             ImmutableArray<AbstractFormattingRule> braceFormattingIndentationRules,
-            DocumentOptionSet documentOptions,
+            IndentationOptions options,
             CancellationToken cancellationToken)
         {
-            var option = document.Project.Solution.Options.GetOption(BraceCompletionOptions.AutoFormattingOnCloseBrace, document.Project.Language);
-            if (!option && shouldHonorAutoFormattingOnCloseBraceOption)
-            {
-                return (ImmutableArray<TextChange>.Empty, closingPoint);
-            }
-
             // Annotate the original closing brace so we can find it after formatting.
             document = await GetDocumentWithAnnotatedClosingBraceAsync(document, closingPoint, cancellationToken).ConfigureAwait(false);
 
@@ -275,8 +274,7 @@ private static bool ContainsOnlyWhitespace(SourceText text, int openingPosition,
                 }
             }
 
-            var style = documentOptions.GetOption(FormattingOptions.SmartIndent);
-            if (style == FormattingOptions.IndentStyle.Smart)
+            if (options.AutoFormattingOptions.IndentStyle == FormattingOptions.IndentStyle.Smart)
             {
                 // Set the formatting start point to be the beginning of the first word to the left 
                 // of the opening brace location.
@@ -297,9 +295,8 @@ private static bool ContainsOnlyWhitespace(SourceText text, int openingPosition,
             var spanToFormat = TextSpan.FromBounds(Math.Max(startPoint, 0), endPoint);
             var rules = document.GetFormattingRules(spanToFormat, braceFormattingIndentationRules);
             var services = document.Project.Solution.Workspace.Services;
-            var formattingOptions = SyntaxFormattingOptions.Create(documentOptions, services, document.Project.Language);
             var result = Formatter.GetFormattingResult(
-                root, SpecializedCollections.SingletonEnumerable(spanToFormat), services, formattingOptions, rules, cancellationToken);
+                root, SpecializedCollections.SingletonEnumerable(spanToFormat), services, options.FormattingOptions, rules, cancellationToken);
             if (result == null)
             {
                 return (ImmutableArray<TextChange>.Empty, closingPoint);
@@ -323,12 +320,6 @@ static async Task<Document> GetDocumentWithAnnotatedClosingBraceAsync(Document d
             }
         }
 
-        private static ImmutableArray<AbstractFormattingRule> GetBraceIndentationFormattingRules(DocumentOptionSet documentOptions)
-        {
-            var indentStyle = documentOptions.GetOption(FormattingOptions.SmartIndent);
-            return ImmutableArray.Create(BraceCompletionFormattingRule.ForIndentStyle(indentStyle));
-        }
-
         private sealed class BraceCompletionFormattingRule : BaseFormattingRule
         {
             private static readonly Predicate<SuppressOperation> s_predicate = o => o == null || o.Option.IsOn(SuppressOption.NoWrapping);
@@ -358,9 +349,9 @@ public static AbstractFormattingRule ForIndentStyle(FormattingOptions.IndentStyl
                 return s_instances[(int)indentStyle];
             }
 
-            public override AbstractFormattingRule WithOptions(AnalyzerConfigOptions options)
+            public override AbstractFormattingRule WithOptions(SyntaxFormattingOptions options)
             {
-                var cachedOptions = new CachedOptions(options);
+                var cachedOptions = new CachedOptions(options.Options);
 
                 if (cachedOptions == _options)
                 {
diff --git a/src/Features/CSharp/Portable/Formatting/CSharpFormattingInteractionService.cs b/src/Features/CSharp/Portable/Formatting/CSharpFormattingInteractionService.cs
index 205f41e2e3885..5f292e5ad6d07 100644
--- a/src/Features/CSharp/Portable/Formatting/CSharpFormattingInteractionService.cs
+++ b/src/Features/CSharp/Portable/Formatting/CSharpFormattingInteractionService.cs
@@ -44,15 +44,9 @@ public CSharpFormattingInteractionService()
         public bool SupportsFormatSelection => true;
         public bool SupportsFormatOnReturn => false;
 
-        public bool SupportsFormattingOnTypedCharacter(Document document, char ch)
+        public bool SupportsFormattingOnTypedCharacter(Document document, AutoFormattingOptions options, char ch)
         {
-            // Performance: This method checks several options to determine if we should do smart
-            // indent, none of which are controlled by editorconfig. Instead of calling 
-            // document.GetOptionsAsync we can use the Workspace's global options and thus save the
-            // work of attempting to read in the editorconfig file.
-            var options = document.Project.Solution.Workspace.Options;
-
-            var smartIndentOn = options.GetOption(FormattingOptions.SmartIndent, LanguageNames.CSharp) == FormattingOptions.IndentStyle.Smart;
+            var smartIndentOn = options.IndentStyle == FormattingOptions.IndentStyle.Smart;
 
             // We consider the proper placement of a close curly or open curly when it is typed at
             // the start of the line to be a smart-indentation operation.  As such, even if "format
@@ -69,18 +63,18 @@ public bool SupportsFormattingOnTypedCharacter(Document document, char ch)
             }
 
             // If format-on-typing is not on, then we don't support formatting on any other characters.
-            var autoFormattingOnTyping = options.GetOption(FormattingBehaviorOptions.AutoFormattingOnTyping, LanguageNames.CSharp);
+            var autoFormattingOnTyping = options.FormatOnTyping;
             if (!autoFormattingOnTyping)
             {
                 return false;
             }
 
-            if (ch == '}' && !options.GetOption(BraceCompletionOptions.AutoFormattingOnCloseBrace, LanguageNames.CSharp))
+            if (ch == '}' && !options.FormatOnCloseBrace)
             {
                 return false;
             }
 
-            if (ch == ';' && !options.GetOption(FormattingBehaviorOptions.AutoFormattingOnSemicolon, LanguageNames.CSharp))
+            if (ch == ';' && !options.FormatOnSemicolon)
             {
                 return false;
             }
@@ -222,6 +216,8 @@ public async Task<ImmutableArray<TextChange>> GetFormattingChangesAsync(
                 documentOptions = await inferredIndentationService.GetDocumentOptionsWithInferredIndentationAsync(document, explicitFormat: false, cancellationToken: cancellationToken).ConfigureAwait(false);
             }
 
+            var options = IndentationOptions.From(documentOptions, document.Project.Solution.Workspace.Services, document.Project.Language);
+
             // Do not attempt to format on open/close brace if autoformat on close brace feature is
             // off, instead just smart indent.
             //
@@ -251,42 +247,41 @@ public async Task<ImmutableArray<TextChange>> GetFormattingChangesAsync(
             // However, we won't touch any of the other code in that block, unlike if we were
             // formatting.
             var onlySmartIndent =
-                (token.IsKind(SyntaxKind.CloseBraceToken) && OnlySmartIndentCloseBrace(documentOptions)) ||
-                (token.IsKind(SyntaxKind.OpenBraceToken) && OnlySmartIndentOpenBrace(documentOptions));
+                (token.IsKind(SyntaxKind.CloseBraceToken) && OnlySmartIndentCloseBrace(options.AutoFormattingOptions)) ||
+                (token.IsKind(SyntaxKind.OpenBraceToken) && OnlySmartIndentOpenBrace(options.AutoFormattingOptions));
 
             if (onlySmartIndent)
             {
                 // if we're only doing smart indent, then ignore all edits to this token that occur before
                 // the span of the token. They're irrelevant and may screw up other code the user doesn't 
                 // want touched.
-                var tokenEdits = await FormatTokenAsync(document, documentOptions, token, formattingRules, cancellationToken).ConfigureAwait(false);
+                var tokenEdits = await FormatTokenAsync(document, options, token, formattingRules, cancellationToken).ConfigureAwait(false);
                 return tokenEdits.Where(t => t.Span.Start >= token.FullSpan.Start).ToImmutableArray();
             }
 
             // if formatting range fails, do format token one at least
-            var changes = await FormatRangeAsync(document, documentOptions, token, formattingRules, cancellationToken).ConfigureAwait(false);
+            var changes = await FormatRangeAsync(document, options, token, formattingRules, cancellationToken).ConfigureAwait(false);
             if (changes.Length > 0)
             {
                 return changes;
             }
 
-            return (await FormatTokenAsync(document, documentOptions, token, formattingRules, cancellationToken).ConfigureAwait(false)).ToImmutableArray();
+            return (await FormatTokenAsync(document, options, token, formattingRules, cancellationToken).ConfigureAwait(false)).ToImmutableArray();
         }
 
-        private static bool OnlySmartIndentCloseBrace(DocumentOptionSet options)
+        private static bool OnlySmartIndentCloseBrace(in AutoFormattingOptions options)
         {
             // User does not want auto-formatting (either in general, or for close braces in
             // specific).  So we only smart indent close braces when typed.
-            return !options.GetOption(BraceCompletionOptions.AutoFormattingOnCloseBrace) ||
-                   !options.GetOption(FormattingBehaviorOptions.AutoFormattingOnTyping);
+            return !options.FormatOnCloseBrace || !options.FormatOnTyping;
         }
 
-        private static bool OnlySmartIndentOpenBrace(DocumentOptionSet options)
+        private static bool OnlySmartIndentOpenBrace(in AutoFormattingOptions options)
         {
             // User does not want auto-formatting .  So we only smart indent open braces when typed.
             // Note: there is no specific option for controlling formatting on open brace.  So we
             // don't have the symmetry with OnlySmartIndentCloseBrace.
-            return !options.GetOption(FormattingBehaviorOptions.AutoFormattingOnTyping);
+            return !options.FormatOnTyping;
         }
 
         private static async Task<SyntaxToken> GetTokenBeforeTheCaretAsync(Document document, int caretPosition, CancellationToken cancellationToken)
@@ -299,7 +294,7 @@ private static async Task<SyntaxToken> GetTokenBeforeTheCaretAsync(Document docu
             return token;
         }
 
-        private static async Task<IList<TextChange>> FormatTokenAsync(Document document, OptionSet options, SyntaxToken token, IEnumerable<AbstractFormattingRule> formattingRules, CancellationToken cancellationToken)
+        private static async Task<IList<TextChange>> FormatTokenAsync(Document document, IndentationOptions options, SyntaxToken token, IEnumerable<AbstractFormattingRule> formattingRules, CancellationToken cancellationToken)
         {
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             var formatter = CreateSmartTokenFormatter(options, formattingRules, root);
@@ -307,12 +302,12 @@ private static async Task<IList<TextChange>> FormatTokenAsync(Document document,
             return changes;
         }
 
-        private static ISmartTokenFormatter CreateSmartTokenFormatter(OptionSet options, IEnumerable<AbstractFormattingRule> formattingRules, SyntaxNode root)
+        private static ISmartTokenFormatter CreateSmartTokenFormatter(IndentationOptions options, IEnumerable<AbstractFormattingRule> formattingRules, SyntaxNode root)
             => new CSharpSmartTokenFormatter(options, formattingRules, (CompilationUnitSyntax)root);
 
         private static async Task<ImmutableArray<TextChange>> FormatRangeAsync(
             Document document,
-            OptionSet options,
+            IndentationOptions options,
             SyntaxToken endToken,
             IEnumerable<AbstractFormattingRule> formattingRules,
             CancellationToken cancellationToken)
diff --git a/src/Features/Core/Portable/BraceCompletion/AbstractBraceCompletionService.cs b/src/Features/Core/Portable/BraceCompletion/AbstractBraceCompletionService.cs
index 09111582b3e4b..29526a6201f06 100644
--- a/src/Features/Core/Portable/BraceCompletion/AbstractBraceCompletionService.cs
+++ b/src/Features/Core/Portable/BraceCompletion/AbstractBraceCompletionService.cs
@@ -5,8 +5,8 @@
 using System.Collections.Immutable;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Indentation;
 using Microsoft.CodeAnalysis.LanguageServices;
-using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
@@ -63,10 +63,10 @@ internal abstract class AbstractBraceCompletionService : IBraceCompletionService
             return new BraceCompletionResult(ImmutableArray.Create(braceTextEdit), caretLocation);
         }
 
-        public virtual Task<BraceCompletionResult?> GetTextChangesAfterCompletionAsync(BraceCompletionContext braceCompletionContext, CancellationToken cancellationToken)
+        public virtual Task<BraceCompletionResult?> GetTextChangesAfterCompletionAsync(BraceCompletionContext braceCompletionContext, IndentationOptions options, CancellationToken cancellationToken)
             => SpecializedTasks.Default<BraceCompletionResult?>();
 
-        public virtual Task<BraceCompletionResult?> GetTextChangeAfterReturnAsync(BraceCompletionContext braceCompletionContext, DocumentOptionSet documentOptions, CancellationToken cancellationToken)
+        public virtual Task<BraceCompletionResult?> GetTextChangeAfterReturnAsync(BraceCompletionContext braceCompletionContext, IndentationOptions options, CancellationToken cancellationToken)
             => SpecializedTasks.Default<BraceCompletionResult?>();
 
         public virtual async Task<bool> CanProvideBraceCompletionAsync(char brace, int openingPosition, Document document, CancellationToken cancellationToken)
diff --git a/src/Features/Core/Portable/BraceCompletion/BraceCompletionOptions.cs b/src/Features/Core/Portable/BraceCompletion/BraceCompletionOptions.cs
deleted file mode 100644
index 15801380d8d2b..0000000000000
--- a/src/Features/Core/Portable/BraceCompletion/BraceCompletionOptions.cs
+++ /dev/null
@@ -1,33 +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.Immutable;
-using System.Composition;
-using Microsoft.CodeAnalysis.Host.Mef;
-using Microsoft.CodeAnalysis.Options;
-using Microsoft.CodeAnalysis.Options.Providers;
-
-namespace Microsoft.CodeAnalysis.BraceCompletion
-{
-    internal class BraceCompletionOptions
-    {
-        public static readonly PerLanguageOption2<bool> AutoFormattingOnCloseBrace = new(
-            nameof(BraceCompletionOptions), nameof(AutoFormattingOnCloseBrace), defaultValue: true,
-            storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.Auto Formatting On Close Brace"));
-
-        [ExportSolutionOptionProvider, Shared]
-        internal class BraceCompletionOptionsProvider : IOptionProvider
-        {
-            [ImportingConstructor]
-            [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-            public BraceCompletionOptionsProvider()
-            {
-            }
-
-            public ImmutableArray<IOption> Options { get; } = ImmutableArray.Create<IOption>(
-                AutoFormattingOnCloseBrace);
-        }
-    }
-}
diff --git a/src/Features/Core/Portable/BraceCompletion/IBraceCompletionService.cs b/src/Features/Core/Portable/BraceCompletion/IBraceCompletionService.cs
index 008fd586cf58a..0da69a7acabd7 100644
--- a/src/Features/Core/Portable/BraceCompletion/IBraceCompletionService.cs
+++ b/src/Features/Core/Portable/BraceCompletion/IBraceCompletionService.cs
@@ -6,6 +6,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Indentation;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Text;
 
@@ -45,12 +46,12 @@ internal interface IBraceCompletionService : ILanguageService
         /// in BraceCompletionSessionProvider.BraceCompletionSession.Start after completing the brace and before
         /// doing any kind of formatting on it.  So these must be two distinct steps until we fully move to LSP.
         /// </remarks>
-        Task<BraceCompletionResult?> GetTextChangesAfterCompletionAsync(BraceCompletionContext braceCompletionContext, CancellationToken cancellationToken);
+        Task<BraceCompletionResult?> GetTextChangesAfterCompletionAsync(BraceCompletionContext braceCompletionContext, IndentationOptions options, CancellationToken cancellationToken);
 
         /// <summary>
         /// Get any text changes that should be applied after the enter key is typed inside a brace completion context.
         /// </summary>
-        Task<BraceCompletionResult?> GetTextChangeAfterReturnAsync(BraceCompletionContext braceCompletionContext, DocumentOptionSet documentOptions, CancellationToken cancellationToken);
+        Task<BraceCompletionResult?> GetTextChangeAfterReturnAsync(BraceCompletionContext braceCompletionContext, IndentationOptions options, CancellationToken cancellationToken);
 
         /// <summary>
         /// Returns the brace completion context if the caret is located between an already completed
diff --git a/src/Features/Core/Portable/Formatting/IFormattingInteractionService.cs b/src/Features/Core/Portable/Formatting/IFormattingInteractionService.cs
index 5b9880cab2767..84296fa0cb7c2 100644
--- a/src/Features/Core/Portable/Formatting/IFormattingInteractionService.cs
+++ b/src/Features/Core/Portable/Formatting/IFormattingInteractionService.cs
@@ -22,7 +22,7 @@ internal interface IFormattingInteractionService : ILanguageService
         /// True if this service would like to format the document based on the user typing the
         /// provided character.
         /// </summary>
-        bool SupportsFormattingOnTypedCharacter(Document document, char ch);
+        bool SupportsFormattingOnTypedCharacter(Document document, AutoFormattingOptions options, char ch);
 
         /// <summary>
         /// Returns the text changes necessary to format the document.  If "textSpan" is provided,
diff --git a/src/Features/Core/Portable/Wrapping/AbstractCodeActionComputer.cs b/src/Features/Core/Portable/Wrapping/AbstractCodeActionComputer.cs
index ae5877e62ff21..3c0b78de18ab0 100644
--- a/src/Features/Core/Portable/Wrapping/AbstractCodeActionComputer.cs
+++ b/src/Features/Core/Portable/Wrapping/AbstractCodeActionComputer.cs
@@ -78,10 +78,10 @@ public AbstractCodeActionComputer(
                 OriginalSourceText = originalSourceText;
                 CancellationToken = cancellationToken;
 
-                UseTabs = options.GetOption(FormattingOptions.UseTabs);
-                TabSize = options.GetOption(FormattingOptions.TabSize);
-                NewLine = options.GetOption(FormattingOptions.NewLine);
-                WrappingColumn = options.GetOption(FormattingBehaviorOptions.PreferredWrappingColumn);
+                UseTabs = options.GetOption(FormattingOptions2.UseTabs);
+                TabSize = options.GetOption(FormattingOptions2.TabSize);
+                NewLine = options.GetOption(FormattingOptions2.NewLine);
+                WrappingColumn = options.GetOption(FormattingOptions2.PreferredWrappingColumn);
 
                 var generator = SyntaxGenerator.GetGenerator(document);
                 var generatorInternal = document.GetRequiredLanguageService<SyntaxGeneratorInternal>();
diff --git a/src/Features/LanguageServer/Protocol/Handler/OnAutoInsert/OnAutoInsertHandler.cs b/src/Features/LanguageServer/Protocol/Handler/OnAutoInsert/OnAutoInsertHandler.cs
index 8565a86cb1509..b8bd9a197bc71 100644
--- a/src/Features/LanguageServer/Protocol/Handler/OnAutoInsert/OnAutoInsertHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/OnAutoInsert/OnAutoInsertHandler.cs
@@ -14,6 +14,7 @@
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Indentation;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
@@ -80,8 +81,10 @@ public OnAutoInsertHandler(
             // Once LSP supports overtype we can move all of brace completion to LSP.
             if (request.Character == "\n" && context.ClientName == document.Services.GetService<DocumentPropertiesService>()?.DiagnosticsLspClientName)
             {
+                var indentationOptions = IndentationOptions.From(documentOptions, document.Project.Solution.Workspace.Services, document.Project.Language);
+
                 var braceCompletionAfterReturnResponse = await GetBraceCompletionAfterReturnResponseAsync(
-                    request, document, documentOptions, cancellationToken).ConfigureAwait(false);
+                    request, document, indentationOptions, cancellationToken).ConfigureAwait(false);
                 if (braceCompletionAfterReturnResponse != null)
                 {
                     return braceCompletionAfterReturnResponse;
@@ -127,7 +130,7 @@ public OnAutoInsertHandler(
         private async Task<LSP.VSInternalDocumentOnAutoInsertResponseItem?> GetBraceCompletionAfterReturnResponseAsync(
             LSP.VSInternalDocumentOnAutoInsertParams autoInsertParams,
             Document document,
-            DocumentOptionSet documentOptions,
+            IndentationOptions options,
             CancellationToken cancellationToken)
         {
             var sourceText = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
@@ -140,7 +143,7 @@ public OnAutoInsertHandler(
             }
 
             var (service, context) = serviceAndContext.Value;
-            var postReturnEdit = await service.GetTextChangeAfterReturnAsync(context, documentOptions, cancellationToken).ConfigureAwait(false);
+            var postReturnEdit = await service.GetTextChangeAfterReturnAsync(context, options, cancellationToken).ConfigureAwait(false);
             if (postReturnEdit == null)
             {
                 return null;
@@ -156,7 +159,7 @@ public OnAutoInsertHandler(
                 if (caretLine.Span.IsEmpty)
                 {
                     // We have an empty line with the caret column at an indented position, let's add whitespace indentation to the text.
-                    var indentedText = GetIndentedText(newSourceText, caretLine, desiredCaretLinePosition, documentOptions);
+                    var indentedText = GetIndentedText(newSourceText, caretLine, desiredCaretLinePosition, options);
 
                     // Get the overall text changes between the original text and the formatted + indented text.
                     textChanges = indentedText.GetTextChanges(sourceText).ToImmutableArray();
@@ -192,13 +195,13 @@ static SourceText GetIndentedText(
                 SourceText textToIndent,
                 TextLine lineToIndent,
                 LinePosition desiredCaretLinePosition,
-                DocumentOptionSet documentOptions)
+                IndentationOptions options)
             {
                 // Indent by the amount needed to make the caret line contain the desired indentation column.
                 var amountToIndent = desiredCaretLinePosition.Character - lineToIndent.Span.Length;
 
                 // Create and apply a text change with whitespace for the indentation amount.
-                var indentText = amountToIndent.CreateIndentationString(documentOptions.GetOption(FormattingOptions.UseTabs), documentOptions.GetOption(FormattingOptions.TabSize));
+                var indentText = amountToIndent.CreateIndentationString(options.FormattingOptions.GetOption(FormattingOptions2.UseTabs), options.FormattingOptions.GetOption(FormattingOptions2.TabSize));
                 var indentedText = textToIndent.WithChanges(new TextChange(new TextSpan(lineToIndent.End, 0), indentText));
                 return indentedText;
             }
diff --git a/src/Tools/ExternalAccess/FSharp/Internal/Editor/FSharpEditorFormattingService.cs b/src/Tools/ExternalAccess/FSharp/Internal/Editor/FSharpEditorFormattingService.cs
index b551a058854ed..05736e9b16964 100644
--- a/src/Tools/ExternalAccess/FSharp/Internal/Editor/FSharpEditorFormattingService.cs
+++ b/src/Tools/ExternalAccess/FSharp/Internal/Editor/FSharpEditorFormattingService.cs
@@ -57,7 +57,7 @@ public Task<IList<TextChange>> GetFormattingChangesOnPasteAsync(Document documen
             return _service.GetFormattingChangesOnReturnAsync(document, position, cancellationToken);
         }
 
-        public bool SupportsFormattingOnTypedCharacter(Document document, char ch)
+        public bool SupportsFormattingOnTypedCharacter(Document document, AutoFormattingOptions options, char ch)
         {
             return _service.SupportsFormattingOnTypedCharacter(document, ch);
         }
diff --git a/src/Tools/ExternalAccess/Razor/RazorCSharpFormattingInteractionService.cs b/src/Tools/ExternalAccess/Razor/RazorCSharpFormattingInteractionService.cs
index 58d6fd5a592ad..164758b6f3031 100644
--- a/src/Tools/ExternalAccess/Razor/RazorCSharpFormattingInteractionService.cs
+++ b/src/Tools/ExternalAccess/Razor/RazorCSharpFormattingInteractionService.cs
@@ -26,7 +26,8 @@ public static bool SupportsFormattingOnTypedCharacter(Document document, char ch
         {
             Contract.ThrowIfFalse(document.Project.Language is LanguageNames.CSharp);
             var formattingService = document.GetRequiredLanguageService<IFormattingInteractionService>();
-            return formattingService.SupportsFormattingOnTypedCharacter(document, ch);
+            var options = AutoFormattingOptions.From(document.Project);
+            return formattingService.SupportsFormattingOnTypedCharacter(document, options, ch);
         }
 
         /// <summary>
diff --git a/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.BraceCompletion.cs b/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.BraceCompletion.cs
index e9f83e5bcb7d6..4e2bea903475a 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.BraceCompletion.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.BraceCompletion.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 Microsoft.CodeAnalysis.BraceCompletion;
+using Microsoft.CodeAnalysis.Formatting;
 
 namespace Microsoft.VisualStudio.LanguageServices.CSharp.Options
 {
@@ -10,8 +10,8 @@ public partial class AutomationObject
     {
         public int Formatting_TriggerOnBlockCompletion
         {
-            get { return GetBooleanOption(BraceCompletionOptions.AutoFormattingOnCloseBrace); }
-            set { SetBooleanOption(BraceCompletionOptions.AutoFormattingOnCloseBrace, value); }
+            get { return GetBooleanOption(AutoFormattingOptions.Metadata.AutoFormattingOnCloseBrace); }
+            set { SetBooleanOption(AutoFormattingOptions.Metadata.AutoFormattingOnCloseBrace, value); }
         }
     }
 }
diff --git a/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.Formatting.cs b/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.Formatting.cs
index 6b8e468419bb7..d03626adf6e21 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.Formatting.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.Formatting.cs
@@ -4,6 +4,7 @@
 
 using Microsoft.CodeAnalysis.CSharp.Formatting;
 using Microsoft.CodeAnalysis.Formatting;
+using Microsoft.CodeAnalysis.Editor.Implementation.Formatting;
 
 namespace Microsoft.VisualStudio.LanguageServices.CSharp.Options
 {
@@ -305,20 +306,20 @@ public int Wrapping_PreserveSingleLine
 
         public int Formatting_TriggerOnPaste
         {
-            get { return GetBooleanOption(FormattingBehaviorOptions.FormatOnPaste); }
-            set { SetBooleanOption(FormattingBehaviorOptions.FormatOnPaste, value); }
+            get { return GetBooleanOption(FormattingOptionsMetadata.FormatOnPaste); }
+            set { SetBooleanOption(FormattingOptionsMetadata.FormatOnPaste, value); }
         }
 
         public int Formatting_TriggerOnStatementCompletion
         {
-            get { return GetBooleanOption(FormattingBehaviorOptions.AutoFormattingOnSemicolon); }
-            set { SetBooleanOption(FormattingBehaviorOptions.AutoFormattingOnSemicolon, value); }
+            get { return GetBooleanOption(AutoFormattingOptions.Metadata.AutoFormattingOnSemicolon); }
+            set { SetBooleanOption(AutoFormattingOptions.Metadata.AutoFormattingOnSemicolon, value); }
         }
 
         public int AutoFormattingOnTyping
         {
-            get { return GetBooleanOption(FormattingBehaviorOptions.AutoFormattingOnTyping); }
-            set { SetBooleanOption(FormattingBehaviorOptions.AutoFormattingOnTyping, value); }
+            get { return GetBooleanOption(AutoFormattingOptions.Metadata.AutoFormattingOnTyping); }
+            set { SetBooleanOption(AutoFormattingOptions.Metadata.AutoFormattingOnTyping, value); }
         }
     }
 }
diff --git a/src/VisualStudio/CSharp/Impl/Options/Formatting/FormattingOptionPageControl.xaml.cs b/src/VisualStudio/CSharp/Impl/Options/Formatting/FormattingOptionPageControl.xaml.cs
index ee490088aed98..dad354fd0f866 100644
--- a/src/VisualStudio/CSharp/Impl/Options/Formatting/FormattingOptionPageControl.xaml.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/Formatting/FormattingOptionPageControl.xaml.cs
@@ -5,7 +5,7 @@
 #nullable disable
 
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.BraceCompletion;
+using Microsoft.CodeAnalysis.Editor.Implementation.Formatting;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.VisualStudio.LanguageServices.Implementation.Options;
 using System.Runtime.CompilerServices;
@@ -33,11 +33,11 @@ public FormattingOptionPageControl(OptionStore optionStore) : base(optionStore)
             FormatOnReturnCheckBox.Content = CSharpVSResources.Automatically_format_on_return;
             FormatOnPasteCheckBox.Content = CSharpVSResources.Automatically_format_on_paste;
 
-            BindToOption(FormatWhenTypingCheckBox, FormattingBehaviorOptions.AutoFormattingOnTyping, LanguageNames.CSharp);
-            BindToOption(FormatOnCloseBraceCheckBox, BraceCompletionOptions.AutoFormattingOnCloseBrace, LanguageNames.CSharp);
-            BindToOption(FormatOnSemicolonCheckBox, FormattingBehaviorOptions.AutoFormattingOnSemicolon, LanguageNames.CSharp);
-            BindToOption(FormatOnReturnCheckBox, FormattingBehaviorOptions.AutoFormattingOnReturn, LanguageNames.CSharp);
-            BindToOption(FormatOnPasteCheckBox, FormattingBehaviorOptions.FormatOnPaste, LanguageNames.CSharp);
+            BindToOption(FormatWhenTypingCheckBox, AutoFormattingOptions.Metadata.AutoFormattingOnTyping, LanguageNames.CSharp);
+            BindToOption(FormatOnCloseBraceCheckBox, AutoFormattingOptions.Metadata.AutoFormattingOnCloseBrace, LanguageNames.CSharp);
+            BindToOption(FormatOnSemicolonCheckBox, AutoFormattingOptions.Metadata.AutoFormattingOnSemicolon, LanguageNames.CSharp);
+            BindToOption(FormatOnReturnCheckBox, AutoFormattingOptions.Metadata.AutoFormattingOnReturn, LanguageNames.CSharp);
+            BindToOption(FormatOnPasteCheckBox, FormattingOptionsMetadata.FormatOnPaste, LanguageNames.CSharp);
         }
     }
 }
diff --git a/src/VisualStudio/Core/Def/Implementation/AbstractEditorFactory.cs b/src/VisualStudio/Core/Def/Implementation/AbstractEditorFactory.cs
index 6efb4b55f0fba..547c6fa76bff8 100644
--- a/src/VisualStudio/Core/Def/Implementation/AbstractEditorFactory.cs
+++ b/src/VisualStudio/Core/Def/Implementation/AbstractEditorFactory.cs
@@ -336,7 +336,7 @@ private async Task FormatDocumentCreatedFromTemplateAsync(IVsHierarchy hierarchy
             var formattedText = formattedRoot.GetText(unformattedText.Encoding, unformattedText.ChecksumAlgorithm);
 
             // Ensure the line endings are normalized. The formatter doesn't touch everything if it doesn't need to.
-            var targetLineEnding = formattingOptions.Options.GetOption(FormattingOptions.NewLine)!;
+            var targetLineEnding = formattingOptions.GetOption(FormattingOptions2.NewLine)!;
 
             var originalText = formattedText;
             foreach (var originalLine in originalText.Lines)
diff --git a/src/VisualStudio/VisualBasic/Impl/Options/AutomationObject/AutomationObject.Formatting.vb b/src/VisualStudio/VisualBasic/Impl/Options/AutomationObject/AutomationObject.Formatting.vb
index a48113097be4b..7ef36de8f58e1 100644
--- a/src/VisualStudio/VisualBasic/Impl/Options/AutomationObject/AutomationObject.Formatting.vb
+++ b/src/VisualStudio/VisualBasic/Impl/Options/AutomationObject/AutomationObject.Formatting.vb
@@ -2,17 +2,17 @@
 ' The .NET Foundation licenses this file to you under the MIT license.
 ' See the LICENSE file in the project root for more information.
 
-Imports Microsoft.CodeAnalysis.Formatting
+Imports Microsoft.CodeAnalysis.Editor.Implementation.Formatting
 
 Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Options
     Partial Public Class AutomationObject
 
         Public Property FormatOnPaste As Boolean
             Get
-                Return GetBooleanOption(FormattingBehaviorOptions.FormatOnPaste)
+                Return GetBooleanOption(FormattingOptionsMetadata.FormatOnPaste)
             End Get
             Set(value As Boolean)
-                SetBooleanOption(FormattingBehaviorOptions.FormatOnPaste, value)
+                SetBooleanOption(FormattingOptionsMetadata.FormatOnPaste, value)
             End Set
         End Property
 
diff --git a/src/Workspaces/CSharp/Portable/Indentation/CSharpIndentationService.Indenter.cs b/src/Workspaces/CSharp/Portable/Indentation/CSharpIndentationService.Indenter.cs
index 0c9deac40330b..a6129a19bb282 100644
--- a/src/Workspaces/CSharp/Portable/Indentation/CSharpIndentationService.Indenter.cs
+++ b/src/Workspaces/CSharp/Portable/Indentation/CSharpIndentationService.Indenter.cs
@@ -20,14 +20,14 @@ internal partial class CSharpIndentationService
     {
         protected override bool ShouldUseTokenIndenter(Indenter indenter, out SyntaxToken syntaxToken)
             => ShouldUseSmartTokenFormatterInsteadOfIndenter(
-                indenter.Rules, indenter.Root, indenter.LineToBeIndented, indenter.OptionService, indenter.OptionSet, out syntaxToken);
+                indenter.Rules, indenter.Root, indenter.LineToBeIndented, indenter.Options, out syntaxToken);
 
         protected override ISmartTokenFormatter CreateSmartTokenFormatter(Indenter indenter)
         {
             var services = indenter.Document.Project.Solution.Workspace.Services;
             var formattingRuleFactory = services.GetRequiredService<IHostDependentFormattingRuleFactoryService>();
             var rules = formattingRuleFactory.CreateRule(indenter.Document.Document, indenter.LineToBeIndented.Start).Concat(Formatter.GetDefaultFormattingRules(indenter.Document.Document));
-            return new CSharpSmartTokenFormatter(indenter.OptionSet, rules, indenter.Root);
+            return new CSharpSmartTokenFormatter(indenter.Options, rules, indenter.Root);
         }
 
         protected override IndentationResult? GetDesiredIndentationWorker(Indenter indenter, SyntaxToken? tokenOpt, SyntaxTrivia? triviaOpt)
@@ -179,7 +179,7 @@ private static IndentationResult GetIndentationBasedOnToken(Indenter indenter, S
 
                         if (nonTerminalNode is SwitchLabelSyntax)
                         {
-                            return indenter.GetIndentationOfLine(sourceText.Lines.GetLineFromPosition(nonTerminalNode.GetFirstToken(includeZeroWidth: true).SpanStart), indenter.OptionSet.GetOption(FormattingOptions.IndentationSize, token.Language));
+                            return indenter.GetIndentationOfLine(sourceText.Lines.GetLineFromPosition(nonTerminalNode.GetFirstToken(includeZeroWidth: true).SpanStart), indenter.Options.FormattingOptions.GetOption(FormattingOptions2.IndentationSize));
                         }
 
                         goto default;
@@ -370,7 +370,7 @@ private static bool IsPartOfQueryExpression(SyntaxToken token)
         private static IndentationResult GetDefaultIndentationFromTokenLine(
             Indenter indenter, SyntaxToken token, int? additionalSpace = null)
         {
-            var spaceToAdd = additionalSpace ?? indenter.OptionSet.GetOption(FormattingOptions.IndentationSize, token.Language);
+            var spaceToAdd = additionalSpace ?? indenter.Options.FormattingOptions.GetOption(FormattingOptions2.IndentationSize);
 
             var sourceText = indenter.LineToBeIndented.Text;
             RoslynDebug.AssertNotNull(sourceText);
diff --git a/src/Workspaces/CSharp/Portable/Indentation/CSharpIndentationService.cs b/src/Workspaces/CSharp/Portable/Indentation/CSharpIndentationService.cs
index de1922efb7d3c..0352f8b050d7c 100644
--- a/src/Workspaces/CSharp/Portable/Indentation/CSharpIndentationService.cs
+++ b/src/Workspaces/CSharp/Portable/Indentation/CSharpIndentationService.cs
@@ -39,20 +39,19 @@ public static bool ShouldUseSmartTokenFormatterInsteadOfIndenter(
             IEnumerable<AbstractFormattingRule> formattingRules,
             CompilationUnitSyntax root,
             TextLine line,
-            IOptionService optionService,
-            OptionSet optionSet,
+            IndentationOptions options,
             out SyntaxToken token)
         {
             Contract.ThrowIfNull(formattingRules);
             Contract.ThrowIfNull(root);
 
             token = default;
-            if (!optionSet.GetOption(FormattingBehaviorOptions.AutoFormattingOnReturn, LanguageNames.CSharp))
+            if (!options.AutoFormattingOptions.FormatOnReturn)
             {
                 return false;
             }
 
-            if (optionSet.GetOption(FormattingOptions.SmartIndent, LanguageNames.CSharp) != FormattingOptions.IndentStyle.Smart)
+            if (options.AutoFormattingOptions.IndentStyle != FormattingOptions.IndentStyle.Smart)
             {
                 return false;
             }
@@ -84,7 +83,7 @@ public static bool ShouldUseSmartTokenFormatterInsteadOfIndenter(
                 return false;
             }
 
-            var lineOperation = FormattingOperations.GetAdjustNewLinesOperation(formattingRules, previousToken, token, optionSet.AsAnalyzerConfigOptions(optionService, LanguageNames.CSharp));
+            var lineOperation = FormattingOperations.GetAdjustNewLinesOperation(formattingRules, previousToken, token, options.FormattingOptions);
             if (lineOperation == null || lineOperation.Option == AdjustNewLinesOption.ForceLinesIfOnSingleLine)
             {
                 // no indentation operation, nothing to do for smart token formatter
diff --git a/src/Workspaces/CSharp/Portable/Indentation/CSharpSmartTokenFormatter.cs b/src/Workspaces/CSharp/Portable/Indentation/CSharpSmartTokenFormatter.cs
index f767038d07f6b..d5c16d911287a 100644
--- a/src/Workspaces/CSharp/Portable/Indentation/CSharpSmartTokenFormatter.cs
+++ b/src/Workspaces/CSharp/Portable/Indentation/CSharpSmartTokenFormatter.cs
@@ -22,17 +22,16 @@ namespace Microsoft.CodeAnalysis.CSharp.Indentation
 {
     internal class CSharpSmartTokenFormatter : ISmartTokenFormatter
     {
-        private readonly OptionSet _options;
+        private readonly IndentationOptions _options;
         private readonly IEnumerable<AbstractFormattingRule> _formattingRules;
 
         private readonly CompilationUnitSyntax _root;
 
         public CSharpSmartTokenFormatter(
-            OptionSet options,
+            IndentationOptions options,
             IEnumerable<AbstractFormattingRule> formattingRules,
             CompilationUnitSyntax root)
         {
-            Contract.ThrowIfNull(options);
             Contract.ThrowIfNull(formattingRules);
             Contract.ThrowIfNull(root);
 
@@ -61,8 +60,7 @@ public IList<TextChange> FormatRange(
                 smartTokenformattingRules = (new NoLineChangeFormattingRule()).Concat(_formattingRules);
             }
 
-            var formattingOptions = SyntaxFormattingOptions.Create(_options, services, _root.Language);
-            return Formatter.GetFormattedTextChanges(_root, new[] { TextSpan.FromBounds(startToken.SpanStart, endToken.Span.End) }, services, formattingOptions, smartTokenformattingRules, cancellationToken);
+            return Formatter.GetFormattedTextChanges(_root, new[] { TextSpan.FromBounds(startToken.SpanStart, endToken.Span.End) }, services, _options.FormattingOptions, smartTokenformattingRules, cancellationToken);
         }
 
         private static bool CloseBraceOfTryOrDoBlock(SyntaxToken endToken)
@@ -104,9 +102,8 @@ public async Task<IList<TextChange>> FormatTokenAsync(
 
             var smartTokenformattingRules = new SmartTokenFormattingRule().Concat(_formattingRules);
             var adjustedStartPosition = previousToken.SpanStart;
-            var indentStyle = _options.GetOption(FormattingOptions.SmartIndent, LanguageNames.CSharp);
             if (token.IsKind(SyntaxKind.OpenBraceToken) &&
-                indentStyle != FormattingOptions.IndentStyle.Smart)
+                _options.AutoFormattingOptions.IndentStyle != FormattingOptions.IndentStyle.Smart)
             {
                 RoslynDebug.AssertNotNull(token.SyntaxTree);
                 var text = await token.SyntaxTree.GetTextAsync(cancellationToken).ConfigureAwait(false);
@@ -116,8 +113,7 @@ public async Task<IList<TextChange>> FormatTokenAsync(
                 }
             }
 
-            var formattingOptions = SyntaxFormattingOptions.Create(_options, services, _root.Language);
-            return Formatter.GetFormattedTextChanges(_root, new[] { TextSpan.FromBounds(adjustedStartPosition, adjustedEndPosition) }, services, formattingOptions, smartTokenformattingRules, cancellationToken);
+            return Formatter.GetFormattedTextChanges(_root, new[] { TextSpan.FromBounds(adjustedStartPosition, adjustedEndPosition) }, services, _options.FormattingOptions, smartTokenformattingRules, cancellationToken);
         }
 
         private class NoLineChangeFormattingRule : AbstractFormattingRule
diff --git a/src/Workspaces/Core/Portable/Formatting/AutoFormattingOptions.cs b/src/Workspaces/Core/Portable/Formatting/AutoFormattingOptions.cs
new file mode 100644
index 0000000000000..edc1df9610d0e
--- /dev/null
+++ b/src/Workspaces/Core/Portable/Formatting/AutoFormattingOptions.cs
@@ -0,0 +1,74 @@
+// 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.Immutable;
+using System.Composition;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Options.Providers;
+
+namespace Microsoft.CodeAnalysis.Formatting
+{
+    /// <summary>
+    /// Solution-wide formatting options.
+    /// </summary>
+    internal readonly record struct AutoFormattingOptions(
+        FormattingOptions.IndentStyle IndentStyle,
+        bool FormatOnReturn,
+        bool FormatOnTyping,
+        bool FormatOnSemicolon,
+        bool FormatOnCloseBrace)
+    {
+        public static AutoFormattingOptions From(Project project)
+            => From(project.Solution.Options, project.Language);
+
+        public static AutoFormattingOptions From(OptionSet options, string language)
+            => new(
+                IndentStyle: options.GetOption(Metadata.SmartIndent, language),
+                FormatOnReturn: options.GetOption(Metadata.AutoFormattingOnReturn, language),
+                FormatOnTyping: options.GetOption(Metadata.AutoFormattingOnTyping, language),
+                FormatOnSemicolon: options.GetOption(Metadata.AutoFormattingOnSemicolon, language),
+                FormatOnCloseBrace: options.GetOption(Metadata.AutoFormattingOnCloseBrace, language));
+
+        [ExportSolutionOptionProvider, Shared]
+        internal sealed class Metadata : IOptionProvider
+        {
+            [ImportingConstructor]
+            [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+            public Metadata()
+            {
+            }
+
+            public ImmutableArray<IOption> Options { get; } = ImmutableArray.Create<IOption>(
+                SmartIndent,
+                AutoFormattingOnReturn,
+                AutoFormattingOnTyping,
+                AutoFormattingOnSemicolon,
+                AutoFormattingOnCloseBrace);
+
+            private const string FeatureName = "FormattingOptions";
+
+            // This is also serialized by the Visual Studio-specific LanguageSettingsPersister
+            public static PerLanguageOption2<FormattingOptions.IndentStyle> SmartIndent { get; } =
+                new(FeatureName, FormattingOptionGroups.IndentationAndSpacing, nameof(SmartIndent), defaultValue: FormattingOptions.IndentStyle.Smart);
+
+            internal static readonly PerLanguageOption2<bool> AutoFormattingOnReturn =
+                new(FeatureName, OptionGroup.Default, nameof(AutoFormattingOnReturn), defaultValue: true,
+                storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.Auto Formatting On Return"));
+
+            public static readonly PerLanguageOption2<bool> AutoFormattingOnTyping =
+                new(FeatureName, OptionGroup.Default, nameof(AutoFormattingOnTyping), defaultValue: true,
+                storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.Auto Formatting On Typing"));
+
+            public static readonly PerLanguageOption2<bool> AutoFormattingOnSemicolon =
+                new(FeatureName, OptionGroup.Default, nameof(AutoFormattingOnSemicolon), defaultValue: true,
+                storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.Auto Formatting On Semicolon"));
+
+            public static readonly PerLanguageOption2<bool> AutoFormattingOnCloseBrace = new(
+                "BraceCompletionOptions", nameof(AutoFormattingOnCloseBrace), defaultValue: true,
+                storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.Auto Formatting On Close Brace"));
+        }
+    }
+}
diff --git a/src/Workspaces/Core/Portable/Formatting/FormattingBehaviorOptions.cs b/src/Workspaces/Core/Portable/Formatting/FormattingBehaviorOptions.cs
deleted file mode 100644
index 6a9b67da7346f..0000000000000
--- a/src/Workspaces/Core/Portable/Formatting/FormattingBehaviorOptions.cs
+++ /dev/null
@@ -1,72 +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.Immutable;
-using System.Composition;
-using Microsoft.CodeAnalysis.Host.Mef;
-using Microsoft.CodeAnalysis.Options;
-using Microsoft.CodeAnalysis.Options.Providers;
-
-namespace Microsoft.CodeAnalysis.Formatting
-{
-    /// <summary>
-    /// Solution-wide formatting options.
-    /// </summary>
-    internal sealed class FormattingBehaviorOptions
-    {
-        [ExportSolutionOptionProvider, Shared]
-        internal sealed class Provider : IOptionProvider
-        {
-            [ImportingConstructor]
-            [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-            public Provider()
-            {
-            }
-
-            public ImmutableArray<IOption> Options { get; } = ImmutableArray.Create<IOption>(
-                SmartIndent,
-                PreferredWrappingColumn,
-                AutoFormattingOnReturn,
-                AutoFormattingOnTyping,
-                AutoFormattingOnSemicolon,
-                FormatOnPaste);
-        }
-
-        private const string FeatureName = "FormattingOptions";
-
-        // This is also serialized by the Visual Studio-specific LanguageSettingsPersister
-        public static PerLanguageOption2<FormattingOptions.IndentStyle> SmartIndent { get; } =
-            new(FeatureName, FormattingOptionGroups.IndentationAndSpacing, nameof(SmartIndent), defaultValue: FormattingOptions.IndentStyle.Smart);
-
-        /// <summary>
-        /// Default value of 120 was picked based on the amount of code in a github.com diff at 1080p.
-        /// That resolution is the most common value as per the last DevDiv survey as well as the latest
-        /// Steam hardware survey.  This also seems to a reasonable length default in that shorter
-        /// lengths can often feel too cramped for .NET languages, which are often starting with a
-        /// default indentation of at least 16 (for namespace, class, member, plus the final construct
-        /// indentation).
-        /// 
-        /// TODO: Currently the option has no storage and always has its default value. See https://github.com/dotnet/roslyn/pull/30422#issuecomment-436118696.
-        /// </summary>
-        internal static Option2<int> PreferredWrappingColumn { get; } =
-            new(FeatureName, FormattingOptionGroups.NewLine, nameof(PreferredWrappingColumn), defaultValue: 120);
-
-        internal static readonly PerLanguageOption2<bool> AutoFormattingOnReturn =
-            new(FeatureName, OptionGroup.Default, nameof(AutoFormattingOnReturn), defaultValue: true,
-            storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.Auto Formatting On Return"));
-
-        public static readonly PerLanguageOption2<bool> AutoFormattingOnTyping =
-            new(FeatureName, OptionGroup.Default, nameof(AutoFormattingOnTyping), defaultValue: true,
-            storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.Auto Formatting On Typing"));
-
-        public static readonly PerLanguageOption2<bool> AutoFormattingOnSemicolon =
-            new(FeatureName, OptionGroup.Default, nameof(AutoFormattingOnSemicolon), defaultValue: true,
-            storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.Auto Formatting On Semicolon"));
-
-        public static readonly PerLanguageOption2<bool> FormatOnPaste =
-            new(FeatureName, OptionGroup.Default, nameof(FormatOnPaste), defaultValue: true,
-            storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.FormatOnPaste"));
-    }
-}
diff --git a/src/Workspaces/Core/Portable/Formatting/FormattingOptions.cs b/src/Workspaces/Core/Portable/Formatting/FormattingOptions.cs
index 8ec5a4b163725..25ddf34780753 100644
--- a/src/Workspaces/Core/Portable/Formatting/FormattingOptions.cs
+++ b/src/Workspaces/Core/Portable/Formatting/FormattingOptions.cs
@@ -21,9 +21,9 @@ public static partial class FormattingOptions
         // Suppression due to https://github.com/dotnet/roslyn/issues/42614
         public static PerLanguageOption<int> IndentationSize { get; } = ((PerLanguageOption<int>)FormattingOptions2.IndentationSize)!;
 
-        /// <inheritdoc cref="FormattingBehaviorOptions.SmartIndent"/>
+        /// <inheritdoc cref="AutoFormattingOptions.IndentStyle"/>
         // Suppression due to https://github.com/dotnet/roslyn/issues/42614
-        public static PerLanguageOption<IndentStyle> SmartIndent { get; } = ((PerLanguageOption<IndentStyle>)FormattingBehaviorOptions.SmartIndent)!;
+        public static PerLanguageOption<IndentStyle> SmartIndent { get; } = ((PerLanguageOption<IndentStyle>)AutoFormattingOptions.Metadata.SmartIndent)!;
 
         /// <inheritdoc cref="FormattingOptions2.NewLine"/>
         // Suppression due to https://github.com/dotnet/roslyn/issues/42614
diff --git a/src/Workspaces/Core/Portable/Indentation/AbstractIndentationService.Indenter.cs b/src/Workspaces/Core/Portable/Indentation/AbstractIndentationService.Indenter.cs
index 86120f72eabc6..644c929013c05 100644
--- a/src/Workspaces/Core/Portable/Indentation/AbstractIndentationService.Indenter.cs
+++ b/src/Workspaces/Core/Portable/Indentation/AbstractIndentationService.Indenter.cs
@@ -9,7 +9,6 @@
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Formatting.Rules;
 using Microsoft.CodeAnalysis.LanguageServices;
-using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
@@ -22,8 +21,7 @@ protected struct Indenter
         {
             private readonly AbstractIndentationService<TSyntaxRoot> _service;
 
-            public readonly OptionSet OptionSet;
-            public readonly IOptionService OptionService;
+            public readonly IndentationOptions Options;
             public readonly TextLine LineToBeIndented;
             public readonly CancellationToken CancellationToken;
 
@@ -42,7 +40,7 @@ public Indenter(
                 AbstractIndentationService<TSyntaxRoot> service,
                 SyntacticDocument document,
                 IEnumerable<AbstractFormattingRule> rules,
-                OptionSet optionSet,
+                IndentationOptions options,
                 TextLine lineToBeIndented,
                 CancellationToken cancellationToken)
             {
@@ -50,18 +48,17 @@ public Indenter(
 
                 _service = service;
                 _syntaxFacts = document.Document.GetRequiredLanguageService<ISyntaxFactsService>();
-                OptionSet = optionSet;
-                OptionService = document.Document.Project.Solution.Workspace.Services.GetRequiredService<IOptionService>();
+                Options = options;
                 Root = (TSyntaxRoot)document.Root;
                 LineToBeIndented = lineToBeIndented;
-                _tabSize = this.OptionSet.GetOption(FormattingOptions.TabSize, Root.Language);
+                _tabSize = options.FormattingOptions.GetOption(FormattingOptions2.TabSize);
                 CancellationToken = cancellationToken;
 
                 Rules = rules;
                 Finder = new BottomUpBaseIndentationFinder(
-                    new ChainedFormattingRules(this.Rules, OptionSet.AsAnalyzerConfigOptions(OptionService, Root.Language)),
+                    new ChainedFormattingRules(this.Rules, options.FormattingOptions),
                     _tabSize,
-                    this.OptionSet.GetOption(FormattingOptions.IndentationSize, Root.Language),
+                    options.FormattingOptions.GetOption(FormattingOptions2.IndentationSize),
                     tokenStream: null,
                     document.Document.GetRequiredLanguageService<IHeaderFactsService>());
             }
diff --git a/src/Workspaces/Core/Portable/Indentation/AbstractIndentationService.cs b/src/Workspaces/Core/Portable/Indentation/AbstractIndentationService.cs
index adb1802cc07dd..3c6655866c34f 100644
--- a/src/Workspaces/Core/Portable/Indentation/AbstractIndentationService.cs
+++ b/src/Workspaces/Core/Portable/Indentation/AbstractIndentationService.cs
@@ -5,8 +5,11 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Formatting.Rules;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Options;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Indentation
@@ -50,7 +53,7 @@ public IndentationResult GetIndentation(
 
         private Indenter GetIndenter(Document document, int lineNumber, FormattingOptions.IndentStyle indentStyle, CancellationToken cancellationToken)
         {
-            var documentOptions = document.GetOptionsAsync(cancellationToken).WaitAndGetResult_CanCallOnBackground(cancellationToken);
+            var options = IndentationOptions.FromDocumentAsync(document, cancellationToken).WaitAndGetResult_CanCallOnBackground(cancellationToken);
             var syntacticDoc = SyntacticDocument.CreateAsync(document, cancellationToken).WaitAndGetResult_CanCallOnBackground(cancellationToken);
 
             var sourceText = syntacticDoc.Root.SyntaxTree.GetText(cancellationToken);
@@ -58,7 +61,7 @@ private Indenter GetIndenter(Document document, int lineNumber, FormattingOption
 
             var formattingRules = GetFormattingRules(document, lineToBeIndented.Start, indentStyle);
 
-            return new Indenter(this, syntacticDoc, formattingRules, documentOptions, lineToBeIndented, cancellationToken);
+            return new Indenter(this, syntacticDoc, formattingRules, options, lineToBeIndented, cancellationToken);
         }
 
         /// <summary>
diff --git a/src/Workspaces/Core/Portable/Indentation/IndentationOptions.cs b/src/Workspaces/Core/Portable/Indentation/IndentationOptions.cs
new file mode 100644
index 0000000000000..b60fa4f7bc537
--- /dev/null
+++ b/src/Workspaces/Core/Portable/Indentation/IndentationOptions.cs
@@ -0,0 +1,28 @@
+// 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.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Formatting;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Options;
+
+namespace Microsoft.CodeAnalysis.Indentation
+{
+    internal readonly record struct IndentationOptions(
+        SyntaxFormattingOptions FormattingOptions,
+        AutoFormattingOptions AutoFormattingOptions)
+    {
+        public static async Task<IndentationOptions> FromDocumentAsync(Document document, CancellationToken cancellationToken)
+        {
+            var documentOptions = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
+            return From(documentOptions, document.Project.Solution.Workspace.Services, document.Project.Language);
+        }
+
+        public static IndentationOptions From(OptionSet options, HostWorkspaceServices services, string language)
+            => new(
+                SyntaxFormattingOptions.Create(options, services, language),
+                AutoFormattingOptions.From(options, language));
+    }
+}
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/CSharpSyntaxFormattingService.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/CSharpSyntaxFormattingService.cs
index d86810668676d..56225c4d86f07 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/CSharpSyntaxFormattingService.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/CSharpSyntaxFormattingService.cs
@@ -57,7 +57,7 @@ public override IEnumerable<AbstractFormattingRule> GetDefaultFormattingRules()
         protected override IFormattingResult CreateAggregatedFormattingResult(SyntaxNode node, IList<AbstractFormattingResult> results, SimpleIntervalTree<TextSpan, TextSpanIntervalIntrospector>? formattingSpans = null)
             => new AggregatedFormattingResult(node, results, formattingSpans);
 
-        protected override AbstractFormattingResult Format(SyntaxNode node, AnalyzerConfigOptions options, IEnumerable<AbstractFormattingRule> formattingRules, SyntaxToken token1, SyntaxToken token2, CancellationToken cancellationToken)
-            => new CSharpFormatEngine(node, options, formattingRules, token1, token2).Format(cancellationToken);
+        protected override AbstractFormattingResult Format(SyntaxNode node, SyntaxFormattingOptions options, IEnumerable<AbstractFormattingRule> formattingRules, SyntaxToken startToken, SyntaxToken endToken, CancellationToken cancellationToken)
+            => new CSharpFormatEngine(node, options, formattingRules, startToken, endToken).Format(cancellationToken);
     }
 }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/CSharpFormatEngine.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/CSharpFormatEngine.cs
index 6d927298ecf56..ea2c57d2f8672 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/CSharpFormatEngine.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/CSharpFormatEngine.cs
@@ -15,15 +15,15 @@ internal class CSharpFormatEngine : AbstractFormatEngine
     {
         public CSharpFormatEngine(
             SyntaxNode node,
-            AnalyzerConfigOptions options,
+            SyntaxFormattingOptions options,
             IEnumerable<AbstractFormattingRule> formattingRules,
-            SyntaxToken token1,
-            SyntaxToken token2)
+            SyntaxToken startToken,
+            SyntaxToken endToken)
             : base(TreeData.Create(node),
                  options,
                  formattingRules,
-                 token1,
-                 token2)
+                 startToken,
+                 endToken)
         {
         }
 
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/CSharpStructuredTriviaFormatEngine.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/CSharpStructuredTriviaFormatEngine.cs
index 1ce924a4c2641..9a8d65fc9988a 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/CSharpStructuredTriviaFormatEngine.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/CSharpStructuredTriviaFormatEngine.cs
@@ -16,7 +16,7 @@ internal class CSharpStructuredTriviaFormatEngine : AbstractFormatEngine
         public static IFormattingResult Format(
             SyntaxTrivia trivia,
             int initialColumn,
-            AnalyzerConfigOptions options,
+            SyntaxFormattingOptions options,
             ChainedFormattingRules formattingRules,
             CancellationToken cancellationToken)
         {
@@ -28,15 +28,15 @@ public static IFormattingResult Format(
         private CSharpStructuredTriviaFormatEngine(
             SyntaxTrivia trivia,
             int initialColumn,
-            AnalyzerConfigOptions options,
+            SyntaxFormattingOptions options,
             ChainedFormattingRules formattingRules,
-            SyntaxToken token1,
-            SyntaxToken token2)
+            SyntaxToken startToken,
+            SyntaxToken endToken)
             : base(TreeData.Create(trivia, initialColumn),
                    options,
                    formattingRules,
-                   token1,
-                   token2)
+                   startToken,
+                   endToken)
         {
         }
 
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/CSharpTriviaFormatter.DocumentationCommentExteriorCommentRewriter.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/CSharpTriviaFormatter.DocumentationCommentExteriorCommentRewriter.cs
index e65084acd3b4a..166e0ba1e6851 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/CSharpTriviaFormatter.DocumentationCommentExteriorCommentRewriter.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/CSharpTriviaFormatter.DocumentationCommentExteriorCommentRewriter.cs
@@ -14,13 +14,13 @@ private class DocumentationCommentExteriorCommentRewriter : CSharpSyntaxRewriter
             private readonly bool _forceIndentation;
             private readonly int _indentation;
             private readonly int _indentationDelta;
-            private readonly AnalyzerConfigOptions _options;
+            private readonly SyntaxFormattingOptions _options;
 
             public DocumentationCommentExteriorCommentRewriter(
                 bool forceIndentation,
                 int indentation,
                 int indentationDelta,
-                AnalyzerConfigOptions options,
+                SyntaxFormattingOptions options,
                 bool visitStructuredTrivia = true)
                 : base(visitIntoStructuredTrivia: visitStructuredTrivia)
             {
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/TriviaDataFactory.CodeShapeAnalyzer.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/TriviaDataFactory.CodeShapeAnalyzer.cs
index 536bd3bab7a43..c558d6d218455 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/TriviaDataFactory.CodeShapeAnalyzer.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/TriviaDataFactory.CodeShapeAnalyzer.cs
@@ -17,7 +17,7 @@ internal partial class TriviaDataFactory
         private struct CodeShapeAnalyzer
         {
             private readonly FormattingContext _context;
-            private readonly AnalyzerConfigOptions _options;
+            private readonly SyntaxFormattingOptions _options;
             private readonly TriviaList _triviaList;
 
             private int _indentation;
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/TriviaDataFactory.ComplexTrivia.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/TriviaDataFactory.ComplexTrivia.cs
index 716dc2c00e264..f3174bc118028 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/TriviaDataFactory.ComplexTrivia.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/TriviaDataFactory.ComplexTrivia.cs
@@ -21,7 +21,7 @@ internal partial class TriviaDataFactory
         /// </summary>
         private class ComplexTrivia : AbstractComplexTrivia
         {
-            public ComplexTrivia(AnalyzerConfigOptions options, TreeData treeInfo, SyntaxToken token1, SyntaxToken token2)
+            public ComplexTrivia(SyntaxFormattingOptions options, TreeData treeInfo, SyntaxToken token1, SyntaxToken token2)
                 : base(options, treeInfo, token1, token2)
             {
             }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/TriviaDataFactory.ModifiedComplexTrivia.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/TriviaDataFactory.ModifiedComplexTrivia.cs
index 53b8f54db9d29..7dd97f491cbb5 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/TriviaDataFactory.ModifiedComplexTrivia.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/TriviaDataFactory.ModifiedComplexTrivia.cs
@@ -18,7 +18,7 @@ private class ModifiedComplexTrivia : TriviaDataWithList
         {
             private readonly ComplexTrivia _original;
 
-            public ModifiedComplexTrivia(AnalyzerConfigOptions options, ComplexTrivia original, int lineBreaks, int space)
+            public ModifiedComplexTrivia(SyntaxFormattingOptions options, ComplexTrivia original, int lineBreaks, int space)
                 : base(options, original.Token1.Language)
             {
                 Contract.ThrowIfNull(original);
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/TriviaDataFactory.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/TriviaDataFactory.cs
index e58ac2d9d5e44..b16c2504f6ce9 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/TriviaDataFactory.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Engine/Trivia/TriviaDataFactory.cs
@@ -18,7 +18,7 @@ namespace Microsoft.CodeAnalysis.CSharp.Formatting
     /// </summary>
     internal partial class TriviaDataFactory : AbstractTriviaDataFactory
     {
-        public TriviaDataFactory(TreeData treeInfo, AnalyzerConfigOptions options)
+        public TriviaDataFactory(TreeData treeInfo, SyntaxFormattingOptions options)
             : base(treeInfo, options)
         {
         }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/IndentBlockFormattingRule.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/IndentBlockFormattingRule.cs
index 1cdb73522fb81..4115df4b30704 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/IndentBlockFormattingRule.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/IndentBlockFormattingRule.cs
@@ -8,6 +8,7 @@
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Formatting.Rules;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Utilities;
@@ -32,9 +33,9 @@ private IndentBlockFormattingRule(CachedOptions options)
             _options = options;
         }
 
-        public override AbstractFormattingRule WithOptions(AnalyzerConfigOptions options)
+        public override AbstractFormattingRule WithOptions(SyntaxFormattingOptions options)
         {
-            var cachedOptions = new CachedOptions(options);
+            var cachedOptions = new CachedOptions(options.Options);
 
             if (cachedOptions == _options)
             {
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/IndentUserSettingsFormattingRule.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/IndentUserSettingsFormattingRule.cs
index 1a5f0ef3a81de..e1e38a16ab7a6 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/IndentUserSettingsFormattingRule.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/IndentUserSettingsFormattingRule.cs
@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Formatting.Rules;
 using Microsoft.CodeAnalysis.Options;
 
@@ -24,9 +25,9 @@ private IndentUserSettingsFormattingRule(CachedOptions options)
             _options = options;
         }
 
-        public override AbstractFormattingRule WithOptions(AnalyzerConfigOptions options)
+        public override AbstractFormattingRule WithOptions(SyntaxFormattingOptions options)
         {
-            var cachedOptions = new CachedOptions(options);
+            var cachedOptions = new CachedOptions(options.Options);
 
             if (cachedOptions == _options)
             {
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/NewLineUserSettingFormattingRule.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/NewLineUserSettingFormattingRule.cs
index 14f0f9052e633..db41954c8317a 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/NewLineUserSettingFormattingRule.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/NewLineUserSettingFormattingRule.cs
@@ -6,6 +6,7 @@
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Formatting.Rules;
 using Microsoft.CodeAnalysis.Options;
 using Roslyn.Utilities;
@@ -26,9 +27,9 @@ private NewLineUserSettingFormattingRule(CachedOptions options)
             _options = options;
         }
 
-        public override AbstractFormattingRule WithOptions(AnalyzerConfigOptions options)
+        public override AbstractFormattingRule WithOptions(SyntaxFormattingOptions options)
         {
-            var cachedOptions = new CachedOptions(options);
+            var cachedOptions = new CachedOptions(options.Options);
 
             if (cachedOptions == _options)
             {
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/QueryExpressionFormattingRule.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/QueryExpressionFormattingRule.cs
index 754f38fe61836..fdc73f61a906f 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/QueryExpressionFormattingRule.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/QueryExpressionFormattingRule.cs
@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Formatting.Rules;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
@@ -28,9 +29,9 @@ private QueryExpressionFormattingRule(CachedOptions options)
             _options = options;
         }
 
-        public override AbstractFormattingRule WithOptions(AnalyzerConfigOptions options)
+        public override AbstractFormattingRule WithOptions(SyntaxFormattingOptions options)
         {
-            var cachedOptions = new CachedOptions(options);
+            var cachedOptions = new CachedOptions(options.Options);
 
             if (cachedOptions == _options)
             {
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/SpacingFormattingRule.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/SpacingFormattingRule.cs
index ae8929fcc892f..cfee07726bf1b 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/SpacingFormattingRule.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/SpacingFormattingRule.cs
@@ -8,6 +8,7 @@
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Formatting.Rules;
 using Microsoft.CodeAnalysis.Options;
 using Roslyn.Utilities;
@@ -28,9 +29,9 @@ private SpacingFormattingRule(CachedOptions options)
             _options = options;
         }
 
-        public override AbstractFormattingRule WithOptions(AnalyzerConfigOptions options)
+        public override AbstractFormattingRule WithOptions(SyntaxFormattingOptions options)
         {
-            var cachedOptions = new CachedOptions(options);
+            var cachedOptions = new CachedOptions(options.Options);
 
             if (cachedOptions == _options)
             {
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/TokenBasedFormattingRule.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/TokenBasedFormattingRule.cs
index cf4fe2139fa1f..8c4f3f0bcac75 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/TokenBasedFormattingRule.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/TokenBasedFormattingRule.cs
@@ -10,6 +10,7 @@
 using Microsoft.CodeAnalysis.CSharp.Utilities;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Formatting.Rules;
 using Microsoft.CodeAnalysis.Options;
 using Roslyn.Utilities;
@@ -32,9 +33,9 @@ private TokenBasedFormattingRule(CachedOptions options)
             _options = options;
         }
 
-        public override AbstractFormattingRule WithOptions(AnalyzerConfigOptions options)
+        public override AbstractFormattingRule WithOptions(SyntaxFormattingOptions options)
         {
-            var cachedOptions = new CachedOptions(options);
+            var cachedOptions = new CachedOptions(options.Options);
 
             if (cachedOptions == _options)
             {
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/WrappingFormattingRule.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/WrappingFormattingRule.cs
index edc59cb164d7c..099d40047873c 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/WrappingFormattingRule.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/WrappingFormattingRule.cs
@@ -7,6 +7,7 @@
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Formatting.Rules;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
@@ -28,9 +29,9 @@ private WrappingFormattingRule(CachedOptions options)
             _options = options;
         }
 
-        public override AbstractFormattingRule WithOptions(AnalyzerConfigOptions options)
+        public override AbstractFormattingRule WithOptions(SyntaxFormattingOptions options)
         {
-            var cachedOptions = new CachedOptions(options);
+            var cachedOptions = new CachedOptions(options.Options);
 
             if (cachedOptions == _options)
             {
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/AbstractSyntaxFormattingService.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/AbstractSyntaxFormattingService.cs
index d1de744dc12a7..27346c2c6c709 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/AbstractSyntaxFormattingService.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/AbstractSyntaxFormattingService.cs
@@ -28,7 +28,7 @@ protected AbstractSyntaxFormattingService()
 
         protected abstract IFormattingResult CreateAggregatedFormattingResult(SyntaxNode node, IList<AbstractFormattingResult> results, SimpleIntervalTree<TextSpan, TextSpanIntervalIntrospector>? formattingSpans = null);
 
-        protected abstract AbstractFormattingResult Format(SyntaxNode node, AnalyzerConfigOptions options, IEnumerable<AbstractFormattingRule> rules, SyntaxToken token1, SyntaxToken token2, CancellationToken cancellationToken);
+        protected abstract AbstractFormattingResult Format(SyntaxNode node, SyntaxFormattingOptions options, IEnumerable<AbstractFormattingRule> rules, SyntaxToken startToken, SyntaxToken endToken, CancellationToken cancellationToken);
 
         public IFormattingResult GetFormattingResult(SyntaxNode node, IEnumerable<TextSpan>? spans, SyntaxFormattingOptions options, IEnumerable<AbstractFormattingRule>? rules, CancellationToken cancellationToken)
         {
@@ -61,7 +61,7 @@ public IFormattingResult GetFormattingResult(SyntaxNode node, IEnumerable<TextSp
                 }
 
                 results ??= new List<AbstractFormattingResult>();
-                results.Add(Format(node, options.Options, rules, startToken, endToken, cancellationToken));
+                results.Add(Format(node, options, rules, startToken, endToken, cancellationToken));
             }
 
             // quick simple case check
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Context/FormattingContext.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Context/FormattingContext.cs
index 2a4dc42f00059..8644321632e78 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Context/FormattingContext.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Context/FormattingContext.cs
@@ -666,7 +666,7 @@ public bool IsFormattingDisabled(int pairIndex)
             return IsFormattingDisabled(spanBetweenTwoTokens);
         }
 
-        public AnalyzerConfigOptions Options => _engine.Options;
+        public SyntaxFormattingOptions Options => _engine.Options;
 
         public TreeData TreeData => _engine.TreeData;
 
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractFormatEngine.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractFormatEngine.cs
index b3135bd8ddc66..1962adb931075 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractFormatEngine.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractFormatEngine.cs
@@ -31,52 +31,48 @@ internal abstract partial class AbstractFormatEngine
         private readonly ChainedFormattingRules _formattingRules;
 
         private readonly SyntaxNode _commonRoot;
-        private readonly SyntaxToken _token1;
-        private readonly SyntaxToken _token2;
+        private readonly SyntaxToken _startToken;
+        private readonly SyntaxToken _endToken;
 
         protected readonly TextSpan SpanToFormat;
 
-        internal readonly AnalyzerConfigOptions Options;
+        internal readonly SyntaxFormattingOptions Options;
         internal readonly TreeData TreeData;
 
         public AbstractFormatEngine(
             TreeData treeData,
-            AnalyzerConfigOptions options,
+            SyntaxFormattingOptions options,
             IEnumerable<AbstractFormattingRule> formattingRules,
-            SyntaxToken token1,
-            SyntaxToken token2)
+            SyntaxToken startToken,
+            SyntaxToken endToken)
             : this(
                   treeData,
                   options,
                   new ChainedFormattingRules(formattingRules, options),
-                  token1,
-                  token2)
+                  startToken,
+                  endToken)
         {
         }
 
         internal AbstractFormatEngine(
             TreeData treeData,
-            AnalyzerConfigOptions options,
+            SyntaxFormattingOptions options,
             ChainedFormattingRules formattingRules,
-            SyntaxToken token1,
-            SyntaxToken token2)
+            SyntaxToken startToken,
+            SyntaxToken endToken)
         {
-            Contract.ThrowIfNull(options);
-            Contract.ThrowIfNull(treeData);
-            Contract.ThrowIfNull(formattingRules);
-
-            Contract.ThrowIfTrue(treeData.Root.IsInvalidTokenRange(token1, token2));
+            Contract.ThrowIfTrue(treeData.Root.IsInvalidTokenRange(startToken, endToken));
 
             this.Options = options;
             this.TreeData = treeData;
             _formattingRules = formattingRules;
 
-            _token1 = token1;
-            _token2 = token2;
+            _startToken = startToken;
+            _endToken = endToken;
 
             // get span and common root
             this.SpanToFormat = GetSpanToFormat();
-            _commonRoot = token1.GetCommonRoot(token2) ?? throw ExceptionUtilities.Unreachable;
+            _commonRoot = startToken.GetCommonRoot(endToken) ?? throw ExceptionUtilities.Unreachable;
         }
 
         internal abstract IHeaderFacts HeaderFacts { get; }
@@ -91,7 +87,7 @@ public AbstractFormattingResult Format(CancellationToken cancellationToken)
                 // setup environment
                 var nodeOperations = CreateNodeOperations(cancellationToken);
 
-                var tokenStream = new TokenStream(this.TreeData, this.Options, this.SpanToFormat, CreateTriviaFactory());
+                var tokenStream = new TokenStream(this.TreeData, Options, this.SpanToFormat, CreateTriviaFactory());
                 var tokenOperation = CreateTokenOperation(tokenStream, cancellationToken);
 
                 // initialize context
@@ -120,7 +116,7 @@ protected virtual FormattingContext CreateFormattingContext(TokenStream tokenStr
         {
             // initialize context
             var context = new FormattingContext(this, tokenStream);
-            context.Initialize(_formattingRules, _token1, _token2, cancellationToken);
+            context.Initialize(_formattingRules, _startToken, _endToken, cancellationToken);
 
             return context;
         }
@@ -320,8 +316,8 @@ static void TriviaFormatter(int tokenPairIndex, FormattingContext ctx, ChainedFo
 
         private TextSpan GetSpanToFormat()
         {
-            var startPosition = this.TreeData.IsFirstToken(_token1) ? this.TreeData.StartPosition : _token1.SpanStart;
-            var endPosition = this.TreeData.IsLastToken(_token2) ? this.TreeData.EndPosition : _token2.Span.End;
+            var startPosition = this.TreeData.IsFirstToken(_startToken) ? this.TreeData.StartPosition : _startToken.SpanStart;
+            var endPosition = this.TreeData.IsLastToken(_endToken) ? this.TreeData.EndPosition : _endToken.Span.End;
 
             return TextSpan.FromBounds(startPosition, endPosition);
         }
@@ -491,8 +487,8 @@ private string FormatSummary()
         {
             return string.Format("({0}) ({1} - {2})",
                 this.SpanToFormat,
-                _token1.ToString().Replace("\r\n", "\\r\\n"),
-                _token2.ToString().Replace("\r\n", "\\r\\n"));
+                _startToken.ToString().Replace("\r\n", "\\r\\n"),
+                _endToken.ToString().Replace("\r\n", "\\r\\n"));
         }
     }
 }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractTriviaDataFactory.AbstractComplexTrivia.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractTriviaDataFactory.AbstractComplexTrivia.cs
index 67590b3bf260e..209a1618ee55a 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractTriviaDataFactory.AbstractComplexTrivia.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractTriviaDataFactory.AbstractComplexTrivia.cs
@@ -21,7 +21,7 @@ protected abstract class AbstractComplexTrivia : TriviaDataWithList
 
             private readonly bool _treatAsElastic;
 
-            public AbstractComplexTrivia(AnalyzerConfigOptions options, TreeData treeInfo, SyntaxToken token1, SyntaxToken token2)
+            public AbstractComplexTrivia(SyntaxFormattingOptions options, TreeData treeInfo, SyntaxToken token1, SyntaxToken token2)
                 : base(options, token1.Language)
             {
                 Contract.ThrowIfNull(treeInfo);
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractTriviaDataFactory.FormattedWhitespace.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractTriviaDataFactory.FormattedWhitespace.cs
index b484b0883bc48..4b223c1de7ee7 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractTriviaDataFactory.FormattedWhitespace.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractTriviaDataFactory.FormattedWhitespace.cs
@@ -17,7 +17,7 @@ protected class FormattedWhitespace : TriviaData
         {
             private readonly string _newString;
 
-            public FormattedWhitespace(AnalyzerConfigOptions options, int lineBreaks, int indentation, string language)
+            public FormattedWhitespace(SyntaxFormattingOptions options, int lineBreaks, int indentation, string language)
                 : base(options, language)
             {
                 this.LineBreaks = Math.Max(0, lineBreaks);
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractTriviaDataFactory.ModifiedWhitespace.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractTriviaDataFactory.ModifiedWhitespace.cs
index 8ae9314f4ac4c..8a1f7d10b33b2 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractTriviaDataFactory.ModifiedWhitespace.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractTriviaDataFactory.ModifiedWhitespace.cs
@@ -15,13 +15,13 @@ protected class ModifiedWhitespace : Whitespace
         {
             private readonly Whitespace? _original;
 
-            public ModifiedWhitespace(AnalyzerConfigOptions options, int lineBreaks, int indentation, bool elastic, string language)
+            public ModifiedWhitespace(SyntaxFormattingOptions options, int lineBreaks, int indentation, bool elastic, string language)
                 : base(options, lineBreaks, indentation, elastic, language)
             {
                 _original = null;
             }
 
-            public ModifiedWhitespace(AnalyzerConfigOptions options, Whitespace original, int lineBreaks, int indentation, bool elastic, string language)
+            public ModifiedWhitespace(SyntaxFormattingOptions options, Whitespace original, int lineBreaks, int indentation, bool elastic, string language)
                 : base(options, lineBreaks, indentation, elastic, language)
             {
                 Contract.ThrowIfNull(original);
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractTriviaDataFactory.Whitespace.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractTriviaDataFactory.Whitespace.cs
index 454328f74e05b..97a344b3fe50e 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractTriviaDataFactory.Whitespace.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractTriviaDataFactory.Whitespace.cs
@@ -21,13 +21,13 @@ protected class Whitespace : TriviaData
         {
             private readonly bool _elastic;
 
-            public Whitespace(AnalyzerConfigOptions options, int space, bool elastic, string language)
+            public Whitespace(SyntaxFormattingOptions options, int space, bool elastic, string language)
                 : this(options, lineBreaks: 0, indentation: space, elastic: elastic, language: language)
             {
                 Contract.ThrowIfFalse(space >= 0);
             }
 
-            public Whitespace(AnalyzerConfigOptions options, int lineBreaks, int indentation, bool elastic, string language)
+            public Whitespace(SyntaxFormattingOptions options, int lineBreaks, int indentation, bool elastic, string language)
                 : base(options, language)
             {
                 _elastic = elastic;
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractTriviaDataFactory.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractTriviaDataFactory.cs
index 1857503a0846c..196f2b02c4a13 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractTriviaDataFactory.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/AbstractTriviaDataFactory.cs
@@ -15,7 +15,7 @@ internal abstract partial class AbstractTriviaDataFactory
         private const int IndentationLevelCacheSize = 20;
 
         protected readonly TreeData TreeInfo;
-        protected readonly AnalyzerConfigOptions Options;
+        protected readonly SyntaxFormattingOptions Options;
 
         protected readonly bool UseTabs;
         protected readonly int TabSize;
@@ -24,10 +24,9 @@ internal abstract partial class AbstractTriviaDataFactory
         private readonly Whitespace[] _spaces;
         private readonly Whitespace?[,] _whitespaces = new Whitespace[LineBreakCacheSize, IndentationLevelCacheSize];
 
-        protected AbstractTriviaDataFactory(TreeData treeInfo, AnalyzerConfigOptions options)
+        protected AbstractTriviaDataFactory(TreeData treeInfo, SyntaxFormattingOptions options)
         {
             Contract.ThrowIfNull(treeInfo);
-            Contract.ThrowIfNull(options);
 
             this.TreeInfo = treeInfo;
             this.Options = options;
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/ChainedFormattingRules.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/ChainedFormattingRules.cs
index 81f8f87018859..01b1b601854f7 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/ChainedFormattingRules.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/ChainedFormattingRules.cs
@@ -19,7 +19,7 @@ internal class ChainedFormattingRules
         private static readonly ConcurrentDictionary<(Type type, string name), Type?> s_typeImplementingMethod = new();
 
         private readonly ImmutableArray<AbstractFormattingRule> _formattingRules;
-        private readonly AnalyzerConfigOptions _options;
+        private readonly SyntaxFormattingOptions _options;
 
         private readonly ImmutableArray<AbstractFormattingRule> _addSuppressOperationsRules;
         private readonly ImmutableArray<AbstractFormattingRule> _addAnchorIndentationOperationsRules;
@@ -28,10 +28,9 @@ internal class ChainedFormattingRules
         private readonly ImmutableArray<AbstractFormattingRule> _getAdjustNewLinesOperationRules;
         private readonly ImmutableArray<AbstractFormattingRule> _getAdjustSpacesOperationRules;
 
-        public ChainedFormattingRules(IEnumerable<AbstractFormattingRule> formattingRules, AnalyzerConfigOptions options)
+        public ChainedFormattingRules(IEnumerable<AbstractFormattingRule> formattingRules, SyntaxFormattingOptions options)
         {
             Contract.ThrowIfNull(formattingRules);
-            Contract.ThrowIfNull(options);
 
             _formattingRules = formattingRules.Select(rule => rule.WithOptions(options)).ToImmutableArray();
             _options = options;
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/TokenStream.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/TokenStream.cs
index aae4c0b9c956e..a0b696f44f967 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/TokenStream.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/TokenStream.cs
@@ -36,7 +36,7 @@ internal partial class TokenStream
         // this will reconstruct information that reside in syntax tree from root node
         // if syntax tree is not given
         private readonly TreeData _treeData;
-        private readonly AnalyzerConfigOptions _options;
+        private readonly SyntaxFormattingOptions _options;
 
         // hold onto information that are made to original trivia info
         private Changes _changes;
@@ -48,7 +48,7 @@ internal partial class TokenStream
         private readonly Func<TokenData, TokenData, TriviaData> _getTriviaData;
         private readonly Func<TokenData, TokenData, TriviaData> _getOriginalTriviaData;
 
-        public TokenStream(TreeData treeData, AnalyzerConfigOptions options, TextSpan spanToFormat, AbstractTriviaDataFactory factory)
+        public TokenStream(TreeData treeData, SyntaxFormattingOptions options, TextSpan spanToFormat, AbstractTriviaDataFactory factory)
         {
             using (Logger.LogBlock(FunctionId.Formatting_TokenStreamConstruction, CancellationToken.None))
             {
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/TriviaData.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/TriviaData.cs
index 2828e6064a3b4..d115af7fd3dcb 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/TriviaData.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/TriviaData.cs
@@ -20,14 +20,13 @@ internal abstract class TriviaData
 
         private readonly string _language;
 
-        protected TriviaData(AnalyzerConfigOptions options, string language)
+        protected TriviaData(SyntaxFormattingOptions options, string language)
         {
-            Contract.ThrowIfNull(options);
             Options = options;
             _language = language;
         }
 
-        protected AnalyzerConfigOptions Options { get; }
+        protected SyntaxFormattingOptions Options { get; }
         protected string Language => _language;
 
         public int LineBreaks { get; protected set; }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/TriviaDataWithList.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/TriviaDataWithList.cs
index f3708ff9981f9..6355f59d66642 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/TriviaDataWithList.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Engine/TriviaDataWithList.cs
@@ -9,7 +9,7 @@ namespace Microsoft.CodeAnalysis.Formatting
 {
     internal abstract class TriviaDataWithList : TriviaData
     {
-        public TriviaDataWithList(AnalyzerConfigOptions options, string language)
+        public TriviaDataWithList(SyntaxFormattingOptions options, string language)
             : base(options, language)
         {
         }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/FormattingOptions2.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/FormattingOptions2.cs
index 13282f2a3e29b..f38ab25895024 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/FormattingOptions2.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/FormattingOptions2.cs
@@ -76,6 +76,19 @@ public Provider()
             new(FeatureName, FormattingOptionGroups.NewLine, nameof(InsertFinalNewLine), defaultValue: false,
             storageLocation: EditorConfigStorageLocation.ForBoolOption("insert_final_newline"));
 
+        /// <summary>
+        /// Default value of 120 was picked based on the amount of code in a github.com diff at 1080p.
+        /// That resolution is the most common value as per the last DevDiv survey as well as the latest
+        /// Steam hardware survey.  This also seems to a reasonable length default in that shorter
+        /// lengths can often feel too cramped for .NET languages, which are often starting with a
+        /// default indentation of at least 16 (for namespace, class, member, plus the final construct
+        /// indentation).
+        /// 
+        /// TODO: Currently the option has no storage and always has its default value. See https://github.com/dotnet/roslyn/pull/30422#issuecomment-436118696.
+        /// </summary>
+        internal static Option2<int> PreferredWrappingColumn { get; } =
+            new(FeatureName, FormattingOptionGroups.NewLine, nameof(PreferredWrappingColumn), defaultValue: 120);
+
 #if !CODE_STYLE
         internal static readonly ImmutableArray<IOption> Options = ImmutableArray.Create<IOption>(
             UseTabs,
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/ISyntaxFormattingService.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/ISyntaxFormattingService.cs
index 9ee260b539894..07a99676510d5 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/ISyntaxFormattingService.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/ISyntaxFormattingService.cs
@@ -9,9 +9,9 @@
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Options;
 
 #if !CODE_STYLE
-using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Host;
 #endif
 
@@ -34,6 +34,12 @@ internal readonly record struct SyntaxFormattingOptions(
         public static SyntaxFormattingOptions Create(AnalyzerConfigOptions options)
             => new(options);
 
+        public T GetOption<T>(Option2<T> option)
+            => Options.GetOption(option);
+
+        public T GetOption<T>(PerLanguageOption2<T> option)
+            => Options.GetOption(option);
+
 #if !CODE_STYLE
         public static SyntaxFormattingOptions Create(OptionSet options, HostWorkspaceServices services, string language)
             => new(options.AsAnalyzerConfigOptions(services.GetRequiredService<IOptionService>(), language));
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Rules/AbstractFormattingRule.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Rules/AbstractFormattingRule.cs
index fb66ca8525776..29c3dae4b185b 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Rules/AbstractFormattingRule.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Rules/AbstractFormattingRule.cs
@@ -13,7 +13,7 @@ namespace Microsoft.CodeAnalysis.Formatting.Rules
     /// <remarks>All methods defined in this class can be called concurrently. Must be thread-safe.</remarks>
     internal abstract class AbstractFormattingRule
     {
-        public virtual AbstractFormattingRule WithOptions(AnalyzerConfigOptions options)
+        public virtual AbstractFormattingRule WithOptions(SyntaxFormattingOptions options)
             => this;
 
         /// <summary>
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Rules/Operations/FormattingOperations.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Rules/Operations/FormattingOperations.cs
index 2bc00ddbaf6b1..c3976ca379f8b 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Rules/Operations/FormattingOperations.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/Rules/Operations/FormattingOperations.cs
@@ -144,7 +144,7 @@ public static AdjustSpacesOperation CreateAdjustSpacesOperation(int space, Adjus
         /// <summary>
         /// return SuppressOperation for the node provided by the given formatting rules
         /// </summary>
-        internal static IEnumerable<SuppressOperation> GetSuppressOperations(IEnumerable<AbstractFormattingRule> formattingRules, SyntaxNode node, AnalyzerConfigOptions options)
+        internal static IEnumerable<SuppressOperation> GetSuppressOperations(IEnumerable<AbstractFormattingRule> formattingRules, SyntaxNode node, SyntaxFormattingOptions options)
         {
             var chainedFormattingRules = new ChainedFormattingRules(formattingRules, options);
 
@@ -156,7 +156,7 @@ internal static IEnumerable<SuppressOperation> GetSuppressOperations(IEnumerable
         /// <summary>
         /// return AnchorIndentationOperation for the node provided by the given formatting rules
         /// </summary>
-        internal static IEnumerable<AnchorIndentationOperation> GetAnchorIndentationOperations(IEnumerable<AbstractFormattingRule> formattingRules, SyntaxNode node, AnalyzerConfigOptions options)
+        internal static IEnumerable<AnchorIndentationOperation> GetAnchorIndentationOperations(IEnumerable<AbstractFormattingRule> formattingRules, SyntaxNode node, SyntaxFormattingOptions options)
         {
             var chainedFormattingRules = new ChainedFormattingRules(formattingRules, options);
 
@@ -168,7 +168,7 @@ internal static IEnumerable<AnchorIndentationOperation> GetAnchorIndentationOper
         /// <summary>
         /// return IndentBlockOperation for the node provided by the given formatting rules
         /// </summary>
-        internal static IEnumerable<IndentBlockOperation> GetIndentBlockOperations(IEnumerable<AbstractFormattingRule> formattingRules, SyntaxNode node, AnalyzerConfigOptions options)
+        internal static IEnumerable<IndentBlockOperation> GetIndentBlockOperations(IEnumerable<AbstractFormattingRule> formattingRules, SyntaxNode node, SyntaxFormattingOptions options)
         {
             var chainedFormattingRules = new ChainedFormattingRules(formattingRules, options);
 
@@ -180,7 +180,7 @@ internal static IEnumerable<IndentBlockOperation> GetIndentBlockOperations(IEnum
         /// <summary>
         /// return AlignTokensOperation for the node provided by the given formatting rules
         /// </summary>
-        internal static IEnumerable<AlignTokensOperation> GetAlignTokensOperations(IEnumerable<AbstractFormattingRule> formattingRules, SyntaxNode node, AnalyzerConfigOptions options)
+        internal static IEnumerable<AlignTokensOperation> GetAlignTokensOperations(IEnumerable<AbstractFormattingRule> formattingRules, SyntaxNode node, SyntaxFormattingOptions options)
         {
             var chainedFormattingRules = new ChainedFormattingRules(formattingRules, options);
 
@@ -192,7 +192,7 @@ internal static IEnumerable<AlignTokensOperation> GetAlignTokensOperations(IEnum
         /// <summary>
         /// return AdjustNewLinesOperation for the node provided by the given formatting rules
         /// </summary>
-        internal static AdjustNewLinesOperation? GetAdjustNewLinesOperation(IEnumerable<AbstractFormattingRule> formattingRules, SyntaxToken previousToken, SyntaxToken currentToken, AnalyzerConfigOptions options)
+        internal static AdjustNewLinesOperation? GetAdjustNewLinesOperation(IEnumerable<AbstractFormattingRule> formattingRules, SyntaxToken previousToken, SyntaxToken currentToken, SyntaxFormattingOptions options)
         {
             var chainedFormattingRules = new ChainedFormattingRules(formattingRules, options);
             return chainedFormattingRules.GetAdjustNewLinesOperation(previousToken, currentToken);
@@ -201,7 +201,7 @@ internal static IEnumerable<AlignTokensOperation> GetAlignTokensOperations(IEnum
         /// <summary>
         /// return AdjustSpacesOperation for the node provided by the given formatting rules
         /// </summary>
-        internal static AdjustSpacesOperation? GetAdjustSpacesOperation(IEnumerable<AbstractFormattingRule> formattingRules, SyntaxToken previousToken, SyntaxToken currentToken, AnalyzerConfigOptions options)
+        internal static AdjustSpacesOperation? GetAdjustSpacesOperation(IEnumerable<AbstractFormattingRule> formattingRules, SyntaxToken previousToken, SyntaxToken currentToken, SyntaxFormattingOptions options)
         {
             var chainedFormattingRules = new ChainedFormattingRules(formattingRules, options);
             return chainedFormattingRules.GetAdjustSpacesOperation(previousToken, currentToken);
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/TriviaEngine/AbstractTriviaFormatter.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/TriviaEngine/AbstractTriviaFormatter.cs
index 3973bdc0d7dc3..35cb44d059ed3 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/TriviaEngine/AbstractTriviaFormatter.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/TriviaEngine/AbstractTriviaFormatter.cs
@@ -225,7 +225,7 @@ protected TreeData TreeInfo
             get { return this.Context.TreeData; }
         }
 
-        protected AnalyzerConfigOptions Options
+        protected SyntaxFormattingOptions Options
         {
             get { return this.Context.Options; }
         }
diff --git a/src/Workspaces/VisualBasic/Portable/Formatting/DefaultOperationProvider.vb b/src/Workspaces/VisualBasic/Portable/Formatting/DefaultOperationProvider.vb
index 4dd16b2851f5b..88a06bd33d5e5 100644
--- a/src/Workspaces/VisualBasic/Portable/Formatting/DefaultOperationProvider.vb
+++ b/src/Workspaces/VisualBasic/Portable/Formatting/DefaultOperationProvider.vb
@@ -5,6 +5,7 @@
 Imports Microsoft.CodeAnalysis
 Imports Microsoft.CodeAnalysis.Diagnostics
 Imports Microsoft.CodeAnalysis.Editing
+Imports Microsoft.CodeAnalysis.Formatting
 Imports Microsoft.CodeAnalysis.Formatting.Rules
 Imports Microsoft.CodeAnalysis.Options
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
@@ -30,8 +31,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
             _options = options
         End Sub
 
-        Public Overrides Function WithOptions(options As AnalyzerConfigOptions) As AbstractFormattingRule
-            Dim cachedOptions = New CachedOptions(options)
+        Public Overrides Function WithOptions(options As SyntaxFormattingOptions) As AbstractFormattingRule
+            Dim cachedOptions = New CachedOptions(options.Options)
 
             If cachedOptions = _options Then
                 Return Me
diff --git a/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.AbstractLineBreakTrivia.vb b/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.AbstractLineBreakTrivia.vb
index 9ebcd34c10a92..d75d120ab0a90 100644
--- a/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.AbstractLineBreakTrivia.vb
+++ b/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.AbstractLineBreakTrivia.vb
@@ -15,7 +15,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
             Protected ReadOnly _original As String
             Protected ReadOnly _newString As String
 
-            Public Sub New(options As AnalyzerConfigOptions,
+            Public Sub New(options As SyntaxFormattingOptions,
                            original As String,
                            lineBreaks As Integer,
                            indentation As Integer,
diff --git a/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.CodeShapeAnalyzer.vb b/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.CodeShapeAnalyzer.vb
index 9f2691dfbe309..97ed0752eca23 100644
--- a/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.CodeShapeAnalyzer.vb
+++ b/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.CodeShapeAnalyzer.vb
@@ -12,7 +12,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
         Private Structure CodeShapeAnalyzer
 
             Private ReadOnly _context As FormattingContext
-            Private ReadOnly _options As AnalyzerConfigOptions
+            Private ReadOnly _options As SyntaxFormattingOptions
             Private ReadOnly _list As TriviaList
 
             Private _indentation As Integer
diff --git a/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.ComplexTrivia.vb b/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.ComplexTrivia.vb
index 9ad47b6b70958..b07e379f4f153 100644
--- a/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.ComplexTrivia.vb
+++ b/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.ComplexTrivia.vb
@@ -17,7 +17,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
         Private Class ComplexTrivia
             Inherits AbstractComplexTrivia
 
-            Public Sub New(options As AnalyzerConfigOptions, treeInfo As TreeData, token1 As SyntaxToken, token2 As SyntaxToken)
+            Public Sub New(options As SyntaxFormattingOptions, treeInfo As TreeData, token1 As SyntaxToken, token2 As SyntaxToken)
                 MyBase.New(options, treeInfo, token1, token2)
                 Contract.ThrowIfNull(treeInfo)
             End Sub
diff --git a/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.LineContinuationTrivia.vb b/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.LineContinuationTrivia.vb
index 9a2fc2a4a559a..2006e847350c5 100644
--- a/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.LineContinuationTrivia.vb
+++ b/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.LineContinuationTrivia.vb
@@ -16,7 +16,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
         Private Class LineContinuationTrivia
             Inherits AbstractLineBreakTrivia
 
-            Public Sub New(options As AnalyzerConfigOptions,
+            Public Sub New(options As SyntaxFormattingOptions,
                            originalString As String,
                            indentation As Integer)
                 MyBase.New(options, originalString, 1, indentation, False)
diff --git a/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.ModifiedComplexTrivia.vb b/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.ModifiedComplexTrivia.vb
index 6bc2b3a49c0f4..2062779935531 100644
--- a/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.ModifiedComplexTrivia.vb
+++ b/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.ModifiedComplexTrivia.vb
@@ -14,7 +14,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
 
             Private ReadOnly _original As ComplexTrivia
 
-            Public Sub New(options As AnalyzerConfigOptions, original As ComplexTrivia, lineBreaks As Integer, space As Integer)
+            Public Sub New(options As SyntaxFormattingOptions, original As ComplexTrivia, lineBreaks As Integer, space As Integer)
                 MyBase.New(options, LanguageNames.VisualBasic)
                 Contract.ThrowIfNull(original)
 
diff --git a/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.vb b/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.vb
index 23ddfad58c055..6b3c2045c406e 100644
--- a/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.vb
+++ b/src/Workspaces/VisualBasic/Portable/Formatting/Engine/Trivia/TriviaDataFactory.vb
@@ -20,7 +20,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
 
         Private ReadOnly _lineContinuations(s_lineContinuationCacheSize) As LineContinuationTrivia
 
-        Public Sub New(treeInfo As TreeData, options As AnalyzerConfigOptions)
+        Public Sub New(treeInfo As TreeData, options As SyntaxFormattingOptions)
             MyBase.New(treeInfo, options)
         End Sub
 
diff --git a/src/Workspaces/VisualBasic/Portable/Formatting/Engine/VisualBasicFormatEngine.vb b/src/Workspaces/VisualBasic/Portable/Formatting/Engine/VisualBasicFormatEngine.vb
index 8402bd704c19d..9468229f60b08 100644
--- a/src/Workspaces/VisualBasic/Portable/Formatting/Engine/VisualBasicFormatEngine.vb
+++ b/src/Workspaces/VisualBasic/Portable/Formatting/Engine/VisualBasicFormatEngine.vb
@@ -13,15 +13,15 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
         Inherits AbstractFormatEngine
 
         Public Sub New(node As SyntaxNode,
-                       options As AnalyzerConfigOptions,
+                       options As SyntaxFormattingOptions,
                        formattingRules As IEnumerable(Of AbstractFormattingRule),
-                       token1 As SyntaxToken,
-                       token2 As SyntaxToken)
+                       startToken As SyntaxToken,
+                       endToken As SyntaxToken)
             MyBase.New(TreeData.Create(node),
                        options,
                        formattingRules,
-                       token1,
-                       token2)
+                       startToken,
+                       endToken)
         End Sub
 
         Friend Overrides ReadOnly Property HeaderFacts As IHeaderFacts = VisualBasicHeaderFacts.Instance
diff --git a/src/Workspaces/VisualBasic/Portable/Formatting/Engine/VisualBasicStructuredTriviaFormatEngine.vb b/src/Workspaces/VisualBasic/Portable/Formatting/Engine/VisualBasicStructuredTriviaFormatEngine.vb
index 717a946024a36..05af2af717c39 100644
--- a/src/Workspaces/VisualBasic/Portable/Formatting/Engine/VisualBasicStructuredTriviaFormatEngine.vb
+++ b/src/Workspaces/VisualBasic/Portable/Formatting/Engine/VisualBasicStructuredTriviaFormatEngine.vb
@@ -14,7 +14,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
 
         Public Shared Function FormatTrivia(trivia As SyntaxTrivia,
                                       initialColumn As Integer,
-                                      options As AnalyzerConfigOptions,
+                                      options As SyntaxFormattingOptions,
                                       formattingRules As ChainedFormattingRules,
                                       cancellationToken As CancellationToken) As IFormattingResult
             Dim root = trivia.GetStructure()
@@ -24,7 +24,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
 
         Private Sub New(trivia As SyntaxTrivia,
                        initialColumn As Integer,
-                       options As AnalyzerConfigOptions,
+                       options As SyntaxFormattingOptions,
                        formattingRules As ChainedFormattingRules,
                        token1 As SyntaxToken,
                        token2 As SyntaxToken)
diff --git a/src/Workspaces/VisualBasic/Portable/Formatting/VisualBasicSyntaxFormattingService.vb b/src/Workspaces/VisualBasic/Portable/Formatting/VisualBasicSyntaxFormattingService.vb
index cd78605300702..b99a58ca7275a 100644
--- a/src/Workspaces/VisualBasic/Portable/Formatting/VisualBasicSyntaxFormattingService.vb
+++ b/src/Workspaces/VisualBasic/Portable/Formatting/VisualBasicSyntaxFormattingService.vb
@@ -54,8 +54,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Formatting
             Return New AggregatedFormattingResult(node, results, formattingSpans)
         End Function
 
-        Protected Overrides Function Format(root As SyntaxNode, options As AnalyzerConfigOptions, formattingRules As IEnumerable(Of AbstractFormattingRule), token1 As SyntaxToken, token2 As SyntaxToken, cancellationToken As CancellationToken) As AbstractFormattingResult
-            Return New VisualBasicFormatEngine(root, options, formattingRules, token1, token2).Format(cancellationToken)
+        Protected Overrides Function Format(root As SyntaxNode, options As SyntaxFormattingOptions, formattingRules As IEnumerable(Of AbstractFormattingRule), startToken As SyntaxToken, endToken As SyntaxToken, cancellationToken As CancellationToken) As AbstractFormattingResult
+            Return New VisualBasicFormatEngine(root, options, formattingRules, startToken, endToken).Format(cancellationToken)
         End Function
     End Class
 End Namespace
diff --git a/src/Workspaces/VisualBasic/Portable/Indentation/VisualBasicIndentationService.Indenter.vb b/src/Workspaces/VisualBasic/Portable/Indentation/VisualBasicIndentationService.Indenter.vb
index d4006252b31a4..87abb127f201d 100644
--- a/src/Workspaces/VisualBasic/Portable/Indentation/VisualBasicIndentationService.Indenter.vb
+++ b/src/Workspaces/VisualBasic/Portable/Indentation/VisualBasicIndentationService.Indenter.vb
@@ -13,15 +13,14 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Indentation
     Partial Friend Class VisualBasicIndentationService
         Protected Overrides Function ShouldUseTokenIndenter(indenter As Indenter, ByRef token As SyntaxToken) As Boolean
             Return ShouldUseSmartTokenFormatterInsteadOfIndenter(
-                indenter.Rules, indenter.Root, indenter.LineToBeIndented, indenter.OptionService, indenter.OptionSet, token)
+                indenter.Rules, indenter.Root, indenter.LineToBeIndented, indenter.Options.FormattingOptions, token)
         End Function
 
         Protected Overrides Function CreateSmartTokenFormatter(indenter As Indenter) As ISmartTokenFormatter
             Dim services = indenter.Document.Project.Solution.Workspace.Services
             Dim formattingRuleFactory = services.GetService(Of IHostDependentFormattingRuleFactoryService)()
-            Dim rules = {New SpecialFormattingRule(indenter.OptionSet.GetOption(FormattingOptions.SmartIndent, indenter.Document.Root.Language)), formattingRuleFactory.CreateRule(indenter.Document.Document, indenter.LineToBeIndented.Start)}.Concat(Formatter.GetDefaultFormattingRules(indenter.Document.Document))
-            Dim options = SyntaxFormattingOptions.Create(indenter.OptionSet, services, indenter.Document.Project.Language)
-            Return New VisualBasicSmartTokenFormatter(options, rules, indenter.Root)
+            Dim rules = {New SpecialFormattingRule(indenter.Options.AutoFormattingOptions.IndentStyle), formattingRuleFactory.CreateRule(indenter.Document.Document, indenter.LineToBeIndented.Start)}.Concat(Formatter.GetDefaultFormattingRules(indenter.Document.Document))
+            Return New VisualBasicSmartTokenFormatter(indenter.Options.FormattingOptions, rules, indenter.Root)
         End Function
 
         Protected Overrides Function GetDesiredIndentationWorker(
@@ -101,7 +100,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Indentation
 
             Dim queryNode = token.GetAncestor(Of QueryClauseSyntax)()
             If queryNode IsNot Nothing Then
-                Dim subQuerySpaces = If(token.IsLastTokenOfStatement(), 0, indenter.OptionSet.GetOption(FormattingOptions.IndentationSize, token.Language))
+                Dim subQuerySpaces = If(token.IsLastTokenOfStatement(), 0, indenter.Options.FormattingOptions.GetOption(FormattingOptions2.IndentationSize))
                 Return indenter.GetIndentationOfToken(queryNode.GetFirstToken(includeZeroWidth:=True), subQuerySpaces)
             End If
 
@@ -272,7 +271,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Indentation
             If statement Is Nothing Then
                 If trivia.Kind <> SyntaxKind.None Then
                     Dim triviaLine = sourceText.Lines.GetLineFromPosition(trivia.SpanStart)
-                    Return indenter.GetIndentationOfLine(triviaLine, indenter.OptionSet.GetOption(FormattingOptions.IndentationSize, token.Language))
+                    Return indenter.GetIndentationOfLine(triviaLine, indenter.Options.FormattingOptions.GetOption(FormattingOptions2.IndentationSize))
                 End If
 
                 ' no base line to use to calculate the indentation
@@ -294,7 +293,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Indentation
         Private Shared Function GetIndentationFromTwoLines(indenter As Indenter, firstLine As TextLine, secondLine As TextLine, token As SyntaxToken, position As Integer) As IndentationResult
             If firstLine.LineNumber = secondLine.LineNumber Then
                 ' things are on same line, put the indentation size
-                Return GetIndentationOfCurrentPosition(indenter, token, position, indenter.OptionSet.GetOption(FormattingOptions.IndentationSize, token.Language))
+                Return GetIndentationOfCurrentPosition(indenter, token, position, indenter.Options.FormattingOptions.GetOption(FormattingOptions2.IndentationSize))
             End If
 
             ' multiline
diff --git a/src/Workspaces/VisualBasic/Portable/Indentation/VisualBasicIndentationService.vb b/src/Workspaces/VisualBasic/Portable/Indentation/VisualBasicIndentationService.vb
index 70fc7b223c7ac..99d57b198ddf9 100644
--- a/src/Workspaces/VisualBasic/Portable/Indentation/VisualBasicIndentationService.vb
+++ b/src/Workspaces/VisualBasic/Portable/Indentation/VisualBasicIndentationService.vb
@@ -40,8 +40,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Indentation
                 formattingRules As IEnumerable(Of AbstractFormattingRule),
                 root As CompilationUnitSyntax,
                 line As TextLine,
-                optionService As IOptionService,
-                optionSet As OptionSet,
+                options As SyntaxFormattingOptions,
                 ByRef token As SyntaxToken,
                 Optional neverUseWhenHavingMissingToken As Boolean = True) As Boolean
 
@@ -87,8 +86,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Indentation
                 Return statement.GetFirstToken() = token
             End If
 
-            Dim options = optionSet.AsAnalyzerConfigOptions(optionService, root.Language)
-
             ' now, regular case. ask formatting rule to see whether we should use token formatter or not
             Dim lineOperation = FormattingOperations.GetAdjustNewLinesOperation(formattingRules, previousToken, token, options)
             If lineOperation IsNot Nothing AndAlso lineOperation.Option <> AdjustNewLinesOption.ForceLinesIfOnSingleLine Then

From 497011dc85a2a90563282dbaade2d1c0194f21d2 Mon Sep 17 00:00:00 2001
From: Rikki Gibson <rigibson@microsoft.com>
Date: Tue, 18 Jan 2022 09:50:04 -0800
Subject: [PATCH 436/444] Handle global methods in GetEmbeddedTypeForMember
 (#58825)

---
 .../Emitter/NoPia/EmbeddedTypesManager.cs     |  6 +++
 .../CodeGenNullCheckedParameterTests.cs       | 39 +++++++++++++++++++
 2 files changed, 45 insertions(+)

diff --git a/src/Compilers/CSharp/Portable/Emitter/NoPia/EmbeddedTypesManager.cs b/src/Compilers/CSharp/Portable/Emitter/NoPia/EmbeddedTypesManager.cs
index 2362945a2ba54..2fb39014cd600 100644
--- a/src/Compilers/CSharp/Portable/Emitter/NoPia/EmbeddedTypesManager.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/NoPia/EmbeddedTypesManager.cs
@@ -589,6 +589,12 @@ protected override EmbeddedType GetEmbeddedTypeForMember(SymbolAdapter member, S
             Debug.Assert(member.AdaptedSymbol.IsDefinition);
             Debug.Assert(ModuleBeingBuilt.SourceModule.AnyReferencedAssembliesAreLinked);
 
+            if (member.AdaptedSymbol.OriginalDefinition is SynthesizedGlobalMethodSymbol)
+            {
+                // No need to embed an internal type from current assembly
+                return null;
+            }
+
             NamedTypeSymbol namedType = member.AdaptedSymbol.ContainingType;
 
             if (IsValidEmbeddableType(namedType, syntaxNodeOpt, diagnostics, this))
diff --git a/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenNullCheckedParameterTests.cs b/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenNullCheckedParameterTests.cs
index 647511c5f8785..fe4b0498ba9a3 100644
--- a/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenNullCheckedParameterTests.cs
+++ b/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenNullCheckedParameterTests.cs
@@ -2029,5 +2029,44 @@ .maxstack  2
   IL_0024:  ret
 }");
         }
+
+        [Fact, WorkItem(58824, "https://github.com/dotnet/roslyn/issues/58824")]
+        public void TestWithEmbeddedReference()
+        {
+            var source = @"
+using System;
+
+C.M(""a"");
+Console.Write(1);
+try
+{
+    C.M(null);
+    Console.Write(0);
+}
+catch
+{
+    Console.Write(2);
+}
+
+class C
+{
+    public static void M(string s!!)
+    {
+    }
+}
+";
+            var verifier = CompileAndVerify(source, references: new[] { TestReferences.SymbolsTests.NoPia.GeneralPia.WithEmbedInteropTypes(true) }, expectedOutput: "12");
+            verifier.VerifyDiagnostics();
+            verifier.VerifyIL("C.M", @"
+{
+    // Code size       12 (0xc)
+    .maxstack  2
+    IL_0000:  ldarg.0
+    IL_0001:  ldstr      ""s""
+    IL_0006:  call       ""ThrowIfNull""
+    IL_000b:  ret
+}
+");
+        }
     }
 }

From d566086d7aed93fa7a6f479bb4ce6fb8018fc82d Mon Sep 17 00:00:00 2001
From: Youssef Victor <youssefvictor00@gmail.com>
Date: Tue, 18 Jan 2022 20:08:36 +0200
Subject: [PATCH 437/444] Fix ParameterSyntax.Update to account for '!!'
 (#58912)

---
 .../CSharp/Portable/Syntax/ParameterSyntax.cs          |  6 +-----
 .../CSharp/Test/Syntax/Syntax/SyntaxNodeTests.cs       | 10 ++++++++++
 2 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Syntax/ParameterSyntax.cs b/src/Compilers/CSharp/Portable/Syntax/ParameterSyntax.cs
index 8097295cb2fe1..cc15e1bd6bcdd 100644
--- a/src/Compilers/CSharp/Portable/Syntax/ParameterSyntax.cs
+++ b/src/Compilers/CSharp/Portable/Syntax/ParameterSyntax.cs
@@ -2,10 +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 Microsoft.CodeAnalysis.CSharp.Symbols;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Text;
-
 namespace Microsoft.CodeAnalysis.CSharp.Syntax
 {
     public partial class ParameterSyntax
@@ -20,7 +16,7 @@ internal bool IsArgList
 
         public ParameterSyntax Update(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, TypeSyntax type, SyntaxToken identifier, EqualsValueClauseSyntax @default)
         {
-            return Update(attributeLists, modifiers, type, identifier, exclamationExclamationToken: default, @default);
+            return Update(attributeLists, modifiers, type, identifier, exclamationExclamationToken: ExclamationExclamationToken, @default);
         }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Syntax/Syntax/SyntaxNodeTests.cs b/src/Compilers/CSharp/Test/Syntax/Syntax/SyntaxNodeTests.cs
index e5c6579071790..f2f40caaf5cb2 100644
--- a/src/Compilers/CSharp/Test/Syntax/Syntax/SyntaxNodeTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Syntax/SyntaxNodeTests.cs
@@ -3802,5 +3802,15 @@ public void TestStackAllocKeywordUpdate()
             var newExpression = expression.Update(replacedKeyword, expression.Type).ToString();
             Assert.Equal("stackalloc int[50]", newExpression);
         }
+
+        [Fact]
+        [WorkItem(58597, "https://github.com/dotnet/roslyn/issues/58597")]
+        public void TestExclamationExclamationUpdate()
+        {
+            var text = "(string s!!)";
+            var parameter = SyntaxFactory.ParseParameterList(text).Parameters[0];
+            var newParameter = parameter.Update(parameter.AttributeLists, parameter.Modifiers, parameter.Type, parameter.Identifier, parameter.Default).ToString();
+            Assert.Equal("string s!!", newParameter);
+        }
     }
 }

From 14103f7397037cef6029a59f26ecfedffc36626f Mon Sep 17 00:00:00 2001
From: Youssef1313 <youssefvictor00@gmail.com>
Date: Tue, 18 Jan 2022 20:10:41 +0200
Subject: [PATCH 438/444] Fix 'add accessibility' false positive with abstract
 statics in interfaces

---
 .../AddAccessibilityModifiersTests.cs         | 30 +++++++++++++++++++
 .../SyntaxFacts/CSharpAccessibilityFacts.cs   |  8 +++--
 2 files changed, 36 insertions(+), 2 deletions(-)

diff --git a/src/Analyzers/CSharp/Tests/AddAccessibilityModifiers/AddAccessibilityModifiersTests.cs b/src/Analyzers/CSharp/Tests/AddAccessibilityModifiers/AddAccessibilityModifiersTests.cs
index 464d671732794..29134c5de0c6b 100644
--- a/src/Analyzers/CSharp/Tests/AddAccessibilityModifiers/AddAccessibilityModifiersTests.cs
+++ b/src/Analyzers/CSharp/Tests/AddAccessibilityModifiers/AddAccessibilityModifiersTests.cs
@@ -581,5 +581,35 @@ public partial class C
 
             await test.RunAsync();
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddAccessibilityModifiers)]
+        [WorkItem(58914, "https://github.com/dotnet/roslyn/issues/58914")]
+        public async Task TestStaticOperatorInInterface()
+        {
+            var source = @"
+internal interface I<T> where T : I<T>
+{
+    abstract static int operator +(T x);
+}
+
+internal class C : I<C>
+{
+    static int I<C>.operator +(C x)
+    {
+        throw new System.NotImplementedException();
+    }
+}
+";
+
+            var test = new VerifyCS.Test
+            {
+                TestCode = source,
+                FixedCode = source,
+                LanguageVersion = CodeAnalysis.CSharp.LanguageVersion.Preview,
+                ReferenceAssemblies = Testing.ReferenceAssemblies.Net.Net60
+            };
+
+            await test.RunAsync();
+        }
     }
 }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpAccessibilityFacts.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpAccessibilityFacts.cs
index dc4cb58f5ef21..86cfbb6cfaa17 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpAccessibilityFacts.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpAccessibilityFacts.cs
@@ -34,8 +34,6 @@ public bool CanHaveAccessibility(SyntaxNode declaration)
                 case SyntaxKind.InterfaceDeclaration:
                 case SyntaxKind.EnumDeclaration:
                 case SyntaxKind.DelegateDeclaration:
-                case SyntaxKind.OperatorDeclaration:
-                case SyntaxKind.ConversionOperatorDeclaration:
                 case SyntaxKind.FieldDeclaration:
                 case SyntaxKind.EventFieldDeclaration:
                 case SyntaxKind.GetAccessorDeclaration:
@@ -60,6 +58,12 @@ public bool CanHaveAccessibility(SyntaxNode declaration)
                 case SyntaxKind.IndexerDeclaration:
                     return ((IndexerDeclarationSyntax)declaration).ExplicitInterfaceSpecifier == null;
 
+                case SyntaxKind.OperatorDeclaration:
+                    return ((OperatorDeclarationSyntax)declaration).ExplicitInterfaceSpecifier == null;
+
+                case SyntaxKind.ConversionOperatorDeclaration:
+                    return ((ConversionOperatorDeclarationSyntax)declaration).ExplicitInterfaceSpecifier == null;
+
                 case SyntaxKind.MethodDeclaration:
                     var method = (MethodDeclarationSyntax)declaration;
                     if (method.ExplicitInterfaceSpecifier != null)

From 8ea5c389b2ccf92aa27a0d937ec9428b7bfa21e4 Mon Sep 17 00:00:00 2001
From: Rikki Gibson <rigibson@microsoft.com>
Date: Tue, 18 Jan 2022 10:42:35 -0800
Subject: [PATCH 439/444] Update Language Feature Status.md (#58919)

---
 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 09c5fb02a475b..d601f34990264 100644
--- a/docs/Language Feature Status.md	
+++ b/docs/Language Feature Status.md	
@@ -12,7 +12,7 @@ efforts behind them.
 | ------- | ------ | ----- | --------- | -------- | --------- |
 | [Newlines in interpolations](https://github.com/dotnet/csharplang/issues/4935) | main | [Merged in 17.1p1](https://github.com/dotnet/roslyn/issues/57154) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) | [jcouv](https://github.com/jcouv), [chsienki](https://github.com/chsienki) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) |
 | [List patterns](https://github.com/dotnet/csharplang/issues/3435) | [list-patterns](https://github.com/dotnet/roslyn/tree/features/list-patterns) | [Merged in 17.1p2](https://github.com/dotnet/roslyn/issues/51289) | [alrz](https://github.com/alrz) | [jcouv](https://github.com/jcouv), [333fred](https://github.com/333fred) | [333fred](https://github.com/333fred) |
-| [Parameter null-checking](https://github.com/dotnet/csharplang/issues/2145) | [param-nullchecking](https://github.com/dotnet/roslyn/tree/features/param-nullchecking) | [In Progress](https://github.com/dotnet/roslyn/issues/36024) | [RikkiGibson](https://github.com/RikkiGibson), [fayrose](https://github.com/fayrose) | [cston](https://github.com/cston), [chsienki](https://github.com/chsienki) | [jaredpar](https://github.com/jaredpar) |
+| [Parameter null-checking](https://github.com/dotnet/csharplang/issues/2145) | [param-nullchecking](https://github.com/dotnet/roslyn/tree/features/param-nullchecking) | [Merged in 17.1p3](https://github.com/dotnet/roslyn/issues/36024) | [RikkiGibson](https://github.com/RikkiGibson), [fayrose](https://github.com/fayrose) | [cston](https://github.com/cston), [chsienki](https://github.com/chsienki) | [jaredpar](https://github.com/jaredpar) |
 | [Raw string literals](https://github.com/dotnet/csharplang/issues/4304) | [RawStringLiterals](https://github.com/dotnet/roslyn/tree/features/RawStringLiterals) | [In Progress](https://github.com/dotnet/roslyn/issues/55306) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) | [jcouv](https://github.com/jcouv) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) |
 | [nameof(parameter)](https://github.com/dotnet/csharplang/issues/373) | main | [In Progress](https://github.com/dotnet/roslyn/issues/40524) | [jcouv](https://github.com/jcouv) | TBD | [jcouv](https://github.com/jcouv) |
 | [Relax ordering of `ref` and `partial` modifiers](https://github.com/dotnet/csharplang/issues/946) | [ref-partial](https://github.com/dotnet/roslyn/tree/features/ref-partial) | In Progress | [alrz](https://github.com/alrz) | [gafter](https://github.com/gafter) | [jcouv](https://github.com/jcouv) |

From 6be7f048e3cbb7a48cddcdef33d274ab40d3f799 Mon Sep 17 00:00:00 2001
From: Rikki Gibson <rigibson@microsoft.com>
Date: Tue, 18 Jan 2022 12:18:48 -0800
Subject: [PATCH 440/444] Fix emit of param-nullchecking on async methods
 (#58822)

---
 .../Portable/Compiler/MethodCompiler.cs       |  30 +-
 .../Lowering/LocalRewriter/LocalRewriter.cs   |  15 +-
 .../LocalRewriter_NullChecking.cs             |  29 +-
 .../StateMachineRewriter.cs                   |   3 +-
 .../CodeGenNullCheckedParameterTests.cs       | 356 ++++++++++++++++--
 5 files changed, 342 insertions(+), 91 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
index 8194f135ac121..e3161bc1b2e79 100644
--- a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
+++ b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
@@ -747,6 +747,14 @@ private void CompileSynthesizedMethods(TypeCompilationState compilationState)
                             stateMachine = stateMachine ?? asyncStateMachine;
                         }
 
+                        var factory = new SyntheticBoundNodeFactory(method, methodWithBody.Body.Syntax, compilationState, diagnosticsThisMethod);
+                        var nullCheckStatements = LocalRewriter.ConstructNullCheckedStatementList(method.Parameters, factory);
+                        if (!nullCheckStatements.IsEmpty)
+                        {
+                            loweredBody = factory.StatementList(nullCheckStatements.Concat(loweredBody));
+                        }
+                        SetGlobalErrorIfTrue(nullCheckStatements.HasErrors() || diagnosticsThisMethod.HasAnyErrors());
+
                         if (_emitMethodBodies && !diagnosticsThisMethod.HasAnyErrors() && !_globalHasErrors)
                         {
                             emittedBody = GenerateMethodBody(
@@ -1293,22 +1301,14 @@ forSemanticModel.Syntax is { } semanticModelSyntax &&
 
                             var factory = new SyntheticBoundNodeFactory(methodSymbol, syntax, compilationState, diagsForCurrentMethod);
 
-                            // Iterators handled in IteratorRewriter.cs
-                            if (!methodSymbol.IsIterator)
+                            var nullCheckStatements = LocalRewriter.ConstructNullCheckedStatementList(methodSymbol.Parameters, factory);
+                            boundStatements = nullCheckStatements.Concat(boundStatements);
+                            hasErrors = nullCheckStatements.HasErrors() || diagsForCurrentMethod.HasAnyErrors();
+                            SetGlobalErrorIfTrue(hasErrors);
+                            if (hasErrors)
                             {
-                                var boundStatementsWithNullCheck = LocalRewriter.TryConstructNullCheckedStatementList(methodSymbol.Parameters, boundStatements, factory);
-
-                                if (!boundStatementsWithNullCheck.IsDefault)
-                                {
-                                    boundStatements = boundStatementsWithNullCheck;
-                                    hasErrors = boundStatementsWithNullCheck.HasErrors() || diagsForCurrentMethod.HasAnyErrors();
-                                    SetGlobalErrorIfTrue(hasErrors);
-                                    if (hasErrors)
-                                    {
-                                        _diagnostics.AddRange(diagsForCurrentMethod);
-                                        return;
-                                    }
-                                }
+                                _diagnostics.AddRange(diagsForCurrentMethod);
+                                return;
                             }
                         }
                         if (_emitMethodBodies && (!(methodSymbol is SynthesizedStaticConstructor cctor) || cctor.ShouldEmit(processedInitializers.BoundInitializers)))
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
index d39ee387058da..f4e50554a1d85 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
@@ -263,12 +263,7 @@ public override BoundNode VisitLambda(BoundLambda node)
                     _instrumenter = RemoveDynamicAnalysisInjectors(oldInstrumenter);
                 }
 
-                var visited = (BoundLambda)base.VisitLambda(node)!;
-                if (RewriteNullChecking(visited.Body) is BoundBlock newBody)
-                {
-                    visited = visited.Update(visited.UnboundLambda, visited.Symbol, newBody, visited.Diagnostics, visited.Binder, visited.Type);
-                }
-                return visited;
+                return base.VisitLambda(node)!;
             }
             finally
             {
@@ -333,13 +328,7 @@ static bool hasReturnTypeOrParameter(LocalFunctionSymbol localFunction, Func<Typ
                     _dynamicFactory = new LoweredDynamicOperationFactory(_factory, _dynamicFactory.MethodOrdinal, localFunctionOrdinal);
                 }
 
-                var visited = (BoundLocalFunctionStatement)base.VisitLocalFunctionStatement(node)!;
-
-                if (!localFunction.IsIterator && RewriteNullChecking(visited.Body) is BoundBlock newBody)
-                {
-                    visited = visited.Update(localFunction, newBody, null);
-                }
-                return visited;
+                return base.VisitLocalFunctionStatement(node)!;
             }
             finally
             {
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_NullChecking.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_NullChecking.cs
index 406e106f62ad5..3010abf5a7816 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_NullChecking.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_NullChecking.cs
@@ -11,25 +11,9 @@ namespace Microsoft.CodeAnalysis.CSharp
 {
     internal sealed partial class LocalRewriter
     {
-        private BoundBlock? RewriteNullChecking(BoundBlock? block)
-        {
-            if (block is null)
-            {
-                return null;
-            }
-
-            Debug.Assert(_factory.CurrentFunction is not null);
-            var statementList = TryConstructNullCheckedStatementList(_factory.CurrentFunction.Parameters, block.Statements, _factory);
-            if (statementList.IsDefault)
-            {
-                return null;
-            }
-            return _factory.Block(block.Locals, statementList);
-        }
-
-        internal static ImmutableArray<BoundStatement> TryConstructNullCheckedStatementList(ImmutableArray<ParameterSymbol> parameters,
-                                                                                         ImmutableArray<BoundStatement> existingStatements,
-                                                                                         SyntheticBoundNodeFactory factory)
+        internal static ImmutableArray<BoundStatement> ConstructNullCheckedStatementList(
+            ImmutableArray<ParameterSymbol> parameters,
+            SyntheticBoundNodeFactory factory)
         {
             ArrayBuilder<BoundStatement>? statementList = null;
             MethodSymbol? throwIfNullMethod = null;
@@ -46,13 +30,8 @@ internal static ImmutableArray<BoundStatement> TryConstructNullCheckedStatementL
                     statementList.Add(constructedIf);
                 }
             }
-            if (statementList is null)
-            {
-                return default;
-            }
 
-            statementList.AddRange(existingStatements);
-            return statementList.ToImmutableAndFree();
+            return statementList?.ToImmutableAndFree() ?? ImmutableArray<BoundStatement>.Empty;
         }
 
         private static BoundStatement ConstructNullCheckHelperCall(ParameterSymbol parameter, ref MethodSymbol? throwIfNullMethod, SyntheticBoundNodeFactory factory)
diff --git a/src/Compilers/CSharp/Portable/Lowering/StateMachineRewriter/StateMachineRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/StateMachineRewriter/StateMachineRewriter.cs
index df7008cb75f7e..0616f66995d3a 100644
--- a/src/Compilers/CSharp/Portable/Lowering/StateMachineRewriter/StateMachineRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/StateMachineRewriter/StateMachineRewriter.cs
@@ -320,8 +320,7 @@ protected BoundStatement GenerateParameterStorage(LocalSymbol stateMachineVariab
             }
 
             var builtBody = bodyBuilder.ToImmutableAndFree();
-            ImmutableArray<BoundStatement> newBody = LocalRewriter.TryConstructNullCheckedStatementList(method.Parameters, builtBody, F);
-            return newBody.IsDefault ? F.Block(builtBody) : F.Block(ImmutableArray.Create(stateMachineVariable), newBody);
+            return F.Block(builtBody);
         }
 
         protected SynthesizedImplementationMethod OpenMethodImplementation(
diff --git a/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenNullCheckedParameterTests.cs b/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenNullCheckedParameterTests.cs
index fe4b0498ba9a3..cd14d272e8954 100644
--- a/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenNullCheckedParameterTests.cs
+++ b/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenNullCheckedParameterTests.cs
@@ -1308,11 +1308,11 @@ public static void Main()
 {
   // Code size       26 (0x1a)
   .maxstack  3
-  IL_0000:  ldc.i4.s   -2
-  IL_0002:  newobj     ""C.<GetChars>d__0..ctor(int)""
-  IL_0007:  ldarg.1
-  IL_0008:  ldstr      ""s""
-  IL_000d:  call       ""ThrowIfNull""
+  IL_0000:  ldarg.1
+  IL_0001:  ldstr      ""s""
+  IL_0006:  call       ""ThrowIfNull""
+  IL_000b:  ldc.i4.s   -2
+  IL_000d:  newobj     ""C.<GetChars>d__0..ctor(int)""
   IL_0012:  dup
   IL_0013:  ldarg.1
   IL_0014:  stfld      ""string C.<GetChars>d__0.<>3__s""
@@ -1343,11 +1343,11 @@ async IAsyncEnumerable<char> GetChars(string s!!, Task t)
 {
   // Code size       33 (0x21)
   .maxstack  3
-  IL_0000:  ldc.i4.s   -2
-  IL_0002:  newobj     ""C.<GetChars>d__0..ctor(int)""
-  IL_0007:  ldarg.1
-  IL_0008:  ldstr      ""s""
-  IL_000d:  call       ""ThrowIfNull""
+  IL_0000:  ldarg.1
+  IL_0001:  ldstr      ""s""
+  IL_0006:  call       ""ThrowIfNull""
+  IL_000b:  ldc.i4.s   -2
+  IL_000d:  newobj     ""C.<GetChars>d__0..ctor(int)""
   IL_0012:  dup
   IL_0013:  ldarg.1
   IL_0014:  stfld      ""string C.<GetChars>d__0.<>3__s""
@@ -1376,18 +1376,17 @@ IEnumerable<char> GetChars(string s!!)
             }
         }
     }
-
 }";
             var compilation = CompileAndVerify(source, parseOptions: TestOptions.RegularPreview);
             compilation.VerifyIL("Iterators.<Use>g__GetChars|0_0(string)", @"
 {
   // Code size       26 (0x1a)
   .maxstack  3
-  IL_0000:  ldc.i4.s   -2
-  IL_0002:  newobj     ""Iterators.<<Use>g__GetChars|0_0>d..ctor(int)""
-  IL_0007:  ldarg.0
-  IL_0008:  ldstr      ""s""
-  IL_000d:  call       ""ThrowIfNull""
+  IL_0000:  ldarg.0
+  IL_0001:  ldstr      ""s""
+  IL_0006:  call       ""ThrowIfNull""
+  IL_000b:  ldc.i4.s   -2
+  IL_000d:  newobj     ""Iterators.<<Use>g__GetChars|0_0>d..ctor(int)""
   IL_0012:  dup
   IL_0013:  ldarg.0
   IL_0014:  stfld      ""string Iterators.<<Use>g__GetChars|0_0>d.<>3__s""
@@ -1399,12 +1398,26 @@ .maxstack  3
         public void TestNullCheckedEnumeratorInLocalFunction()
         {
             var source = @"
+using System;
 using System.Collections.Generic;
+
+Iterators.Use();
+
 class Iterators
 {
-    void Use()
+    public static void Use()
     {
         IEnumerator<char> e = GetChars(""hello"");
+        Console.Write(1);
+
+        try
+        {
+            GetChars(null!);
+        }
+        catch (ArgumentNullException)
+        {
+            Console.Write(2);
+        }
         IEnumerator<char> GetChars(string s!!)
         {
             foreach (var c in s)
@@ -1415,16 +1428,16 @@ IEnumerator<char> GetChars(string s!!)
     }
 
 }";
-            var compilation = CompileAndVerify(source, parseOptions: TestOptions.RegularPreview);
-            compilation.VerifyIL("Iterators.<Use>g__GetChars|0_0(string)", @"
+            var verifier = CompileAndVerify(source, parseOptions: TestOptions.RegularPreview, expectedOutput: "12");
+            verifier.VerifyIL("Iterators.<Use>g__GetChars|0_0(string)", @"
 {
   // Code size       25 (0x19)
   .maxstack  3
-  IL_0000:  ldc.i4.0
-  IL_0001:  newobj     ""Iterators.<<Use>g__GetChars|0_0>d..ctor(int)""
-  IL_0006:  ldarg.0
-  IL_0007:  ldstr      ""s""
-  IL_000c:  call       ""ThrowIfNull""
+  IL_0000:  ldarg.0
+  IL_0001:  ldstr      ""s""
+  IL_0006:  call       ""ThrowIfNull""
+  IL_000b:  ldc.i4.0
+  IL_000c:  newobj     ""Iterators.<<Use>g__GetChars|0_0>d..ctor(int)""
   IL_0011:  dup
   IL_0012:  ldarg.0
   IL_0013:  stfld      ""string Iterators.<<Use>g__GetChars|0_0>d.s""
@@ -1537,12 +1550,12 @@ static IEnumerable<char> GetChars(string s!!)
             CompileAndVerify(source, parseOptions: TestOptions.RegularPreview).VerifyIL("C.GetChars(string)", @"
 {
   // Code size       19 (0x13)
-  .maxstack  3
-  IL_0000:  ldc.i4.s   -2
-  IL_0002:  newobj     ""C.<GetChars>d__1..ctor(int)""
-  IL_0007:  ldarg.0
-  IL_0008:  ldstr      ""s""
-  IL_000d:  call       ""ThrowIfNull""
+  .maxstack  2
+  IL_0000:  ldarg.0
+  IL_0001:  ldstr      ""s""
+  IL_0006:  call       ""ThrowIfNull""
+  IL_000b:  ldc.i4.s   -2
+  IL_000d:  newobj     ""C.<GetChars>d__1..ctor(int)""
   IL_0012:  ret
 }");
         }
@@ -1563,12 +1576,12 @@ static IEnumerator<char> GetChars(string s!!)
             CompileAndVerify(source, parseOptions: TestOptions.RegularPreview).VerifyIL("C.GetChars(string)", @"
 {
   // Code size       18 (0x12)
-  .maxstack  3
-  IL_0000:  ldc.i4.0
-  IL_0001:  newobj     ""C.<GetChars>d__1..ctor(int)""
-  IL_0006:  ldarg.0
-  IL_0007:  ldstr      ""s""
-  IL_000c:  call       ""ThrowIfNull""
+  .maxstack  2
+  IL_0000:  ldarg.0
+  IL_0001:  ldstr      ""s""
+  IL_0006:  call       ""ThrowIfNull""
+  IL_000b:  ldc.i4.0
+  IL_000c:  newobj     ""C.<GetChars>d__1..ctor(int)""
   IL_0011:  ret
 }");
         }
@@ -2066,6 +2079,277 @@ .maxstack  2
     IL_0006:  call       ""ThrowIfNull""
     IL_000b:  ret
 }
+");
+        }
+
+        [Fact]
+        public void AsyncMethod_1()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+
+var c = new C();
+try
+{
+    await c.M(""a"");
+    Console.Write(1);
+}
+catch (ArgumentNullException)
+{
+    Console.Write(0);
+}
+
+try
+{
+    _ = c.M(null!);
+    Console.Write(0);
+}
+catch (ArgumentNullException)
+{
+    Console.Write(2);
+}
+
+class C
+{
+    public async Task M(string s!!)
+    {
+    }
+}
+";
+            var verifier = CompileAndVerify(source, expectedOutput: "12");
+            verifier.VerifyDiagnostics(
+                // (28,23): warning CS1998: This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.
+                //     public async Task M(string s!!)
+                Diagnostic(ErrorCode.WRN_AsyncLacksAwaits, "M").WithLocation(28, 23));
+            verifier.VerifyIL("C.M", @"
+{
+  // Code size       58 (0x3a)
+  .maxstack  2
+  .locals init (C.<M>d__0 V_0)
+  IL_0000:  ldarg.1
+  IL_0001:  ldstr      ""s""
+  IL_0006:  call       ""ThrowIfNull""
+  IL_000b:  ldloca.s   V_0
+  IL_000d:  call       ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Create()""
+  IL_0012:  stfld      ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<M>d__0.<>t__builder""
+  IL_0017:  ldloca.s   V_0
+  IL_0019:  ldc.i4.m1
+  IL_001a:  stfld      ""int C.<M>d__0.<>1__state""
+  IL_001f:  ldloca.s   V_0
+  IL_0021:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<M>d__0.<>t__builder""
+  IL_0026:  ldloca.s   V_0
+  IL_0028:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Start<C.<M>d__0>(ref C.<M>d__0)""
+  IL_002d:  ldloca.s   V_0
+  IL_002f:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<M>d__0.<>t__builder""
+  IL_0034:  call       ""System.Threading.Tasks.Task System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Task.get""
+  IL_0039:  ret
+}
+");
+        }
+
+        [Fact]
+        public void AsyncLocalFunction()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+
+await C.M();
+
+class C
+{
+    public static async Task M()
+    {
+        try
+        {
+            await local(""a"");
+            Console.Write(1);
+        }
+        catch (ArgumentNullException)
+        {
+            Console.Write(0);
+        }
+
+        try
+        {
+            _ = local(null!);
+            Console.Write(0);
+        }
+        catch (ArgumentNullException)
+        {
+            Console.Write(2);
+        }
+
+        async Task local(string s!!) { }
+    }
+}
+";
+            var verifier = CompileAndVerify(source, expectedOutput: "12");
+            verifier.VerifyDiagnostics(
+                // (31,20): warning CS1998: This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.
+                //         async Task local(string s!!) { }
+                Diagnostic(ErrorCode.WRN_AsyncLacksAwaits, "local").WithLocation(31, 20));
+            verifier.VerifyIL("C.<M>g__local|0_0", @"
+{
+    // Code size       58 (0x3a)
+    .maxstack  2
+    .locals init (C.<<M>g__local|0_0>d V_0)
+    IL_0000:  ldarg.0
+    IL_0001:  ldstr      ""s""
+    IL_0006:  call       ""ThrowIfNull""
+    IL_000b:  ldloca.s   V_0
+    IL_000d:  call       ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Create()""
+    IL_0012:  stfld      ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<<M>g__local|0_0>d.<>t__builder""
+    IL_0017:  ldloca.s   V_0
+    IL_0019:  ldc.i4.m1
+    IL_001a:  stfld      ""int C.<<M>g__local|0_0>d.<>1__state""
+    IL_001f:  ldloca.s   V_0
+    IL_0021:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<<M>g__local|0_0>d.<>t__builder""
+    IL_0026:  ldloca.s   V_0
+    IL_0028:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Start<C.<<M>g__local|0_0>d>(ref C.<<M>g__local|0_0>d)""
+    IL_002d:  ldloca.s   V_0
+    IL_002f:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<<M>g__local|0_0>d.<>t__builder""
+    IL_0034:  call       ""System.Threading.Tasks.Task System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Task.get""
+    IL_0039:  ret
+}
+");
+        }
+
+        [Fact]
+        public void AsyncLambda()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+
+await C.M();
+
+class C
+{
+    public static async Task M()
+    {
+        var lambda = async Task (string s!!) => { };
+        try
+        {
+            await lambda(""a"");
+            Console.Write(1);
+        }
+        catch (ArgumentNullException)
+        {
+            Console.Write(0);
+        }
+
+        try
+        {
+            _ = lambda(null!);
+            Console.Write(0);
+        }
+        catch (ArgumentNullException)
+        {
+            Console.Write(2);
+        }
+    }
+}
+";
+            var verifier = CompileAndVerify(source, expectedOutput: "12");
+            verifier.VerifyDiagnostics(
+                // (11,46): warning CS1998: This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.
+                //         var lambda = async Task (string s!!) => { };
+                Diagnostic(ErrorCode.WRN_AsyncLacksAwaits, "=>").WithLocation(11, 46));
+            verifier.VerifyIL("C.<>c.<M>b__0_0", @"
+{
+    // Code size       58 (0x3a)
+    .maxstack  2
+    .locals init (C.<>c.<<M>b__0_0>d V_0)
+    IL_0000:  ldarg.1
+    IL_0001:  ldstr      ""s""
+    IL_0006:  call       ""ThrowIfNull""
+    IL_000b:  ldloca.s   V_0
+    IL_000d:  call       ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Create()""
+    IL_0012:  stfld      ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<>c.<<M>b__0_0>d.<>t__builder""
+    IL_0017:  ldloca.s   V_0
+    IL_0019:  ldc.i4.m1
+    IL_001a:  stfld      ""int C.<>c.<<M>b__0_0>d.<>1__state""
+    IL_001f:  ldloca.s   V_0
+    IL_0021:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<>c.<<M>b__0_0>d.<>t__builder""
+    IL_0026:  ldloca.s   V_0
+    IL_0028:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Start<C.<>c.<<M>b__0_0>d>(ref C.<>c.<<M>b__0_0>d)""
+    IL_002d:  ldloca.s   V_0
+    IL_002f:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<>c.<<M>b__0_0>d.<>t__builder""
+    IL_0034:  call       ""System.Threading.Tasks.Task System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Task.get""
+    IL_0039:  ret
+}
+");
+        }
+
+        [Fact]
+        public void AsyncMethod_2()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+
+var c = new C();
+try
+{
+    await c.M(""a"");
+    Console.Write(1);
+}
+catch (ArgumentNullException)
+{
+    Console.Write(0);
+}
+
+try
+{
+    _ = c.M(null!);
+    Console.Write(0);
+}
+catch (ArgumentNullException)
+{
+    Console.Write(2);
+}
+
+class C
+{
+    public async Task M(string s!!)
+    {
+        if (s == """")
+            return;
+        await Task.CompletedTask;
+        return;
+    }
+}
+";
+            var verifier = CompileAndVerify(source, expectedOutput: "12");
+            verifier.VerifyDiagnostics();
+            verifier.VerifyIL("C.M", @"
+{
+  // Code size       66 (0x42)
+  .maxstack  2
+  .locals init (C.<M>d__0 V_0)
+  IL_0000:  ldarg.1
+  IL_0001:  ldstr      ""s""
+  IL_0006:  call       ""ThrowIfNull""
+  IL_000b:  ldloca.s   V_0
+  IL_000d:  call       ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Create()""
+  IL_0012:  stfld      ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<M>d__0.<>t__builder""
+  IL_0017:  ldloca.s   V_0
+  IL_0019:  ldarg.1
+  IL_001a:  stfld      ""string C.<M>d__0.s""
+  IL_001f:  ldloca.s   V_0
+  IL_0021:  ldc.i4.m1
+  IL_0022:  stfld      ""int C.<M>d__0.<>1__state""
+  IL_0027:  ldloca.s   V_0
+  IL_0029:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<M>d__0.<>t__builder""
+  IL_002e:  ldloca.s   V_0
+  IL_0030:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Start<C.<M>d__0>(ref C.<M>d__0)""
+  IL_0035:  ldloca.s   V_0
+  IL_0037:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<M>d__0.<>t__builder""
+  IL_003c:  call       ""System.Threading.Tasks.Task System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Task.get""
+  IL_0041:  ret
+}
 ");
         }
     }

From a8c25ef6e71b9607e432e5dd878a15b0d281e038 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: Tue, 18 Jan 2022 15:09:22 -0800
Subject: [PATCH 441/444] Syntax tree configuration (#58889)

* Syntax tree configuration

* Comment
---
 .../Portable/Workspace/ProjectCacheService.cs | 21 +++----
 .../SyntaxTreeConfigurationOptions.cs}        |  0
 ...ualStudioSyntaxTreeConfigurationService.cs | 59 +++++++++++++++++++
 .../CSharpSyntaxTreeFactoryService.cs         | 10 ++--
 .../IRemoteProcessTelemetryService.cs         |  6 ++
 .../Host/Caching/IProjectCacheService.cs      |  1 -
 .../AbstractSyntaxTreeFactoryService.cs       |  8 +--
 .../ISyntaxTreeConfigurationService.cs        | 14 +++++
 .../Remote/Core/ServiceHubRemoteHostClient.cs |  8 +++
 .../RemoteProcessTelemetryService.cs          | 14 +++++
 .../RemoteSyntaxTreeConfigurationService.cs   | 30 ++++++++++
 .../VisualBasicSyntaxTreeFactoryService.vb    | 10 ++--
 12 files changed, 152 insertions(+), 29 deletions(-)
 rename src/{Workspaces/Core/Portable/Workspace/WorkspaceConfigurationOptions.cs => VisualStudio/Core/Def/Telemetry/SyntaxTreeConfigurationOptions.cs} (100%)
 create mode 100644 src/VisualStudio/Core/Def/Telemetry/VisualStudioSyntaxTreeConfigurationService.cs
 create mode 100644 src/Workspaces/Core/Portable/Workspace/ISyntaxTreeConfigurationService.cs
 create mode 100644 src/Workspaces/Remote/ServiceHub/Services/ProcessTelemetry/RemoteSyntaxTreeConfigurationService.cs

diff --git a/src/Features/Core/Portable/Workspace/ProjectCacheService.cs b/src/Features/Core/Portable/Workspace/ProjectCacheService.cs
index 3205a7817bf62..55e7f36bc8034 100644
--- a/src/Features/Core/Portable/Workspace/ProjectCacheService.cs
+++ b/src/Features/Core/Portable/Workspace/ProjectCacheService.cs
@@ -26,18 +26,21 @@ internal partial class ProjectCacheService : IProjectCacheHostService
         private readonly object _gate = new();
 
         private readonly Workspace? _workspace;
+        private readonly ISyntaxTreeConfigurationService? _configurationService;
         private readonly Dictionary<ProjectId, Cache> _activeCaches = new();
 
         private readonly SimpleMRUCache? _implicitCache;
         private readonly ImplicitCacheMonitor? _implicitCacheMonitor;
 
         public ProjectCacheService(Workspace? workspace)
-            => _workspace = workspace;
-
-        public ProjectCacheService(Workspace? workspace, TimeSpan implicitCacheTimeout)
         {
             _workspace = workspace;
+            _configurationService = workspace?.Services.GetService<ISyntaxTreeConfigurationService>();
+        }
 
+        public ProjectCacheService(Workspace? workspace, TimeSpan implicitCacheTimeout)
+            : this(workspace)
+        {
             _implicitCache = new SimpleMRUCache();
             _implicitCacheMonitor = new ImplicitCacheMonitor(this, implicitCacheTimeout);
         }
@@ -46,7 +49,7 @@ public ProjectCacheService(Workspace? workspace, TimeSpan implicitCacheTimeout)
         /// Recoverable trees only save significant memory for larger trees.
         /// </summary>
         public int MinimumLengthForRecoverableTree
-            => 4 * 1024;
+            => (_configurationService?.DisableRecoverableTrees != true) ? 4 * 1024 : int.MaxValue;
 
         public bool IsImplicitCacheEmpty
         {
@@ -93,7 +96,7 @@ public IDisposable EnableCaching(ProjectId key)
         [return: NotNullIfNotNull("instance")]
         public T? CacheObjectIfCachingEnabledForKey<T>(ProjectId key, object owner, T? instance) where T : class
         {
-            if (IsEnabled())
+            if (IsEnabled)
             {
                 lock (_gate)
                 {
@@ -113,10 +116,8 @@ public IDisposable EnableCaching(ProjectId key)
             return instance;
         }
 
-        private bool IsEnabled()
-        {
-            return _workspace == null || !_workspace.Options.GetOption(WorkspaceConfigurationOptions.DisableProjectCacheService);
-        }
+        private bool IsEnabled
+            => _configurationService?.DisableProjectCacheService != true;
 
         private bool PartOfP2PReferences(ProjectId key)
         {
@@ -144,7 +145,7 @@ private bool PartOfP2PReferences(ProjectId key)
         [return: NotNullIfNotNull("instance")]
         public T? CacheObjectIfCachingEnabledForKey<T>(ProjectId key, ICachedObjectOwner owner, T? instance) where T : class
         {
-            if (IsEnabled())
+            if (IsEnabled)
             {
                 lock (_gate)
                 {
diff --git a/src/Workspaces/Core/Portable/Workspace/WorkspaceConfigurationOptions.cs b/src/VisualStudio/Core/Def/Telemetry/SyntaxTreeConfigurationOptions.cs
similarity index 100%
rename from src/Workspaces/Core/Portable/Workspace/WorkspaceConfigurationOptions.cs
rename to src/VisualStudio/Core/Def/Telemetry/SyntaxTreeConfigurationOptions.cs
diff --git a/src/VisualStudio/Core/Def/Telemetry/VisualStudioSyntaxTreeConfigurationService.cs b/src/VisualStudio/Core/Def/Telemetry/VisualStudioSyntaxTreeConfigurationService.cs
new file mode 100644
index 0000000000000..362f2871a1b15
--- /dev/null
+++ b/src/VisualStudio/Core/Def/Telemetry/VisualStudioSyntaxTreeConfigurationService.cs
@@ -0,0 +1,59 @@
+// 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.Immutable;
+using System.Composition;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Options.Providers;
+
+namespace Microsoft.VisualStudio.LanguageServices.Telemetry
+{
+    [ExportWorkspaceService(typeof(ISyntaxTreeConfigurationService)), Shared]
+    internal sealed class VisualStudioSyntaxTreeConfigurationService : ISyntaxTreeConfigurationService
+    {
+        private readonly IGlobalOptionService _globalOptions;
+
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public VisualStudioSyntaxTreeConfigurationService(IGlobalOptionService globalOptions)
+        {
+            _globalOptions = globalOptions;
+        }
+
+        public bool DisableRecoverableTrees
+            => _globalOptions.GetOption(OptionsMetadata.DisableRecoverableTrees);
+
+        public bool DisableProjectCacheService
+            => _globalOptions.GetOption(OptionsMetadata.DisableProjectCacheService);
+
+        [ExportSolutionOptionProvider, Shared]
+        internal sealed class OptionsMetadata : IOptionProvider
+        {
+            /// <summary>
+            /// Disables if the workspace creates recoverable trees when from its <see cref="ISyntaxTreeFactoryService"/>s.
+            /// </summary>
+            public static readonly Option<bool> DisableRecoverableTrees = new(
+                nameof(WorkspaceConfigurationOptions), nameof(DisableRecoverableTrees), defaultValue: false,
+                new FeatureFlagStorageLocation("Roslyn.DisableRecoverableTrees"));
+
+            public static readonly Option<bool> DisableProjectCacheService = new(
+                nameof(WorkspaceConfigurationOptions), nameof(DisableProjectCacheService), defaultValue: false,
+                new FeatureFlagStorageLocation("Roslyn.DisableProjectCacheService"));
+
+            ImmutableArray<IOption> IOptionProvider.Options { get; } = ImmutableArray.Create<IOption>(
+                DisableRecoverableTrees,
+                DisableProjectCacheService);
+
+            [ImportingConstructor]
+            [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+            public OptionsMetadata()
+            {
+            }
+        }
+    }
+}
diff --git a/src/Workspaces/CSharp/Portable/Workspace/LanguageServices/CSharpSyntaxTreeFactoryService.cs b/src/Workspaces/CSharp/Portable/Workspace/LanguageServices/CSharpSyntaxTreeFactoryService.cs
index 861faf2614ade..631875792f4b7 100644
--- a/src/Workspaces/CSharp/Portable/Workspace/LanguageServices/CSharpSyntaxTreeFactoryService.cs
+++ b/src/Workspaces/CSharp/Portable/Workspace/LanguageServices/CSharpSyntaxTreeFactoryService.cs
@@ -23,22 +23,20 @@ namespace Microsoft.CodeAnalysis.CSharp
     internal partial class CSharpSyntaxTreeFactoryServiceFactory : ILanguageServiceFactory
     {
         private static readonly CSharpParseOptions _parseOptionWithLatestLanguageVersion = CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.Preview);
-        private readonly IGlobalOptionService _optionService;
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public CSharpSyntaxTreeFactoryServiceFactory(IGlobalOptionService optionService)
+        public CSharpSyntaxTreeFactoryServiceFactory()
         {
-            _optionService = optionService;
         }
 
         public ILanguageService CreateLanguageService(HostLanguageServices provider)
-            => new CSharpSyntaxTreeFactoryService(_optionService, provider);
+            => new CSharpSyntaxTreeFactoryService(provider);
 
         private partial class CSharpSyntaxTreeFactoryService : AbstractSyntaxTreeFactoryService
         {
-            public CSharpSyntaxTreeFactoryService(IGlobalOptionService optionService, HostLanguageServices languageServices)
-                : base(optionService, languageServices)
+            public CSharpSyntaxTreeFactoryService(HostLanguageServices languageServices)
+                : base(languageServices)
             {
             }
 
diff --git a/src/Workspaces/Core/Portable/Telemetry/IRemoteProcessTelemetryService.cs b/src/Workspaces/Core/Portable/Telemetry/IRemoteProcessTelemetryService.cs
index 8374037764fc8..7dab41c7a1eaa 100644
--- a/src/Workspaces/Core/Portable/Telemetry/IRemoteProcessTelemetryService.cs
+++ b/src/Workspaces/Core/Portable/Telemetry/IRemoteProcessTelemetryService.cs
@@ -20,5 +20,11 @@ internal interface IRemoteProcessTelemetryService
         /// Initializes telemetry session.
         /// </summary>
         ValueTask InitializeTelemetrySessionAsync(int hostProcessId, string serializedSession, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Configures recoverable syntax tree creation in the process.
+        /// Called as soon as the remote process is created but can't guarantee that syntax trees have not been created beforehand.
+        /// </summary>
+        ValueTask SetSyntaxTreeConfigurationOptionsAsync(bool disableRecoverableTrees, bool disableProjectCacheService, CancellationToken cancellationToken);
     }
 }
diff --git a/src/Workspaces/Core/Portable/Workspace/Host/Caching/IProjectCacheService.cs b/src/Workspaces/Core/Portable/Workspace/Host/Caching/IProjectCacheService.cs
index e272e09b226f6..a5bb6c06248db 100644
--- a/src/Workspaces/Core/Portable/Workspace/Host/Caching/IProjectCacheService.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Host/Caching/IProjectCacheService.cs
@@ -28,7 +28,6 @@ internal interface IProjectCacheHostService : IProjectCacheService
     {
         /// <summary>
         /// The length of the source file above which a recoverable tree is created.
-        /// Overridable for testing purposes.
         /// </summary>
         int MinimumLengthForRecoverableTree { get; }
 
diff --git a/src/Workspaces/Core/Portable/Workspace/Host/SyntaxTreeFactory/AbstractSyntaxTreeFactoryService.cs b/src/Workspaces/Core/Portable/Workspace/Host/SyntaxTreeFactory/AbstractSyntaxTreeFactoryService.cs
index ad83a1da7dcea..01d122829c740 100644
--- a/src/Workspaces/Core/Portable/Workspace/Host/SyntaxTreeFactory/AbstractSyntaxTreeFactoryService.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Host/SyntaxTreeFactory/AbstractSyntaxTreeFactoryService.cs
@@ -20,16 +20,12 @@ internal abstract partial class AbstractSyntaxTreeFactoryService : ISyntaxTreeFa
 
         internal HostLanguageServices LanguageServices { get; }
 
-        public AbstractSyntaxTreeFactoryService(
-            IGlobalOptionService optionService,
-            HostLanguageServices languageServices)
+        public AbstractSyntaxTreeFactoryService(HostLanguageServices languageServices)
         {
             LanguageServices = languageServices;
 
             var cacheService = languageServices.WorkspaceServices.GetService<IProjectCacheHostService>();
-
-            _minimumLengthForRecoverableTree = (cacheService != null && !optionService.GetOption(WorkspaceConfigurationOptions.DisableRecoverableTrees)) ?
-                cacheService.MinimumLengthForRecoverableTree : int.MaxValue;
+            _minimumLengthForRecoverableTree = (cacheService != null) ? cacheService.MinimumLengthForRecoverableTree : int.MaxValue;
         }
 
         public abstract ParseOptions GetDefaultParseOptions();
diff --git a/src/Workspaces/Core/Portable/Workspace/ISyntaxTreeConfigurationService.cs b/src/Workspaces/Core/Portable/Workspace/ISyntaxTreeConfigurationService.cs
new file mode 100644
index 0000000000000..ac4d8a8265582
--- /dev/null
+++ b/src/Workspaces/Core/Portable/Workspace/ISyntaxTreeConfigurationService.cs
@@ -0,0 +1,14 @@
+// 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.Host;
+
+namespace Microsoft.CodeAnalysis
+{
+    internal interface ISyntaxTreeConfigurationService : IWorkspaceService
+    {
+        bool DisableRecoverableTrees { get; }
+        bool DisableProjectCacheService { get; }
+    }
+}
diff --git a/src/Workspaces/Remote/Core/ServiceHubRemoteHostClient.cs b/src/Workspaces/Remote/Core/ServiceHubRemoteHostClient.cs
index 87b6b64dfbd29..3569e9de6c292 100644
--- a/src/Workspaces/Remote/Core/ServiceHubRemoteHostClient.cs
+++ b/src/Workspaces/Remote/Core/ServiceHubRemoteHostClient.cs
@@ -76,6 +76,14 @@ public static async Task<RemoteHostClient> CreateAsync(
 
                 var client = new ServiceHubRemoteHostClient(services, globalOptions, serviceBrokerClient, hubClient, callbackDispatchers);
 
+                var syntaxTreeConfigurationService = services.GetService<ISyntaxTreeConfigurationService>();
+                if (syntaxTreeConfigurationService != null)
+                {
+                    await client.TryInvokeAsync<IRemoteProcessTelemetryService>(
+                        (service, cancellationToken) => service.SetSyntaxTreeConfigurationOptionsAsync(syntaxTreeConfigurationService.DisableRecoverableTrees, syntaxTreeConfigurationService.DisableProjectCacheService, cancellationToken),
+                        cancellationToken).ConfigureAwait(false);
+                }
+
                 await client.TryInvokeAsync<IRemoteAsynchronousOperationListenerService>(
                     (service, cancellationToken) => service.EnableAsync(AsynchronousOperationListenerProvider.IsEnabled, listenerProvider.DiagnosticTokensEnabled, cancellationToken),
                     cancellationToken).ConfigureAwait(false);
diff --git a/src/Workspaces/Remote/ServiceHub/Services/ProcessTelemetry/RemoteProcessTelemetryService.cs b/src/Workspaces/Remote/ServiceHub/Services/ProcessTelemetry/RemoteProcessTelemetryService.cs
index afb7fefc57c50..d717021f1702d 100644
--- a/src/Workspaces/Remote/ServiceHub/Services/ProcessTelemetry/RemoteProcessTelemetryService.cs
+++ b/src/Workspaces/Remote/ServiceHub/Services/ProcessTelemetry/RemoteProcessTelemetryService.cs
@@ -109,5 +109,19 @@ private static void SetRoslynLogger<T>(ImmutableArray<string> loggerTypes, Func<
                 RoslynLogger.SetLogger(AggregateLogger.Remove(RoslynLogger.GetLogger(), l => l is T));
             }
         }
+
+        /// <summary>
+        /// Remote API.
+        /// </summary>
+        public ValueTask SetSyntaxTreeConfigurationOptionsAsync(bool disableRecoverableTrees, bool disableProjectCacheService, CancellationToken cancellationToken)
+        {
+            return RunServiceAsync(cancellationToken =>
+            {
+                var service = (RemoteSyntaxTreeConfigurationService)GetWorkspaceServices().GetRequiredService<ISyntaxTreeConfigurationService>();
+                service.SetOptions(disableRecoverableTrees, disableProjectCacheService);
+
+                return ValueTaskFactory.CompletedTask;
+            }, cancellationToken);
+        }
     }
 }
diff --git a/src/Workspaces/Remote/ServiceHub/Services/ProcessTelemetry/RemoteSyntaxTreeConfigurationService.cs b/src/Workspaces/Remote/ServiceHub/Services/ProcessTelemetry/RemoteSyntaxTreeConfigurationService.cs
new file mode 100644
index 0000000000000..37f6aac2a3e87
--- /dev/null
+++ b/src/Workspaces/Remote/ServiceHub/Services/ProcessTelemetry/RemoteSyntaxTreeConfigurationService.cs
@@ -0,0 +1,30 @@
+// 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.Composition;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Host.Mef;
+
+namespace Microsoft.VisualStudio.LanguageServices.Telemetry
+{
+    [ExportWorkspaceService(typeof(ISyntaxTreeConfigurationService)), Shared]
+    internal sealed class RemoteSyntaxTreeConfigurationService : ISyntaxTreeConfigurationService
+    {
+        public bool DisableRecoverableTrees { get; private set; }
+        public bool DisableProjectCacheService { get; private set; }
+
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public RemoteSyntaxTreeConfigurationService()
+        {
+        }
+
+        internal void SetOptions(bool disableRecoverableTrees, bool disableProjectCacheService)
+        {
+            DisableRecoverableTrees = disableRecoverableTrees;
+            DisableProjectCacheService = disableProjectCacheService;
+        }
+    }
+}
diff --git a/src/Workspaces/VisualBasic/Portable/Workspace/LanguageServices/VisualBasicSyntaxTreeFactoryService.vb b/src/Workspaces/VisualBasic/Portable/Workspace/LanguageServices/VisualBasicSyntaxTreeFactoryService.vb
index 0b4811deacf2d..516b42105a088 100644
--- a/src/Workspaces/VisualBasic/Portable/Workspace/LanguageServices/VisualBasicSyntaxTreeFactoryService.vb
+++ b/src/Workspaces/VisualBasic/Portable/Workspace/LanguageServices/VisualBasicSyntaxTreeFactoryService.vb
@@ -19,23 +19,21 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         Implements ILanguageServiceFactory
 
         Private Shared ReadOnly _parseOptionsWithLatestLanguageVersion As VisualBasicParseOptions = VisualBasicParseOptions.Default.WithLanguageVersion(LanguageVersion.Latest)
-        Private ReadOnly _optionService As IGlobalOptionService
 
         <ImportingConstructor>
         <Obsolete(MefConstruction.ImportingConstructorMessage, True)>
-        Public Sub New(optionService As IGlobalOptionService)
-            _optionService = optionService
+        Public Sub New()
         End Sub
 
         Public Function CreateLanguageService(provider As HostLanguageServices) As ILanguageService Implements ILanguageServiceFactory.CreateLanguageService
-            Return New VisualBasicSyntaxTreeFactoryService(_optionService, provider)
+            Return New VisualBasicSyntaxTreeFactoryService(provider)
         End Function
 
         Partial Friend Class VisualBasicSyntaxTreeFactoryService
             Inherits AbstractSyntaxTreeFactoryService
 
-            Public Sub New(optionService As IGlobalOptionService, languageServices As HostLanguageServices)
-                MyBase.New(optionService, languageServices)
+            Public Sub New(languageServices As HostLanguageServices)
+                MyBase.New(languageServices)
             End Sub
 
             Public Overloads Overrides Function GetDefaultParseOptions() As ParseOptions

From 7b6b57276d7a27198956beb3a86d7d0db34a0829 Mon Sep 17 00:00:00 2001
From: Rikki Gibson <rigibson@microsoft.com>
Date: Tue, 18 Jan 2022 18:52:58 -0800
Subject: [PATCH 442/444] Handle null coalescing assign-to-self scenarios
 (#58933)

Co-authored-by: CyrusNajmabadi <cyrus.najmabadi@gmail.com>
---
 ...ParameterNullCheckingDiagnosticAnalyzer.cs | 22 +++++++++-----
 ...UseParameterNullCheckingCodeFixProvider.cs | 12 ++++----
 .../UseParameterNullCheckingTests.cs          | 30 ++++++++++++++++++-
 3 files changed, 50 insertions(+), 14 deletions(-)

diff --git a/src/Analyzers/CSharp/Analyzers/UseParameterNullChecking/CSharpUseParameterNullCheckingDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseParameterNullChecking/CSharpUseParameterNullCheckingDiagnosticAnalyzer.cs
index db85ff5cdea6a..66bc65f0c0ce1 100644
--- a/src/Analyzers/CSharp/Analyzers/UseParameterNullChecking/CSharpUseParameterNullCheckingDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseParameterNullChecking/CSharpUseParameterNullCheckingDiagnosticAnalyzer.cs
@@ -141,15 +141,15 @@ private void AnalyzeSyntax(
 
             foreach (var statement in block.Statements)
             {
-                var parameter = TryGetParameterNullCheckedByStatement(statement);
-                if (ParameterCanUseNullChecking(parameter)
+                if (TryGetParameterNullCheckedByStatement(statement) is var (parameter, diagnosticLocation)
+                    && ParameterCanUseNullChecking(parameter)
                     && parameter.DeclaringSyntaxReferences.FirstOrDefault() is SyntaxReference reference
                     && reference.SyntaxTree.Equals(statement.SyntaxTree)
                     && reference.GetSyntax() is ParameterSyntax parameterSyntax)
                 {
                     context.ReportDiagnostic(DiagnosticHelper.Create(
                         Descriptor,
-                        statement.GetLocation(),
+                        diagnosticLocation,
                         option.Notification.Severity,
                         additionalLocations: new[] { parameterSyntax.GetLocation() },
                         properties: null));
@@ -175,7 +175,7 @@ bool ParameterCanUseNullChecking([NotNullWhen(true)] IParameterSymbol? parameter
                 return true;
             }
 
-            IParameterSymbol? TryGetParameterNullCheckedByStatement(StatementSyntax statement)
+            (IParameterSymbol parameter, Location diagnosticLocation)? TryGetParameterNullCheckedByStatement(StatementSyntax statement)
             {
                 switch (statement)
                 {
@@ -229,18 +229,19 @@ when semanticModel.GetSymbolInfo(binary).Symbol is IMethodSymbol { MethodKind: M
                             return null;
                         }
 
-                        return parameterInBinary;
+                        return (parameterInBinary, ifStatement.GetLocation());
 
                     // this.field = param ?? throw new ArgumentNullException(nameof(param));
                     case ExpressionStatementSyntax
                     {
                         Expression: AssignmentExpressionSyntax
                         {
+                            Left: var leftOfAssignment,
                             Right: BinaryExpressionSyntax
                             {
                                 OperatorToken.RawKind: (int)SyntaxKind.QuestionQuestionToken,
                                 Left: ExpressionSyntax maybeParameter,
-                                Right: ThrowExpressionSyntax { Expression: ObjectCreationExpressionSyntax thrownInNullCoalescing }
+                                Right: ThrowExpressionSyntax { Expression: ObjectCreationExpressionSyntax thrownInNullCoalescing } throwExpression
                             }
                         }
                     }:
@@ -250,7 +251,14 @@ when semanticModel.GetSymbolInfo(binary).Symbol is IMethodSymbol { MethodKind: M
                             return null;
                         }
 
-                        return coalescedParameter;
+                        // ensure we delete the entire statement in the below scenario:
+                        //     void M(string s) { s = s ?? throw new ArgumentNullException(); }
+                        // otherwise, we just replace the '??' expression with its left operand
+                        var diagnosticLocation = coalescedParameter.Equals(semanticModel.GetSymbolInfo(leftOfAssignment, cancellationToken).Symbol)
+                            ? statement.GetLocation()
+                            : throwExpression.GetLocation();
+
+                        return (coalescedParameter, diagnosticLocation);
 
                     default:
                         return null;
diff --git a/src/Analyzers/CSharp/CodeFixes/UseParameterNullChecking/CSharpUseParameterNullCheckingCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/UseParameterNullChecking/CSharpUseParameterNullCheckingCodeFixProvider.cs
index 5bc8f3a915a18..6da8f754e67b9 100644
--- a/src/Analyzers/CSharp/CodeFixes/UseParameterNullChecking/CSharpUseParameterNullCheckingCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/UseParameterNullChecking/CSharpUseParameterNullCheckingCodeFixProvider.cs
@@ -9,6 +9,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editing;
@@ -54,16 +55,15 @@ protected override Task FixAllAsync(
                 var node = diagnostic.Location.FindNode(getInnermostNodeForTie: true, cancellationToken: cancellationToken);
                 switch (node)
                 {
-                    case IfStatementSyntax ifStatement:
-                        editor.RemoveNode(ifStatement);
-                        break;
-                    case ExpressionStatementSyntax expressionStatement:
+                    case ExpressionSyntax { Parent: BinaryExpressionSyntax(SyntaxKind.CoalesceExpression) nullCoalescing }:
                         // this.item = item ?? throw new ArgumentNullException(nameof(item));
-                        var assignment = (AssignmentExpressionSyntax)expressionStatement.Expression;
-                        var nullCoalescing = (BinaryExpressionSyntax)assignment.Right;
                         var parameterReferenceSyntax = nullCoalescing.Left;
                         editor.ReplaceNode(nullCoalescing, parameterReferenceSyntax.WithAppendedTrailingTrivia(SyntaxFactory.ElasticMarker));
                         break;
+                    case IfStatementSyntax:
+                    case ExpressionStatementSyntax { Expression: AssignmentExpressionSyntax { Right: BinaryExpressionSyntax(SyntaxKind.CoalesceExpression) } }:
+                        editor.RemoveNode(node);
+                        break;
                     default:
                         throw ExceptionUtilities.UnexpectedValue(node);
                 }
diff --git a/src/Analyzers/CSharp/Tests/UseParameterNullChecking/UseParameterNullCheckingTests.cs b/src/Analyzers/CSharp/Tests/UseParameterNullChecking/UseParameterNullCheckingTests.cs
index bc69220f51600..30f799355e4ba 100644
--- a/src/Analyzers/CSharp/Tests/UseParameterNullChecking/UseParameterNullCheckingTests.cs
+++ b/src/Analyzers/CSharp/Tests/UseParameterNullChecking/UseParameterNullCheckingTests.cs
@@ -192,7 +192,7 @@ class C
     private readonly string s;
     public C(string s)
     {
-        [|this.s = s ?? throw new ArgumentNullException(nameof(s));|]
+        this.s = s ?? [|throw new ArgumentNullException(nameof(s))|];
     }
 }",
                 FixedCode = @"
@@ -210,6 +210,34 @@ public C(string s!!)
             }.RunAsync();
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestNullCoalescingThrow_AssignSameVariable()
+        {
+            await new VerifyCS.Test()
+            {
+                TestCode = @"
+using System;
+
+class C
+{
+    public void M(string s)
+    {
+        [|s = s ?? throw new ArgumentNullException(nameof(s));|]
+    }
+}",
+                FixedCode = @"
+using System;
+
+class C
+{
+    public void M(string s!!)
+    {
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
         public async Task TestOperator()
         {

From 259a9e27ab8c6a1d8d3a3445b079fd5e3a13ec0a Mon Sep 17 00:00:00 2001
From: "dotnet-maestro[bot]"
 <42748379+dotnet-maestro[bot]@users.noreply.github.com>
Date: Wed, 19 Jan 2022 14:53:37 +0000
Subject: [PATCH 443/444] Update dependencies from
 https://github.com/dotnet/arcade build 20220118.3 (#58944)

[main] Update dependencies from dotnet/arcade
---
 eng/Version.Details.xml                     | 8 ++++----
 eng/common/templates/steps/source-build.yml | 2 +-
 global.json                                 | 4 ++--
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index 8ca96d14c6cc9..17d6542bdc20c 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -13,18 +13,18 @@
     </Dependency>
   </ProductDependencies>
   <ToolsetDependencies>
-    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="7.0.0-beta.22067.1">
+    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="7.0.0-beta.22068.3">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>3fb1f4bbc1f2cdd26071764132a3592eceab63fe</Sha>
+      <Sha>9ffc76ac9f5799de9b28ee59f9bfbe0f8844d0d7</Sha>
       <SourceBuild RepoName="arcade" ManagedOnly="true" />
     </Dependency>
     <Dependency Name="Microsoft.Net.Compilers.Toolset" Version="4.1.0-3.22062.11">
       <Uri>https://github.com/dotnet/roslyn</Uri>
       <Sha>cc0d213b15fdda217ad888d269d19754fa556eb4</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="7.0.0-beta.22067.1">
+    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="7.0.0-beta.22068.3">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>3fb1f4bbc1f2cdd26071764132a3592eceab63fe</Sha>
+      <Sha>9ffc76ac9f5799de9b28ee59f9bfbe0f8844d0d7</Sha>
     </Dependency>
   </ToolsetDependencies>
 </Dependencies>
diff --git a/eng/common/templates/steps/source-build.yml b/eng/common/templates/steps/source-build.yml
index ba40dc82f1411..d85d6d07d5c7b 100644
--- a/eng/common/templates/steps/source-build.yml
+++ b/eng/common/templates/steps/source-build.yml
@@ -23,7 +23,7 @@ steps:
     # In addition, add an msbuild argument to copy the WIP from the repo to the target build location.
     # This is because SetupNuGetSources.sh will alter the current NuGet.config file, and we need to preserve those
     # changes.
-    $internalRestoreArgs=
+    internalRestoreArgs=
     if [ '$(dn-bot-dnceng-artifact-feeds-rw)' != '$''(dn-bot-dnceng-artifact-feeds-rw)' ]; then
       # Temporarily work around https://github.com/dotnet/arcade/issues/7709
       chmod +x $(Build.SourcesDirectory)/eng/common/SetupNugetSources.sh
diff --git a/global.json b/global.json
index 84e7dcb8c1b80..3b4f034197c04 100644
--- a/global.json
+++ b/global.json
@@ -12,7 +12,7 @@
     "xcopy-msbuild": "16.10.0-preview2"
   },
   "msbuild-sdks": {
-    "Microsoft.DotNet.Arcade.Sdk": "7.0.0-beta.22067.1",
-    "Microsoft.DotNet.Helix.Sdk": "7.0.0-beta.22067.1"
+    "Microsoft.DotNet.Arcade.Sdk": "7.0.0-beta.22068.3",
+    "Microsoft.DotNet.Helix.Sdk": "7.0.0-beta.22068.3"
   }
 }

From 0ada814b01c5a9245629b64392c72472bae4366c Mon Sep 17 00:00:00 2001
From: Rikki Gibson <rigibson@microsoft.com>
Date: Wed, 19 Jan 2022 12:09:01 -0800
Subject: [PATCH 444/444] Allow 'ref' and 'in' parameters to be null-checked
 (#58938)

---
 ...ParameterNullCheckingDiagnosticAnalyzer.cs |  2 +-
 .../UseParameterNullCheckingTests.cs          | 34 ++++++-
 .../CSharp/Portable/CSharpResources.resx      |  4 +-
 .../CSharp/Portable/Errors/ErrorCode.cs       |  2 +-
 .../Symbols/Source/ParameterHelpers.cs        |  4 +-
 .../Portable/xlf/CSharpResources.cs.xlf       |  6 +-
 .../Portable/xlf/CSharpResources.de.xlf       |  6 +-
 .../Portable/xlf/CSharpResources.es.xlf       |  6 +-
 .../Portable/xlf/CSharpResources.fr.xlf       |  6 +-
 .../Portable/xlf/CSharpResources.it.xlf       |  6 +-
 .../Portable/xlf/CSharpResources.ja.xlf       |  6 +-
 .../Portable/xlf/CSharpResources.ko.xlf       |  6 +-
 .../Portable/xlf/CSharpResources.pl.xlf       |  6 +-
 .../Portable/xlf/CSharpResources.pt-BR.xlf    |  6 +-
 .../Portable/xlf/CSharpResources.ru.xlf       |  6 +-
 .../Portable/xlf/CSharpResources.tr.xlf       |  6 +-
 .../Portable/xlf/CSharpResources.zh-Hans.xlf  |  6 +-
 .../Portable/xlf/CSharpResources.zh-Hant.xlf  |  6 +-
 .../CodeGenNullCheckedParameterTests.cs       | 93 +++++++++++++++++++
 .../Semantics/NullCheckedParameterTests.cs    | 14 +--
 20 files changed, 172 insertions(+), 59 deletions(-)

diff --git a/src/Analyzers/CSharp/Analyzers/UseParameterNullChecking/CSharpUseParameterNullCheckingDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseParameterNullChecking/CSharpUseParameterNullCheckingDiagnosticAnalyzer.cs
index 66bc65f0c0ce1..e28d2fdab642a 100644
--- a/src/Analyzers/CSharp/Analyzers/UseParameterNullChecking/CSharpUseParameterNullCheckingDiagnosticAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analyzers/UseParameterNullChecking/CSharpUseParameterNullCheckingDiagnosticAnalyzer.cs
@@ -163,7 +163,7 @@ bool ParameterCanUseNullChecking([NotNullWhen(true)] IParameterSymbol? parameter
                 if (parameter is null)
                     return false;
 
-                if (parameter.RefKind != RefKind.None)
+                if (parameter.RefKind == RefKind.Out)
                     return false;
 
                 if (parameter.Type.IsValueType)
diff --git a/src/Analyzers/CSharp/Tests/UseParameterNullChecking/UseParameterNullCheckingTests.cs b/src/Analyzers/CSharp/Tests/UseParameterNullChecking/UseParameterNullCheckingTests.cs
index 30f799355e4ba..2b8b1aab81723 100644
--- a/src/Analyzers/CSharp/Tests/UseParameterNullChecking/UseParameterNullCheckingTests.cs
+++ b/src/Analyzers/CSharp/Tests/UseParameterNullChecking/UseParameterNullCheckingTests.cs
@@ -579,17 +579,43 @@ public C(string s!!)
         [Theory, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
         [InlineData("ref")]
         [InlineData("in")]
-        [InlineData("out")]
         public async Task TestRefParameter(string refKind)
         {
-            // https://github.com/dotnet/roslyn/issues/58699
-            // When the implementation changes to permit ref/in parameters, we should also change the fixer.
-            var testCode = @"
+            await new VerifyCS.Test()
+            {
+                TestCode = @"
 using System;
 
 class C
 {
     public C(" + refKind + @" string s)
+    {
+        [|if (s is null)
+            throw new ArgumentNullException(nameof(s));|]
+    }
+}",
+                FixedCode = @"
+using System;
+
+class C
+{
+    public C(" + refKind + @" string s!!)
+    {
+    }
+}",
+                LanguageVersion = LanguageVersionExtensions.CSharpNext
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestOutParameter()
+        {
+            var testCode = @"
+using System;
+
+class C
+{
+    public C(out string s)
     {
         if (s is null)
             throw new ArgumentNullException(nameof(s));
diff --git a/src/Compilers/CSharp/Portable/CSharpResources.resx b/src/Compilers/CSharp/Portable/CSharpResources.resx
index 4ce105b21ba20..c4557d6b39a7e 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.resx
+++ b/src/Compilers/CSharp/Portable/CSharpResources.resx
@@ -6184,8 +6184,8 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="WRN_NullCheckedHasDefaultNull_Title" xml:space="preserve">
     <value>Parameter is null-checked but is null by default.</value>
   </data>
-  <data name="ERR_NullCheckingOnByRefParameter" xml:space="preserve">
-    <value>By-reference parameter '{0}' cannot be null-checked.</value>
+  <data name="ERR_NullCheckingOnOutParameter" xml:space="preserve">
+    <value>'out' parameter '{0}' cannot be null-checked.</value>
   </data>
   <data name="WRN_NullCheckingOnNullableType" xml:space="preserve">
     <value>Nullable type '{0}' is null-checked and will throw if null.</value>
diff --git a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
index 331a67db4e803..450c5f645296b 100644
--- a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
+++ b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
@@ -2024,7 +2024,7 @@ internal enum ErrorCode
         ERR_MustNullCheckInImplementation = 8991,
         ERR_NonNullableValueTypeIsNullChecked = 8992,
         WRN_NullCheckedHasDefaultNull = 8993,
-        ERR_NullCheckingOnByRefParameter = 8994,
+        ERR_NullCheckingOnOutParameter = 8994,
         WRN_NullCheckingOnNullableType = 8995,
 
         #endregion
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs b/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs
index fd74d30be3164..d473e4053ad4f 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs
@@ -138,9 +138,9 @@ private static ImmutableArray<TParameterSymbol> MakeParameters<TParameterSyntax,
                 CheckParameterModifiers(parameterSyntax, diagnostics, parsingFunctionPointer);
 
                 var refKind = GetModifiers(parameterSyntax.Modifiers, out SyntaxToken refnessKeyword, out SyntaxToken paramsKeyword, out SyntaxToken thisKeyword);
-                if (refKind != RefKind.None && parameterSyntax is ParameterSyntax { ExclamationExclamationToken: var exExToken, Identifier: var identifier } && exExToken.Kind() != SyntaxKind.None)
+                if (refKind == RefKind.Out && parameterSyntax is ParameterSyntax { ExclamationExclamationToken: var exExToken, Identifier: var identifier } && exExToken.Kind() != SyntaxKind.None)
                 {
-                    diagnostics.Add(ErrorCode.ERR_NullCheckingOnByRefParameter, exExToken.GetLocation(), identifier.ValueText);
+                    diagnostics.Add(ErrorCode.ERR_NullCheckingOnOutParameter, exExToken.GetLocation(), identifier.ValueText);
                 }
                 if (thisKeyword.Kind() != SyntaxKind.None && !allowThis)
                 {
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
index 631838d583f12..3578b08227659 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
@@ -937,9 +937,9 @@
         <target state="translated">{0} musí povolovat přepisování, protože obsahující záznam není zapečetěný.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_NullCheckingOnByRefParameter">
-        <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="translated">Parametr podle odkazu '{0}' nemůže mít hodnotu null.</target>
+      <trans-unit id="ERR_NullCheckingOnOutParameter">
+        <source>'out' parameter '{0}' cannot be null-checked.</source>
+        <target state="new">'out' parameter '{0}' cannot be null-checked.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
index ffe0c045101e5..3552cd59655ad 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
@@ -937,9 +937,9 @@
         <target state="translated">"{0}" muss Überschreibungen zulassen, weil der enthaltende Datensatz nicht versiegelt ist.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_NullCheckingOnByRefParameter">
-        <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="translated">Der Verweisparameter „{0}“ kann nicht auf NULL-Werte überprüft werden.</target>
+      <trans-unit id="ERR_NullCheckingOnOutParameter">
+        <source>'out' parameter '{0}' cannot be null-checked.</source>
+        <target state="new">'out' parameter '{0}' cannot be null-checked.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
index baea85297e2eb..0279642185344 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
@@ -937,9 +937,9 @@
         <target state="translated">"{0}" debe permitir la invalidación porque el registro contenedor no está sellado.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_NullCheckingOnByRefParameter">
-        <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="translated">El parámetro por referencia '{0}' no se puede comprobar con valores NULL.</target>
+      <trans-unit id="ERR_NullCheckingOnOutParameter">
+        <source>'out' parameter '{0}' cannot be null-checked.</source>
+        <target state="new">'out' parameter '{0}' cannot be null-checked.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
index 70de3a1bd8a61..4a85719407556 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
@@ -937,9 +937,9 @@
         <target state="translated">'{0}' doit autoriser la substitution, car l'enregistrement contenant n'est pas sealed.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_NullCheckingOnByRefParameter">
-        <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="translated">Le paramètre par référence '{0}' ne peut pas faire l’objet d’une vérification de valeur Null.</target>
+      <trans-unit id="ERR_NullCheckingOnOutParameter">
+        <source>'out' parameter '{0}' cannot be null-checked.</source>
+        <target state="new">'out' parameter '{0}' cannot be null-checked.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
index 5405b1ee6c037..a9b269f4d63bf 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
@@ -937,9 +937,9 @@
         <target state="translated">'{0}' deve consentire l'override perché il record contenitore non è sealed.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_NullCheckingOnByRefParameter">
-        <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="translated">Il parametro '{0}' per riferimento non può essere controllato Null.</target>
+      <trans-unit id="ERR_NullCheckingOnOutParameter">
+        <source>'out' parameter '{0}' cannot be null-checked.</source>
+        <target state="new">'out' parameter '{0}' cannot be null-checked.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
index deeb9c0cef0e3..2184b01594d64 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
@@ -937,9 +937,9 @@
         <target state="translated">'{0}' ではオーバーライドを許可する必要があります。これが含まれているレコードが sealed ではないためです。</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_NullCheckingOnByRefParameter">
-        <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="translated">参照渡しパラメーター '{0}' を null チェックすることはできません。</target>
+      <trans-unit id="ERR_NullCheckingOnOutParameter">
+        <source>'out' parameter '{0}' cannot be null-checked.</source>
+        <target state="new">'out' parameter '{0}' cannot be null-checked.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
index 436250047233a..56fe083f974e4 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
@@ -937,9 +937,9 @@
         <target state="translated">포함된 레코드가 봉인되지 않았으므로 '{0}'은(는) 재정의를 허용해야 합니다.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_NullCheckingOnByRefParameter">
-        <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="translated">참조 기준 매개 변수 '{0}'을(를) Null로 확인할 수 없습니다.</target>
+      <trans-unit id="ERR_NullCheckingOnOutParameter">
+        <source>'out' parameter '{0}' cannot be null-checked.</source>
+        <target state="new">'out' parameter '{0}' cannot be null-checked.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
index cd1840eab38e3..9f96d4745d092 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
@@ -937,9 +937,9 @@
         <target state="translated">Element „{0}” musi zezwalać na przesłanianie, ponieważ zawierający go rekord nie jest zapieczętowany.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_NullCheckingOnByRefParameter">
-        <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="translated">Parametru referencyjny „{0}” nie może zostać sprawdzony przy użyciu wartości null.</target>
+      <trans-unit id="ERR_NullCheckingOnOutParameter">
+        <source>'out' parameter '{0}' cannot be null-checked.</source>
+        <target state="new">'out' parameter '{0}' cannot be null-checked.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
index 1624f30e16bf4..e54bd3baee10d 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
@@ -937,9 +937,9 @@
         <target state="translated">'{0}' precisa permitir a substituição porque o registro contentor não está selado.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_NullCheckingOnByRefParameter">
-        <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="translated">O parâmetro por referência '{0}' não pode ser verificado com o valor nulo.</target>
+      <trans-unit id="ERR_NullCheckingOnOutParameter">
+        <source>'out' parameter '{0}' cannot be null-checked.</source>
+        <target state="new">'out' parameter '{0}' cannot be null-checked.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
index d75ad04596278..d82f4492a76ac 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
@@ -937,9 +937,9 @@
         <target state="translated">"{0}" должен допускать переопределение, поскольку содержащая его запись не является запечатанной.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_NullCheckingOnByRefParameter">
-        <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="translated">Для параметра по ссылке "{0}" невозможно проверить значение NULL.</target>
+      <trans-unit id="ERR_NullCheckingOnOutParameter">
+        <source>'out' parameter '{0}' cannot be null-checked.</source>
+        <target state="new">'out' parameter '{0}' cannot be null-checked.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
index 7d7500ca26a02..3e64ce4e66c7b 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
@@ -937,9 +937,9 @@
         <target state="translated">'{0}', kapsayan kayıt mühürlü olmadığından geçersiz kılmaya izin vermelidir.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_NullCheckingOnByRefParameter">
-        <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="translated">Başvuru parametresine göre “{0}” için null denetimi yapılamaz.</target>
+      <trans-unit id="ERR_NullCheckingOnOutParameter">
+        <source>'out' parameter '{0}' cannot be null-checked.</source>
+        <target state="new">'out' parameter '{0}' cannot be null-checked.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
index a22bb02fc5830..7bb00b0d32b31 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
@@ -937,9 +937,9 @@
         <target state="translated">“{0}”必须允许替代，因为包含的记录未密封。</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_NullCheckingOnByRefParameter">
-        <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="translated">不能对按地址引用参数 "{0}" 进行 null 检查。</target>
+      <trans-unit id="ERR_NullCheckingOnOutParameter">
+        <source>'out' parameter '{0}' cannot be null-checked.</source>
+        <target state="new">'out' parameter '{0}' cannot be null-checked.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
index 3712d68d119c6..b5e0be75daeab 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
@@ -937,9 +937,9 @@
         <target state="translated">'{0}' 必須允許覆寫，因為包含的記錄並未密封。</target>
         <note />
       </trans-unit>
-      <trans-unit id="ERR_NullCheckingOnByRefParameter">
-        <source>By-reference parameter '{0}' cannot be null-checked.</source>
-        <target state="translated">參考類參數 '{0}' 不能檢查是否為 Null。</target>
+      <trans-unit id="ERR_NullCheckingOnOutParameter">
+        <source>'out' parameter '{0}' cannot be null-checked.</source>
+        <target state="new">'out' parameter '{0}' cannot be null-checked.</target>
         <note />
       </trans-unit>
       <trans-unit id="ERR_NullInvalidInterpolatedStringHandlerArgumentName">
diff --git a/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenNullCheckedParameterTests.cs b/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenNullCheckedParameterTests.cs
index cd14d272e8954..1a2d9ed14b9e1 100644
--- a/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenNullCheckedParameterTests.cs
+++ b/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenNullCheckedParameterTests.cs
@@ -2352,5 +2352,98 @@ .locals init (C.<M>d__0 V_0)
 }
 ");
         }
+
+        [Fact]
+        public void TestNullCheckedRefString()
+        {
+            var source = @"
+using System;
+
+class C
+{
+    public static void Main()
+    {
+        var s = ""1"";
+        Console.Write(s);
+        M(ref s);
+        Console.Write(s);
+        s = null;
+        try
+        {
+            M(ref s!);
+            Console.Write(0);
+        }
+        catch (ArgumentNullException)
+        {
+            Console.Write(3);
+        }
+    }
+
+    public static void M(ref string x!!)
+    {
+        x = ""2"";
+    }
+}";
+            var verifier = CompileAndVerify(source, parseOptions: TestOptions.RegularPreview, expectedOutput: "123");
+            verifier.VerifyDiagnostics();
+
+            verifier.VerifyIL("C.M", @"
+{
+  // Code size       20 (0x14)
+  .maxstack  2
+  IL_0000:  ldarg.0
+  IL_0001:  ldind.ref
+  IL_0002:  ldstr      ""x""
+  IL_0007:  call       ""ThrowIfNull""
+  IL_000c:  ldarg.0
+  IL_000d:  ldstr      ""2""
+  IL_0012:  stind.ref
+  IL_0013:  ret
+}");
+        }
+
+        [Fact]
+        public void TestNullCheckedInString()
+        {
+            var source = @"
+using System;
+
+class C
+{
+    public static void Main()
+    {
+        var s = ""1"";
+        Console.Write(s);
+        M(in s);
+        s = null;
+        try
+        {
+            M(in s!);
+            Console.Write(0);
+        }
+        catch (ArgumentNullException)
+        {
+            Console.Write(2);
+        }
+    }
+
+    public static void M(in string x!!)
+    {
+    }
+}";
+            var verifier = CompileAndVerify(source, parseOptions: TestOptions.RegularPreview, expectedOutput: "12");
+            verifier.VerifyDiagnostics();
+
+            verifier.VerifyIL("C.M", @"
+{
+  // Code size       13 (0xd)
+  .maxstack  2
+  IL_0000:  ldarg.0
+  IL_0001:  ldind.ref
+  IL_0002:  ldstr      ""x""
+  IL_0007:  call       ""ThrowIfNull""
+  IL_000c:  ret
+}");
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs
index 11099313ee706..66aa80df46fd6 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/NullCheckedParameterTests.cs
@@ -680,9 +680,9 @@ public void M(out string x!!)
 }";
             var compilation = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
             compilation.VerifyDiagnostics(
-                    // (5,31): error CS8720: By-reference parameter 'x' cannot be null-checked.
+                    // (5,31): error CS8994: 'out' parameter 'x' cannot be null-checked.
                     //     public void M(out string x!!)
-                    Diagnostic(ErrorCode.ERR_NullCheckingOnByRefParameter, "!!").WithArguments("x").WithLocation(5, 31));
+                    Diagnostic(ErrorCode.ERR_NullCheckingOnOutParameter, "!!").WithArguments("x").WithLocation(5, 31));
         }
 
         [Fact]
@@ -698,10 +698,7 @@ public void M(ref string x!!)
     }
 }";
             var compilation = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
-            compilation.VerifyDiagnostics(
-                    // (5,31): error CS8720: By-reference parameter 'x' cannot be null-checked.
-                    //     public void M(ref string x!!)
-                    Diagnostic(ErrorCode.ERR_NullCheckingOnByRefParameter, "!!").WithArguments("x").WithLocation(5, 31));
+            compilation.VerifyDiagnostics();
         }
 
         [Fact]
@@ -714,10 +711,7 @@ public static void Main() { }
     public void M(in string x!!) { }
 }";
             var compilation = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
-            compilation.VerifyDiagnostics(
-                    // (5,30): error CS8720: By-reference parameter 'x' cannot be null-checked.
-                    //     public void M(in string x!!) { }
-                    Diagnostic(ErrorCode.ERR_NullCheckingOnByRefParameter, "!!").WithArguments("x").WithLocation(5, 30));
+            compilation.VerifyDiagnostics();
         }
 
         [Fact]